Changeset 142


Ignore:
Timestamp:
Dec 11, 2008, 11:57:03 AM (13 years ago)
Author:
Gerhard Junker
Message:

Tiger: Plugin ready

Location:
trunk/CrypPlugins
Files:
2 added
4 edited
1 copied

Legend:

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

    r141 r142  
    3535
    3636        [Author("Gerhard Junker", null, "private project member", "http://www.uni-siegen.de")]
    37         [PluginInfo(false, "Tiger", "Tiger V1.0.2 Hash", "", "Tiger/Tiger.png")]
     37        [PluginInfo(false, "Tiger", "Tiger2 V1.0.2 Hash", "", "Tiger/Tiger1.png")]
    3838        public class Tiger : IHash
    3939        {
     
    7474                /// </summary>
    7575                /// <value>The settings.</value>
    76                 public ISettings Settings
    77                 {
    78                         get
    79                         {
    80                                 return settings;
    81                         }
    82                         set
    83                         {
    84                                 settings = (TigerSettings)value;
    85                                 OnPropertyChanged("Settings");
    86                                 GuiLogMessage("Settings changed.", NotificationLevel.Debug);
    87                         }
    88                 }
     76    public ISettings Settings
     77    {
     78      get
     79      {
     80        return settings;
     81      }
     82      set
     83      {
     84        settings = (TigerSettings)value;
     85        OnPropertyChanged("Settings");
     86        GuiLogMessage("Settings changed.", NotificationLevel.Debug);
     87      }
     88    }
    8989
    9090                /// <summary>
     
    110110                #endregion
    111111
    112                 #region Input key / password
    113 
    114                 // Input key
    115                 private byte[] key = { };
    116                 private dataCanal keyCanal = dataCanal.none;
     112                #region Input inputdata / password
     113
     114                // Input inputdata
     115                private byte[] inputdata = { };
     116                private dataCanal inputCanal = dataCanal.none;
    117117
    118118                /// <summary>
    119119                /// Notifies the update input.
    120120                /// </summary>
    121                 private void NotifyUpdateKey()
    122                 {
    123                         OnPropertyChanged("KeyStream");
    124                         OnPropertyChanged("KeyData");
    125                 }
    126 
    127                 /// <summary>
    128                 /// Gets or sets the input data.
    129                 /// </summary>
    130                 /// <value>The input key.</value>
    131                 [PropertyInfo(Direction.Input, "Key Stream", "Key stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    132                 public CryptoolStream KeyStream
    133                 {
    134                         get
    135                         {
    136                                 CryptoolStream keyDataStream = new CryptoolStream();
    137                                 keyDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, key);
    138                                 return keyDataStream;
     121                private void NotifyUpdateInput()
     122                {
     123                        OnPropertyChanged("InputStream");
     124                        OnPropertyChanged("InputData");
     125                }
     126
     127                /// <summary>
     128                /// Gets or sets the input inputdata.
     129                /// </summary>
     130                /// <value>The input inputdata.</value>
     131                [PropertyInfo(Direction.Input, "Input Data Stream", "Input data stream to be hashed", "",
     132      false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     133                public CryptoolStream InputStream
     134                {
     135                        get
     136                        {
     137                                CryptoolStream inputStream = new CryptoolStream();
     138                                inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, inputdata);
     139                                return inputStream;
    139140                        }
    140141                        set
     
    143144                                        return;
    144145
    145                                 if (keyCanal != dataCanal.none && keyCanal != dataCanal.streamCanal)
    146                                         GuiLogMessage("Duplicate input key not allowed!", NotificationLevel.Error);
    147                                 keyCanal = dataCanal.streamCanal;
     146                                if (inputCanal != dataCanal.none && inputCanal != dataCanal.streamCanal)
     147                                        GuiLogMessage("Duplicate input data not allowed!", NotificationLevel.Error);
     148                                inputCanal = dataCanal.streamCanal;
    148149
    149150                                long len = value.Length;
    150                                 key = new byte[len];
     151                                inputdata = new byte[len];
    151152
    152153                                for (long i = 0; i < len; i++)
    153                                         key[i] = (byte)value.ReadByte();
    154 
    155                                 NotifyUpdateKey();
    156                                 GuiLogMessage("KeyStream changed.", NotificationLevel.Debug);
     154                                        inputdata[i] = (byte)value.ReadByte();
     155
     156                                NotifyUpdateInput();
     157                                GuiLogMessage("InputStream changed.", NotificationLevel.Debug);
    157158                        }
    158159                }
     
    162163                /// </summary>
    163164                /// <value>The input data.</value>
    164                 [PropertyInfo(Direction.Input, "Key Data", "Key stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    165                 public byte[] KeyData
    166                 {
    167                         get
    168                         {
    169                                 return key;
     165                [PropertyInfo(Direction.Input, "Input Data", "Input Data to be hashed", "",
     166      false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     167                public byte[] InputData
     168                {
     169                        get
     170                        {
     171                                return inputdata;
    170172                        }
    171173                        set
    172174                        {
    173                                 if (keyCanal != dataCanal.none && keyCanal != dataCanal.byteCanal)
    174                                         GuiLogMessage("Duplicate key data not allowed!", NotificationLevel.Error);
    175                                 keyCanal = dataCanal.byteCanal;
     175                                if (inputCanal != dataCanal.none && inputCanal != dataCanal.byteCanal)
     176                                        GuiLogMessage("Duplicate Data data not allowed!", NotificationLevel.Error);
     177                                inputCanal = dataCanal.byteCanal;
    176178
    177179                                long len = value.Length;
    178                                 key = new byte[len];
     180                                inputdata = new byte[len];
    179181
    180182                                for (long i = 0; i < len; i++)
    181                                         key[i] = value[i];
    182 
    183                                 NotifyUpdateKey();
    184                                 GuiLogMessage("KeyData changed.", NotificationLevel.Debug);
    185                         }
    186                 }
    187                 #endregion
    188 
    189                 #region Salt data / Seed data
    190 
    191                 // Salt Data
    192                 private byte[] salt = { };
    193                 private dataCanal saltCanal = dataCanal.none;
    194 
    195                 /// <summary>
    196                 /// Notifies the update salt.
    197                 /// </summary>
    198                 private void NotifyUpdateSalt()
    199                 {
    200                         OnPropertyChanged("SaltStream");
    201                         OnPropertyChanged("SaltData");
    202                 }
    203 
    204                 /// <summary>
    205                 /// Gets or sets the salt data.
    206                 /// </summary>
    207                 /// <value>The salt data.</value>
    208                 [PropertyInfo(Direction.Input, "Salt Stream", "Salt - Input salt data to change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    209                 public CryptoolStream SaltStream
    210                 {
    211                         get
    212                         {
    213                                 CryptoolStream saltDataStream = new CryptoolStream();
    214                                 saltDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, salt);
    215                                 return saltDataStream;
    216                         }
    217                         set
    218                         {
    219                                 if (null == value)
    220                                         return;
    221 
    222                                 if (saltCanal != dataCanal.none && saltCanal != dataCanal.streamCanal)
    223                                         GuiLogMessage("Duplicate salt input not allowed!", NotificationLevel.Error);
    224                                 saltCanal = dataCanal.streamCanal;
    225 
    226                                 long len = value.Length;
    227                                 salt = new byte[len];
    228 
    229                                 for (long i = 0; i < len; i++)
    230                                         salt[i] = (byte)value.ReadByte();
    231 
    232                                 NotifyUpdateSalt();
    233                                 GuiLogMessage("SaltStream changed.", NotificationLevel.Debug);
    234                         }
    235                 }
    236 
    237                 /// <summary>
    238                 /// Gets or sets the salt data.
    239                 /// </summary>
    240                 /// <value>The salt data.</value>
    241                 [PropertyInfo(Direction.Input, "Salt Data", "Salt - Input salt data to to be change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    242                 public byte[] SaltData
    243                 {
    244                         get
    245                         {
    246                                 return salt;
    247                         }
    248 
    249                         set
    250                         {
    251                                 if (saltCanal != dataCanal.none && saltCanal != dataCanal.byteCanal)
    252                                         GuiLogMessage("Duplicate salt input not allowed!", NotificationLevel.Error);
    253                                 saltCanal = dataCanal.byteCanal;
    254 
    255                                 long len = value.Length;
    256                                 salt = new byte[len];
    257 
    258                                 for (long i = 0; i < len; i++)
    259                                         salt[i] = value[i];
    260 
    261                                 NotifyUpdateSalt();
    262                                 GuiLogMessage("SaltData changed.", NotificationLevel.Debug);
     183                                        inputdata[i] = value[i];
     184
     185                                NotifyUpdateInput();
     186                                GuiLogMessage("InputData changed.", NotificationLevel.Debug);
    263187                        }
    264188                }
     
    282206
    283207                /// <summary>
    284                 /// Gets or sets the output data stream.
    285                 /// </summary>
    286                 /// <value>The output data stream.</value>
     208                /// Gets or sets the output inputdata stream.
     209                /// </summary>
     210                /// <value>The output inputdata stream.</value>
    287211                [PropertyInfo(Direction.Output, "Hashed Stream", "Output stream of the hashed value", "",
    288212                        true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     
    307231
    308232                /// <summary>
    309                 /// Gets the output data.
    310                 /// </summary>
    311                 /// <value>The output data.</value>
     233                /// Gets the output inputdata.
     234                /// </summary>
     235                /// <value>The output inputdata.</value>
    312236                [PropertyInfo(Direction.Output, "Hashed Data", "Output data of the hashed value", "",
    313237                        true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     
    331255                #endregion
    332256
    333                 void Hash()
    334                 {}
    335 
    336 
     257    void Hash()
     258    {
     259      HMACTIGER2 tg = new HMACTIGER2();
     260      outputData = tg.ComputeHash(inputdata);
     261      NotifyUpdateOutput();
     262    }
    337263
    338264                #region IPlugin Member
     
    346272
    347273
     274    /// <summary>
     275    /// Provide all presentation stuff in this user control, it will be opened in an tab.
     276    /// Return null if your plugin has no presentation.
     277    /// </summary>
     278    /// <value>The presentation.</value>
    348279                public System.Windows.Controls.UserControl Presentation
    349280                {
    350281                        get
    351282                        {
    352                                 throw new NotImplementedException();
    353                         }
    354                 }
    355 
     283        return null;
     284                        }
     285                }
     286
     287    /// <summary>
     288    /// Gets the quick watch presentation
     289    /// </summary>
     290    /// <value>The quick watch presentation.</value>
    356291                public System.Windows.Controls.UserControl QuickWatchPresentation
    357292                {
    358293                        get
    359294                        {
    360                                 throw new NotImplementedException();
    361                         }
    362                 }
    363 
     295        return null;
     296                        }
     297                }
     298
     299    /// <summary>
     300    /// Will be called from editor before right before chain-run starts
     301    /// </summary>
    364302                public void PreExecution()
    365303                {
    366                         throw new NotImplementedException();
    367                 }
    368 
     304                }
     305
     306    /// <summary>
     307    /// Will be called from editor while chain-run is active and after last necessary input
     308    /// for plugin has been set.
     309    /// </summary>
    369310                public void Execute()
    370311                {
    371                         throw new NotImplementedException();
    372                 }
    373 
     312      Hash();
     313                }
     314
     315    /// <summary>
     316    /// Will be called from editor after last plugin in chain has finished its work.
     317    /// </summary>
    374318                public void PostExecution()
    375319                {
    376                         throw new NotImplementedException();
    377                 }
     320                }
     321
    378322
    379323                public void Pause()
    380324                {
    381                         throw new NotImplementedException();
    382                 }
    383 
     325                }
     326
     327    /// <summary>
     328    /// Will be called from editor while chain-run is active. Plugin hast to stop work immediately.
     329    /// </summary>
    384330                public void Stop()
    385331                {
    386                         throw new NotImplementedException();
    387                 }
    388 
     332                }
     333
     334    /// <summary>
     335    /// Will be called from editor after restoring settings and before adding to workspace.
     336    /// </summary>
    389337                public void Initialize()
    390338                {
    391                         throw new NotImplementedException();
    392                 }
    393 
     339                }
     340
     341    /// <summary>
     342    /// Will be called from editor when element is deleted from worksapce.
     343    /// Releases unmanaged and - optionally - managed resources
     344    /// </summary>
    394345                public void Dispose()
    395346                {
    396                         throw new NotImplementedException();
     347      foreach (CryptoolStream stream in listCryptoolStreamsOut)
     348      {
     349        stream.Close();
     350      }
     351      listCryptoolStreamsOut.Clear();
    397352                }
    398353
     
    411366                        if (PropertyChanged != null)
    412367                        {
    413                                 if (name == "Settings")
    414                                         Hash();
    415                                 else
    416                                         PropertyChanged(this, new PropertyChangedEventArgs(name));
     368        if (name == "Settings")
     369        {
     370          Hash();
     371        }
     372        else
     373          PropertyChanged(this, new PropertyChangedEventArgs(name));
    417374                        }
    418375                }
     
    430387                }
    431388
    432 
    433                 #endregion
    434 
    435 
    436 
     389                #endregion
    437390        }
    438391}
  • trunk/CrypPlugins/Tiger/Tiger.csproj

    r140 r142  
    6262      <Name>CrypPluginBase</Name>
    6363    </ProjectReference>
     64    <ProjectReference Include="..\..\SSCext\SSCext.csproj">
     65      <Project>{E46A6AA6-56EE-4AE5-8725-DCD07DC95527}</Project>
     66      <Name>SSCext</Name>
     67    </ProjectReference>
     68  </ItemGroup>
     69  <ItemGroup>
     70    <Resource Include="Tiger.png" />
     71  </ItemGroup>
     72  <ItemGroup>
     73    <Resource Include="Tiger1.png" />
    6474  </ItemGroup>
    6575  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/CrypPlugins/Whirlpool/Whirlpool.csproj

    r139 r142  
    7070  <ItemGroup>
    7171    <Content Include="license.txt" />
     72    <Resource Include="whirlpool1.png" />
    7273  </ItemGroup>
    7374  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  • trunk/CrypPlugins/Whirlpool/WhirlpoolPlugin.cs

    r139 r142  
    2525namespace Whirlpool
    2626{
    27   [Author("Gerhard Junker", null, "private project member", "http://www.uni-siegen.de")]
    28   [PluginInfo(false, "Whirlpool", "Whirlpool hash function", "", "Whirlpool/Whirlpool.png")]
     27  [Author("Gerhard Junker", null, "private project member", null)]
     28  [PluginInfo(false, "Whirlpool", "Whirlpool hash function", "", "Whirlpool/Whirlpool1.png")]
    2929  public class WPHash : IHash
    3030  {
     
    258258
    259259    /// <summary>
    260     /// Gets the quick watch presentation - will be displayed inside of the plugin presentation-element. You
    261     /// can return the existing Presentation if it makes sense to display it inside a small area. But be aware that
    262     /// if Presentation is displayed in QuickWatchPresentation you can't open Presentation it in a tab before you
    263     /// you close QuickWatchPresentation;
     260    /// Gets the quick watch presentation - will be displayed inside of the plugin presentation-element.
     261    /// You can return the existing Presentation if it makes sense to display it inside a small area.
     262    /// But be aware that
     263    /// if Presentation is displayed in QuickWatchPresentation you can't open Presentation it in a tab
     264    /// before you you close QuickWatchPresentation;
    264265    /// Return null if your plugin has no QuickWatchPresentation.
    265266    /// </summary>
     
    278279    public void Initialize()
    279280    {
    280       GuiLogMessage("Initialize.", NotificationLevel.Debug);
    281281    }
    282282
     
    286286    public void PreExecution()
    287287    {
    288       GuiLogMessage("PreExecution.", NotificationLevel.Debug);
    289288    }
    290289
     
    295294    public void Execute()
    296295    {
    297       GuiLogMessage("Execute.", NotificationLevel.Debug);
    298296      Hash();
    299297    }
     
    304302    public void PostExecution()
    305303    {
    306       GuiLogMessage("PostExecution.", NotificationLevel.Debug);
    307304    }
    308305
     
    312309    public void Pause()
    313310    {
    314       GuiLogMessage("Pause.", NotificationLevel.Debug);
    315311    }
    316312
     
    320316    public void Stop()
    321317    {
    322       GuiLogMessage("Stop.", NotificationLevel.Debug);
    323318    }
    324319
     
    334329      }
    335330      listCryptoolStreamsOut.Clear();
    336       GuiLogMessage("Dispose.", NotificationLevel.Debug);
    337331    }
    338332
Note: See TracChangeset for help on using the changeset viewer.