Changeset 138


Ignore:
Timestamp:
Dec 10, 2008, 10:53:31 AM (13 years ago)
Author:
Gerhard Junker
Message:

TIGER Hash implementes under SSCext
ToDo Tiger Plugin

Location:
trunk
Files:
11 edited
2 copied

Legend:

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

    r130 r138  
    2525namespace PKCS5
    2626{
    27         [Author("Gerhard Junker", null, "private project member", "http://www.uni-siegen.de")]
    28     [PluginInfo(false, "PKCS#5", "PKCS#5 V2.1 Hash", "", "PKCS5/PKCS5.png")]
    29     public class PKCS5 : IHash
    30     {
    31 
    32         /// <summary>
    33         /// can only handle one input canal
    34         /// </summary>
    35         private enum dataCanal
     27  [Author("Gerhard Junker", null, "private project member", "http://www.uni-siegen.de")]
     28  [PluginInfo(false, "PKCS#5", "PKCS#5 V2.1 Hash", "", "PKCS5/PKCS5.png")]
     29  public class PKCS5 : IHash
     30  {
     31
     32    /// <summary>
     33    /// can only handle one input canal
     34    /// </summary>
     35    private enum dataCanal
     36    {
     37      /// <summary>
     38      /// nothing assigned
     39      /// </summary>
     40      none,
     41      /// <summary>
     42      /// using stream interface
     43      /// </summary>
     44      streamCanal,
     45      /// <summary>
     46      /// using byte array interface
     47      /// </summary>
     48      byteCanal
     49    };
     50
     51
     52    /// <summary>
     53    /// Initializes a new instance of the <see cref="PKCS5"/> class.
     54    /// </summary>
     55    public PKCS5()
     56    {
     57      this.settings = new PKCS5Settings();
     58    }
     59
     60    #region Settings
     61
     62    private PKCS5Settings settings;
     63
     64    /// <summary>
     65    /// Gets or sets the settings.
     66    /// </summary>
     67    /// <value>The settings.</value>
     68    public ISettings Settings
     69    {
     70      get
     71      {
     72        return settings;
     73      }
     74      set
     75      {
     76        settings = (PKCS5Settings)value;
     77        OnPropertyChanged("Settings");
     78        GuiLogMessage("Settings changed.", NotificationLevel.Debug);
     79      }
     80    }
     81
     82
     83    /// <summary>
     84    /// Gets or sets a value indicating whether this instance has changes.
     85    /// </summary>
     86    /// <value>
     87    ///         <c>true</c> if this instance has changes; otherwise, <c>false</c>.
     88    /// </value>
     89    public bool HasChanges
     90    {
     91      get
     92      {
     93        return settings.HasChanges;
     94      }
     95
     96      set
     97      {
     98        settings.HasChanges = value;
     99        GuiLogMessage("HasChanges changed.", NotificationLevel.Debug);
     100      }
     101    }
     102
     103    #endregion
     104
     105    #region Input key / password
     106
     107    // Input key
     108    private byte[] key = { };
     109    private dataCanal keyCanal = dataCanal.none;
     110
     111    /// <summary>
     112    /// Notifies the update input.
     113    /// </summary>
     114    private void NotifyUpdateKey()
     115    {
     116      OnPropertyChanged("KeyStream");
     117      OnPropertyChanged("KeyData");
     118    }
     119
     120    /// <summary>
     121    /// Gets or sets the input data.
     122    /// </summary>
     123    /// <value>The input key.</value>
     124    [PropertyInfo(Direction.Input, "Key Stream", "Key stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     125    public CryptoolStream KeyStream
     126    {
     127      get
     128      {
     129        CryptoolStream keyDataStream = new CryptoolStream();
     130        keyDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, key);
     131        return keyDataStream;
     132      }
     133      set
     134      {
     135        if (null == value)
     136          return;
     137
     138        if (keyCanal != dataCanal.none && keyCanal != dataCanal.streamCanal)
     139          GuiLogMessage("Duplicate input key not allowed!", NotificationLevel.Warning);
     140        keyCanal = dataCanal.streamCanal;
     141
     142        long len = value.Length;
     143        key = new byte[len];
     144
     145        for (long i = 0; i < len; i++)
     146          key[i] = (byte)value.ReadByte();
     147
     148        NotifyUpdateKey();
     149        GuiLogMessage("KeyStream changed.", NotificationLevel.Debug);
     150      }
     151    }
     152
     153    /// <summary>
     154    /// Gets the input data.
     155    /// </summary>
     156    /// <value>The input data.</value>
     157    [PropertyInfo(Direction.Input, "Key Data", "Key stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     158    public byte[] KeyData
     159    {
     160      get
     161      {
     162        return key;
     163      }
     164      set
     165      {
     166        if (keyCanal != dataCanal.none && keyCanal != dataCanal.byteCanal)
     167          GuiLogMessage("Duplicate key data not allowed!", NotificationLevel.Warning);
     168        keyCanal = dataCanal.byteCanal;
     169
     170        long len = value.Length;
     171        key = new byte[len];
     172
     173        for (long i = 0; i < len; i++)
     174          key[i] = value[i];
     175
     176        NotifyUpdateKey();
     177        GuiLogMessage("KeyData changed.", NotificationLevel.Debug);
     178      }
     179    }
     180    #endregion
     181
     182    #region Salt data / Seed data
     183
     184    // Salt Data
     185    private byte[] salt = { };
     186    private dataCanal saltCanal = dataCanal.none;
     187
     188    /// <summary>
     189    /// Notifies the update salt.
     190    /// </summary>
     191    private void NotifyUpdateSalt()
     192    {
     193      OnPropertyChanged("SaltStream");
     194      OnPropertyChanged("SaltData");
     195    }
     196
     197    /// <summary>
     198    /// Gets or sets the salt data.
     199    /// </summary>
     200    /// <value>The salt data.</value>
     201    [PropertyInfo(Direction.Input, "Salt Stream", "Salt - Input salt data to change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     202    public CryptoolStream SaltStream
     203    {
     204      get
     205      {
     206        CryptoolStream saltDataStream = new CryptoolStream();
     207        saltDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, salt);
     208        return saltDataStream;
     209      }
     210      set
     211      {
     212        if (null == value)
     213          return;
     214
     215        if (saltCanal != dataCanal.none && saltCanal != dataCanal.streamCanal)
     216          GuiLogMessage("Duplicate salt input not allowed!", NotificationLevel.Warning);
     217        saltCanal = dataCanal.streamCanal;
     218
     219        long len = value.Length;
     220        salt = new byte[len];
     221
     222        for (long i = 0; i < len; i++)
     223          salt[i] = (byte)value.ReadByte();
     224
     225        NotifyUpdateSalt();
     226        GuiLogMessage("SaltStream changed.", NotificationLevel.Debug);
     227      }
     228    }
     229
     230    /// <summary>
     231    /// Gets or sets the salt data.
     232    /// </summary>
     233    /// <value>The salt data.</value>
     234    [PropertyInfo(Direction.Input, "Salt Data", "Salt - Input salt data to to be change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     235    public byte[] SaltData
     236    {
     237      get
     238      {
     239        return salt;
     240      }
     241
     242      set
     243      {
     244        if (saltCanal != dataCanal.none && saltCanal != dataCanal.byteCanal)
     245          GuiLogMessage("Duplicate salt input not allowed!", NotificationLevel.Warning);
     246        saltCanal = dataCanal.byteCanal;
     247
     248        long len = value.Length;
     249        salt = new byte[len];
     250
     251        for (long i = 0; i < len; i++)
     252          salt[i] = value[i];
     253
     254        NotifyUpdateSalt();
     255        GuiLogMessage("SaltData changed.", NotificationLevel.Debug);
     256      }
     257    }
     258    #endregion
     259
     260    #region Output
     261
     262    // Output
     263    private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     264    private byte[] outputData = { };
     265
     266    /// <summary>
     267    /// Notifies the update output.
     268    /// </summary>
     269    private void NotifyUpdateOutput()
     270    {
     271      OnPropertyChanged("HashOutputStream");
     272      OnPropertyChanged("HashOutputData");
     273    }
     274
     275
     276    /// <summary>
     277    /// Gets or sets the output data stream.
     278    /// </summary>
     279    /// <value>The output data stream.</value>
     280    [PropertyInfo(Direction.Output, "Hashed Stream", "Output stream of the hashed value", "",
     281      true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     282    public CryptoolStream HashOutputStream
     283    {
     284      get
     285      {
     286        CryptoolStream outputDataStream = null;
     287        if (outputData != null)
    36288        {
    37             /// <summary>
    38             /// nothing assigned
    39             /// </summary>
    40             none,
    41             /// <summary>
    42             /// using stream interface
    43             /// </summary>
    44             streamCanal,
    45             /// <summary>
    46             /// using byte array interface
    47             /// </summary>
    48             byteCanal
    49         };
    50 
    51 
    52         /// <summary>
    53         /// Initializes a new instance of the <see cref="PKCS5"/> class.
    54         /// </summary>
    55         public PKCS5()
    56         {
    57             this.settings = new PKCS5Settings();
     289          outputDataStream = new CryptoolStream();
     290          outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
     291          listCryptoolStreamsOut.Add(outputDataStream);
    58292        }
    59 
    60         #region Settings
    61 
    62                                 private PKCS5Settings settings;
    63 
    64                                 /// <summary>
    65                                 /// Gets or sets the settings.
    66                                 /// </summary>
    67                                 /// <value>The settings.</value>
    68                                 public ISettings Settings
    69                                 {
    70                                         get
    71                                         {
    72                                                 return settings;
    73                                         }
    74                                         set
    75                                         {
    76                                                 settings = (PKCS5Settings)value;
    77                                                 OnPropertyChanged("Settings");
    78                                                 GuiLogMessage("Settings changed.", NotificationLevel.Debug);
    79                                         }
    80                                 }
    81 
    82 
    83         /// <summary>
    84         /// Gets or sets a value indicating whether this instance has changes.
    85         /// </summary>
    86         /// <value>
    87         ///     <c>true</c> if this instance has changes; otherwise, <c>false</c>.
    88         /// </value>
    89         public bool HasChanges
    90         {
    91             get
    92             {
    93                 return settings.HasChanges;
    94             }
    95 
    96             set
    97             {
    98                 settings.HasChanges = value;
    99                 GuiLogMessage("HasChanges changed.", NotificationLevel.Debug);
    100             }
    101         }
    102 
    103         #endregion
    104 
    105         #region Input key / password
    106 
    107         // Input key
    108         private byte[] key = { };
    109         private dataCanal keyCanal = dataCanal.none;
    110 
    111         /// <summary>
    112         /// Notifies the update input.
    113         /// </summary>
    114         private void NotifyUpdateKey()
    115         {
    116             OnPropertyChanged("KeyStream");
    117             OnPropertyChanged("KeyData");
    118         }
    119 
    120         /// <summary>
    121         /// Gets or sets the input data.
    122         /// </summary>
    123         /// <value>The input key.</value>
    124         [PropertyInfo(Direction.Input, "Key Stream", "Key stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    125         public CryptoolStream KeyStream
    126         {
    127             get
    128             {
    129                 CryptoolStream keyDataStream = new CryptoolStream();
    130                 keyDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, key);
    131                 return keyDataStream;
    132             }
    133             set
    134             {
    135                 if (null == value)
    136                     return;
    137 
    138                 if (keyCanal != dataCanal.none && keyCanal != dataCanal.streamCanal)
    139                     GuiLogMessage("Duplicate input key not allowed!", NotificationLevel.Warning);
    140                 keyCanal = dataCanal.streamCanal;
    141 
    142                 long len = value.Length;
    143                 key = new byte[len];
    144 
    145                 for (long i = 0; i < len; i++)
    146                     key[i] = (byte)value.ReadByte();
    147 
    148                 NotifyUpdateKey();
    149                 GuiLogMessage("KeyStream changed.", NotificationLevel.Debug);
    150             }
    151         }
    152 
    153         /// <summary>
    154         /// Gets the input data.
    155         /// </summary>
    156         /// <value>The input data.</value>
    157         [PropertyInfo(Direction.Input, "Key Data", "Key stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    158         public byte[] KeyData
    159         {
    160             get
    161             {
    162                 return key;
    163             }
    164             set
    165             {
    166                                                         if (keyCanal != dataCanal.none && keyCanal != dataCanal.byteCanal)
    167                                                                 GuiLogMessage("Duplicate key data not allowed!", NotificationLevel.Warning);
    168                                                         keyCanal = dataCanal.byteCanal;
    169 
    170                 long len = value.Length;
    171                 key = new byte[len];
    172 
    173                 for (long i = 0; i < len; i++)
    174                     key[i] = value[i];
    175 
    176                 NotifyUpdateKey();
    177                 GuiLogMessage("KeyData changed.", NotificationLevel.Debug);
    178             }
    179         }
    180         #endregion
    181 
    182         #region Salt data / Seed data
    183 
    184         // Salt Data
    185         private byte[] salt = { };
    186         private dataCanal saltCanal = dataCanal.none;
    187 
    188         /// <summary>
    189         /// Notifies the update salt.
    190         /// </summary>
    191         private void NotifyUpdateSalt()
    192         {
    193             OnPropertyChanged("SaltStream");
    194             OnPropertyChanged("SaltData");
    195         }
    196 
    197         /// <summary>
    198         /// Gets or sets the salt data.
    199         /// </summary>
    200         /// <value>The salt data.</value>
    201         [PropertyInfo(Direction.Input, "Salt Stream", "Salt - Input salt data to change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    202         public CryptoolStream SaltStream
    203         {
    204             get
    205             {
    206                 CryptoolStream saltDataStream = new CryptoolStream();
    207                 saltDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, salt);
    208                 return saltDataStream;
    209             }
    210             set
    211             {
    212                                                         if (null == value)
    213                                                                 return;
    214 
    215                 if (saltCanal != dataCanal.none && saltCanal != dataCanal.streamCanal)
    216                     GuiLogMessage("Duplicate salt input not allowed!", NotificationLevel.Warning);
    217                 saltCanal = dataCanal.streamCanal;
    218 
    219                 long len = value.Length;
    220                 salt = new byte[len];
    221 
    222                 for (long i = 0; i < len; i++)
    223                     salt[i] = (byte)value.ReadByte();
    224 
    225                 NotifyUpdateSalt();
    226                 GuiLogMessage("SaltStream changed.", NotificationLevel.Debug);
    227             }
    228         }
    229 
    230         /// <summary>
    231         /// Gets or sets the salt data.
    232         /// </summary>
    233         /// <value>The salt data.</value>
    234         [PropertyInfo(Direction.Input, "Salt Data", "Salt - Input salt data to to be change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    235         public byte[] SaltData
    236         {
    237             get
    238             {
    239                 return salt;
    240             }
    241 
    242             set
    243             {
    244                 if (saltCanal != dataCanal.none && saltCanal != dataCanal.byteCanal)
    245                     GuiLogMessage("Duplicate salt input not allowed!", NotificationLevel.Warning);
    246                 saltCanal = dataCanal.byteCanal;
    247 
    248                 long len = value.Length;
    249                 salt = new byte[len];
    250 
    251                 for (long i = 0; i < len; i++)
    252                     salt[i] = value[i];
    253 
    254                 NotifyUpdateSalt();
    255                 GuiLogMessage("SaltData changed.", NotificationLevel.Debug);
    256             }
    257         }
    258         #endregion
    259 
    260         #region Output
    261 
    262         // Output
    263         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    264         private byte[] outputData = { };
    265 
    266         /// <summary>
    267         /// Notifies the update output.
    268         /// </summary>
    269         private void NotifyUpdateOutput()
    270         {
    271             OnPropertyChanged("HashOutputStream");
    272             OnPropertyChanged("HashOutputData");
    273         }
    274 
    275 
    276         /// <summary>
    277         /// Gets or sets the output data stream.
    278         /// </summary>
    279         /// <value>The output data stream.</value>
    280         [PropertyInfo(Direction.Output, "Hashed Stream", "Output stream of the hashed value", "",
    281                                         true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    282         public CryptoolStream HashOutputStream
    283         {
    284             get
    285             {
    286                 CryptoolStream outputDataStream = null;
    287                 if (outputData != null)
    288                 {
    289                     outputDataStream = new CryptoolStream();
    290                     outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
    291                     listCryptoolStreamsOut.Add(outputDataStream);
    292                 }
    293                 GuiLogMessage("Got HashOutputStream.", NotificationLevel.Debug);
    294                 return outputDataStream;
    295             }
    296             //set
    297             //{
    298             //} //readonly
    299         }
    300 
    301         /// <summary>
    302         /// Gets the output data.
    303         /// </summary>
    304         /// <value>The output data.</value>
    305         [PropertyInfo(Direction.Output, "Hashed Data", "Output data of the hashed value", "",
    306                                         true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    307         public byte[] HashOutputData
    308         {
    309             get
    310             {
    311                 GuiLogMessage("Got HashOutputData.", NotificationLevel.Debug);
    312                 return this.outputData;
    313             }
    314                                                 //set
    315                                                 //{
    316                                                 //    if (outputData != value)
    317                                                 //    {
    318                                                 //        this.outputData = value;
    319                                                 //    }
    320                                                 //    NotifyUpdateOutput();
    321                                                 //}
    322         }
    323 
    324         /// <summary>
    325         /// Hashes this instance.
    326         /// </summary>
    327         public void Hash()
    328         {
    329             System.Security.Cryptography.PKCS5MaskGenerationMethod pkcs5Hash =
     293        GuiLogMessage("Got HashOutputStream.", NotificationLevel.Debug);
     294        return outputDataStream;
     295      }
     296      //set
     297      //{
     298      //} //readonly
     299    }
     300
     301    /// <summary>
     302    /// Gets the output data.
     303    /// </summary>
     304    /// <value>The output data.</value>
     305    [PropertyInfo(Direction.Output, "Hashed Data", "Output data of the hashed value", "",
     306      true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     307    public byte[] HashOutputData
     308    {
     309      get
     310      {
     311        GuiLogMessage("Got HashOutputData.", NotificationLevel.Debug);
     312        return this.outputData;
     313      }
     314      //set
     315      //{
     316      //    if (outputData != value)
     317      //    {
     318      //        this.outputData = value;
     319      //    }
     320      //    NotifyUpdateOutput();
     321      //}
     322    }
     323
     324    /// <summary>
     325    /// Hashes this instance.
     326    /// </summary>
     327    public void Hash()
     328    {
     329      System.Security.Cryptography.PKCS5MaskGenerationMethod pkcs5Hash =
    330330                                                        new System.Security.Cryptography.PKCS5MaskGenerationMethod();
    331331
    332             pkcs5Hash.SelectedShaFunction =
    333                                                         (PKCS5MaskGenerationMethod.ShaFunction)settings.SHAFunction;
    334 
    335             outputData =
    336                                                         pkcs5Hash.GenerateMask(this.key, this.salt, settings.Count, settings.Length >> 3);
    337 
    338             NotifyUpdateOutput();
    339         }
    340         #endregion
    341 
    342         #region IPlugin Member
     332      pkcs5Hash.SelectedShaFunction =
     333        (PKCS5MaskGenerationMethod.ShaFunction)settings.SHAFunction;
     334
     335      outputData =
     336        pkcs5Hash.GenerateMask(this.key, this.salt, settings.Count, settings.Length >> 3);
     337
     338      NotifyUpdateOutput();
     339    }
     340    #endregion
     341
     342    #region IPlugin Member
    343343
    344344#pragma warning disable 67
    345         public event StatusChangedEventHandler OnPluginStatusChanged;
    346         public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    347         public event PluginProgressChangedEventHandler OnPluginProgressChanged;
     345    public event StatusChangedEventHandler OnPluginStatusChanged;
     346    public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
     347    public event PluginProgressChangedEventHandler OnPluginProgressChanged;
    348348#pragma warning restore
    349349
    350         /// <summary>
    351         /// Provide all presentation stuff in this user control, it will be opened in an tab.
    352         /// Return null if your plugin has no presentation.
    353         /// </summary>
    354         /// <value>The presentation.</value>
    355         public System.Windows.Controls.UserControl Presentation
    356         {
    357             get
    358             {
    359                 return null;
    360             }
    361         }
    362 
    363         /// <summary>
    364         /// Gets the quick watch presentation - will be displayed inside of the plugin presentation-element. You
    365         /// can return the existing Presentation if it makes sense to display it inside a small area. But be aware that
    366         /// if Presentation is displayed in QuickWatchPresentation you can't open Presentation it in a tab before you
    367         /// you close QuickWatchPresentation;
    368         /// Return null if your plugin has no QuickWatchPresentation.
    369         /// </summary>
    370         /// <value>The quick watch presentation.</value>
    371         public System.Windows.Controls.UserControl QuickWatchPresentation
    372         {
    373             get
    374             {
    375                 return null;
    376             }
    377         }
    378 
    379         /// <summary>
    380         /// Will be called from editor after restoring settings and before adding to workspace.
    381         /// </summary>
    382         public void Initialize()
    383         {
    384             GuiLogMessage("Initialize.", NotificationLevel.Debug);
    385         }
    386 
    387         /// <summary>
    388         /// Will be called from editor before right before chain-run starts
    389         /// </summary>
    390         public void PreExecution()
    391         {
    392             GuiLogMessage("PreExecution.", NotificationLevel.Debug);
    393         }
    394 
    395         /// <summary>
    396         /// Will be called from editor while chain-run is active and after last necessary input
    397         /// for plugin has been set.
    398         /// </summary>
    399         public void Execute()
    400         {
    401             GuiLogMessage("Execute.", NotificationLevel.Debug);
    402             Hash();
    403         }
    404 
    405         /// <summary>
    406         /// Will be called from editor after last plugin in chain has finished its work.
    407         /// </summary>
    408         public void PostExecution()
    409         {
    410             GuiLogMessage("PostExecution.", NotificationLevel.Debug);
    411         }
    412 
    413         /// <summary>
    414         /// Not defined yet.
    415         /// </summary>
    416         public void Pause()
    417         {
    418             GuiLogMessage("Pause.", NotificationLevel.Debug);
    419         }
    420 
    421         /// <summary>
    422         /// Will be called from editor while chain-run is active. Plugin hast to stop work immediately.
    423         /// </summary>
    424         public void Stop()
    425         {
    426             GuiLogMessage("Stop.", NotificationLevel.Debug);
    427         }
    428 
    429         /// <summary>
    430         /// Will be called from editor when element is deleted from worksapce.
    431         /// Releases unmanaged and - optionally - managed resources
    432         /// </summary>
    433         public void Dispose()
    434         {
    435             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    436             {
    437                 stream.Close();
    438             }
    439             listCryptoolStreamsOut.Clear();
    440             GuiLogMessage("Dispose.", NotificationLevel.Debug);
    441         }
    442 
    443         #endregion
    444 
    445         #region INotifyPropertyChanged Member
    446 
    447         /// <summary>
    448         /// Occurs when a property value changes.
    449         /// </summary>
    450         public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
    451 
    452         /// <summary>
    453         /// Called when [property changed].
    454         /// </summary>
    455         /// <param name="name">The name.</param>
    456         protected void OnPropertyChanged(string name)
    457         {
    458             if (PropertyChanged != null)
    459             {
    460                 if (name == "Settings")
    461                     Hash();
    462                 else
    463                     PropertyChanged(this, new PropertyChangedEventArgs(name));
    464             }
    465         }
    466 
    467         /// <summary>
    468         /// GUIs the log message.
    469         /// </summary>
    470         /// <param name="message">The message.</param>
    471         /// <param name="logLevel">The log level.</param>
    472         private void GuiLogMessage(string message, NotificationLevel logLevel)
    473         {
    474             EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this,
    475                                                         new GuiLogEventArgs(message, this, logLevel));
    476         }
    477 
    478         #endregion
    479     }
     350    /// <summary>
     351    /// Provide all presentation stuff in this user control, it will be opened in an tab.
     352    /// Return null if your plugin has no presentation.
     353    /// </summary>
     354    /// <value>The presentation.</value>
     355    public System.Windows.Controls.UserControl Presentation
     356    {
     357      get
     358      {
     359        return null;
     360      }
     361    }
     362
     363    /// <summary>
     364    /// Gets the quick watch presentation - will be displayed inside of the plugin presentation-element. You
     365    /// can return the existing Presentation if it makes sense to display it inside a small area. But be aware that
     366    /// if Presentation is displayed in QuickWatchPresentation you can't open Presentation it in a tab before you
     367    /// you close QuickWatchPresentation;
     368    /// Return null if your plugin has no QuickWatchPresentation.
     369    /// </summary>
     370    /// <value>The quick watch presentation.</value>
     371    public System.Windows.Controls.UserControl QuickWatchPresentation
     372    {
     373      get
     374      {
     375        return null;
     376      }
     377    }
     378
     379    /// <summary>
     380    /// Will be called from editor after restoring settings and before adding to workspace.
     381    /// </summary>
     382    public void Initialize()
     383    {
     384      GuiLogMessage("Initialize.", NotificationLevel.Debug);
     385    }
     386
     387    /// <summary>
     388    /// Will be called from editor before right before chain-run starts
     389    /// </summary>
     390    public void PreExecution()
     391    {
     392      GuiLogMessage("PreExecution.", NotificationLevel.Debug);
     393    }
     394
     395    /// <summary>
     396    /// Will be called from editor while chain-run is active and after last necessary input
     397    /// for plugin has been set.
     398    /// </summary>
     399    public void Execute()
     400    {
     401      GuiLogMessage("Execute.", NotificationLevel.Debug);
     402      Hash();
     403    }
     404
     405    /// <summary>
     406    /// Will be called from editor after last plugin in chain has finished its work.
     407    /// </summary>
     408    public void PostExecution()
     409    {
     410      GuiLogMessage("PostExecution.", NotificationLevel.Debug);
     411    }
     412
     413    /// <summary>
     414    /// Not defined yet.
     415    /// </summary>
     416    public void Pause()
     417    {
     418      GuiLogMessage("Pause.", NotificationLevel.Debug);
     419    }
     420
     421    /// <summary>
     422    /// Will be called from editor while chain-run is active. Plugin hast to stop work immediately.
     423    /// </summary>
     424    public void Stop()
     425    {
     426      GuiLogMessage("Stop.", NotificationLevel.Debug);
     427    }
     428
     429    /// <summary>
     430    /// Will be called from editor when element is deleted from worksapce.
     431    /// Releases unmanaged and - optionally - managed resources
     432    /// </summary>
     433    public void Dispose()
     434    {
     435      foreach (CryptoolStream stream in listCryptoolStreamsOut)
     436      {
     437        stream.Close();
     438      }
     439      listCryptoolStreamsOut.Clear();
     440      GuiLogMessage("Dispose.", NotificationLevel.Debug);
     441    }
     442
     443    #endregion
     444
     445    #region INotifyPropertyChanged Member
     446
     447    /// <summary>
     448    /// Occurs when a property value changes.
     449    /// </summary>
     450    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
     451
     452    /// <summary>
     453    /// Called when [property changed].
     454    /// </summary>
     455    /// <param name="name">The name.</param>
     456    protected void OnPropertyChanged(string name)
     457    {
     458      if (PropertyChanged != null)
     459      {
     460        if (name == "Settings")
     461          Hash();
     462        else
     463          PropertyChanged(this, new PropertyChangedEventArgs(name));
     464      }
     465    }
     466
     467    /// <summary>
     468    /// GUIs the log message.
     469    /// </summary>
     470    /// <param name="message">The message.</param>
     471    /// <param name="logLevel">The log level.</param>
     472    private void GuiLogMessage(string message, NotificationLevel logLevel)
     473    {
     474      EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this,
     475        new GuiLogEventArgs(message, this, logLevel));
     476    }
     477
     478    #endregion
     479  }
    480480}
  • trunk/CrypPlugins/PKCS5/PKCS5Settings.cs

    r133 r138  
    2828namespace PKCS5
    2929{
    30     /// <summary>
    31     /// Settings for PKCS#5 v2
    32     /// </summary>
    33     public class PKCS5Settings : ISettings
    34     {
    35         private bool hasChanges = false;
     30  /// <summary>
     31  /// Settings for PKCS#5 v2
     32  /// </summary>
     33  public class PKCS5Settings : ISettings
     34  {
     35    private bool hasChanges = false;
    3636
    37         #region ISettings Member
     37    #region ISettings Member
    3838
    3939
    40                         /// <summary>
    41                         /// selected internal hash HMAC function
    42                         /// </summary>
    43                           private PKCS5MaskGenerationMethod.ShaFunction selectedShaFunction
     40    /// <summary>
     41    /// selected internal hash HMAC function
     42    /// </summary>
     43    private PKCS5MaskGenerationMethod.ShaFunction selectedShaFunction
    4444                                        = PKCS5MaskGenerationMethod.ShaFunction.SHA256;
    4545
    46         [ContextMenu("SHA Function",
    47                                         "Select the hash function (MD5, SHA1 or one out of the SHA2 family)", 0,
    48                                         DisplayLevel.Beginner, ContextMenuControlType.ComboBox, null,
    49                                         new string[] {"MD5", "SHA1", "SHA256", "SHA384", "SHA512"})]
    50         [TaskPane("Select hash function",
    51                                         "Select the hash function (MD2, SHA1 or one out of the SHA2 family)", "", 0, true,
    52                                         DisplayLevel.Beginner, ControlType.ComboBox,
    53                                         new string[] { "MD5", "SHA1", "SHA256", "SHA384", "SHA512" })]
    54         public int SHAFunction
    55         {
    56             get
    57             {
    58                 return (int)this.selectedShaFunction;
    59             }
    60             set
    61             {
    62                 this.selectedShaFunction = (PKCS5MaskGenerationMethod.ShaFunction)value;
    63                                                                 //CheckLength();
    64                                                                 // set to max hash length
    65                                                                 length = PKCS5MaskGenerationMethod.GetHashLength(selectedShaFunction) * 8;
    66                                                                 hasChanges = true;
    67                                                                 OnPropertyChanged("SHAFunction");
    68                                                                 OnPropertyChanged("Length");
    69             }
    70         }
     46    [ContextMenu("SHA Function",
     47      "Select the hash function (MD5, SHA1 or one out of the SHA2 family)", 0,
     48      DisplayLevel.Beginner, ContextMenuControlType.ComboBox, null,
     49      new string[] { "MD5", "SHA1", "SHA256", "SHA384", "SHA512" })]
     50    [TaskPane("Select hash function",
     51      "Select the hash function (MD2, SHA1 or one out of the SHA2 family)", "", 0, true,
     52      DisplayLevel.Beginner, ControlType.ComboBox,
     53      new string[] { "MD5", "SHA1", "SHA256", "SHA384", "SHA512" })]
     54    public int SHAFunction
     55    {
     56      get
     57      {
     58        return (int)this.selectedShaFunction;
     59      }
     60      set
     61      {
     62        this.selectedShaFunction = (PKCS5MaskGenerationMethod.ShaFunction)value;
     63        //CheckLength();
     64        // set to max hash length
     65        length = PKCS5MaskGenerationMethod.GetHashLength(selectedShaFunction) * 8;
     66        hasChanges = true;
     67        OnPropertyChanged("SHAFunction");
     68        OnPropertyChanged("Length");
     69      }
     70    }
    7171
    72                         /// <summary>
    73                         /// count of hash loops
    74                         /// </summary>
    75                                 private int count = 1000;
    76         [TaskPane("Number of iterations (counter)",
    77                                         "The counter determines how often the hash function is applied." +
    78                                         " A value bigger than 1000 is recommended.", "", 1, false,     
    79                                         DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RangeInteger, 1, 9999)]
    80         public int Count
    81         {
    82             get
    83             {
    84                 return count;
    85             }
    86             set
    87             {
    88                 count = value;
    89                 if (count == 0)
    90                     count = 1000;
    91                 hasChanges = true;
    92                 OnPropertyChanged("Count");
    93             }
    94         }
     72    /// <summary>
     73    /// count of hash loops
     74    /// </summary>
     75    private int count = 1000;
     76    [TaskPane("Number of iterations (counter)",
     77      "The counter determines how often the hash function is applied." +
     78      " A value bigger than 1000 is recommended.", "", 1, false,
     79      DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RangeInteger, 1, 9999)]
     80    public int Count
     81    {
     82      get
     83      {
     84        return count;
     85      }
     86      set
     87      {
     88        count = value;
     89        if (count == 0)
     90          count = 1000;
     91        hasChanges = true;
     92        OnPropertyChanged("Count");
     93      }
     94    }
    9595
    96                         /// <summary>
    97                         /// length of calculated hash in bits
    98                         /// </summary>
    99                                 private int length = 256;
    100         [TaskPane("Length of output key",
    101                                         "The length of the output in bits must be a multiple of 8.", "", 2, false,
    102                                         DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RangeInteger, -64, 2048)]
    103                                 public int Length
    104                                 {
    105                                         get
    106                                         {
    107                                                 return length;
    108                                         }
    109                                         set
    110                                         {
    111                                                 length = value;
    112                                                 if (length < 0) // change from bytes to bits [hack]
    113                                                         length *= -8;
    114                                                
    115                                                 while ((length & 0x07) != 0) // go to the next multiple of 8
    116                                                         length++;
     96    /// <summary>
     97    /// length of calculated hash in bits
     98    /// </summary>
     99    private int length = 256;
     100    [TaskPane("Length of output key",
     101      "The length of the output in bits must be a multiple of 8.", "", 2, false,
     102      DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RangeInteger, -64, 2048)]
     103    public int Length
     104    {
     105      get
     106      {
     107        return length;
     108      }
     109      set
     110      {
     111        length = value;
     112        if (length < 0) // change from bytes to bits [hack]
     113          length *= -8;
    117114
    118                                                 //CheckLength();
     115        while ((length & 0x07) != 0) // go to the next multiple of 8
     116          length++;
    119117
    120                                                 hasChanges = true;
    121                                                 OnPropertyChanged("Length");
    122                                         }
    123                                 }
     118        //CheckLength();
    124119
    125                                 /// <summary>
    126                                 /// Checks the length.
    127                                 /// </summary>
    128                                 private void CheckLength()
    129                                 {
    130                                         // get max length of this hash
    131                                         int newlen = PKCS5MaskGenerationMethod.GetHashLength(selectedShaFunction) * 8;
    132                                         if (newlen < length)
    133                                         {
    134                                                 length = newlen; // reduce it to max length
    135                                                 hasChanges = true;
    136                                         }
    137                                 }
     120        hasChanges = true;
     121        OnPropertyChanged("Length");
     122      }
     123    }
    138124
    139         /// <summary>
    140         /// Gets or sets a value indicating whether this instance has changes.
    141         /// </summary>
    142         /// <value>
    143         ///     <c>true</c> if this instance has changes; otherwise, <c>false</c>.
    144         /// </value>
    145         public bool HasChanges
    146         {
    147             get
    148             {
    149                 return hasChanges;
    150             }
    151             set
    152             {
    153                 hasChanges = value;
    154             }
    155         }
     125    /// <summary>
     126    /// Checks the length.
     127    /// </summary>
     128    private void CheckLength()
     129    {
     130      // get max length of this hash
     131      int newlen = PKCS5MaskGenerationMethod.GetHashLength(selectedShaFunction) * 8;
     132      if (newlen < length)
     133      {
     134        length = newlen; // reduce it to max length
     135        hasChanges = true;
     136      }
     137    }
    156138
    157         #endregion
     139    /// <summary>
     140    /// Gets or sets a value indicating whether this instance has changes.
     141    /// </summary>
     142    /// <value>
     143    ///         <c>true</c> if this instance has changes; otherwise, <c>false</c>.
     144    /// </value>
     145    public bool HasChanges
     146    {
     147      get
     148      {
     149        return hasChanges;
     150      }
     151      set
     152      {
     153        hasChanges = value;
     154      }
     155    }
    158156
    159         #region INotifyPropertyChanged Member
     157    #endregion
    160158
    161         public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
     159    #region INotifyPropertyChanged Member
    162160
    163         /// <summary>
    164         /// Called when [property changed].
    165         /// </summary>
    166         /// <param name="name">The name.</param>
    167         protected void OnPropertyChanged(string name)
    168         {
    169             if (PropertyChanged != null)
    170             {
    171                 PropertyChanged(this, new PropertyChangedEventArgs(name));
    172             }
    173             hasChanges = true;
    174         }
     161    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
    175162
    176         #endregion
     163    /// <summary>
     164    /// Called when [property changed].
     165    /// </summary>
     166    /// <param name="name">The name.</param>
     167    protected void OnPropertyChanged(string name)
     168    {
     169      if (PropertyChanged != null)
     170      {
     171        PropertyChanged(this, new PropertyChangedEventArgs(name));
     172      }
     173      hasChanges = true;
    177174    }
     175
     176    #endregion
     177  }
    178178}
  • trunk/CrypPlugins/Whirlpool/Whirlpool.csproj

    r122 r138  
    6868    <Resource Include="whirlpool.png" />
    6969  </ItemGroup>
     70  <ItemGroup>
     71    <Content Include="license.txt" />
     72  </ItemGroup>
    7073  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
    7174  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
  • trunk/CrypPlugins/Whirlpool/WhirlpoolPlugin.cs

    r121 r138  
    2525namespace Whirlpool
    2626{
    27         [Author("Gerhard Junker", null, "private project member", "http://www.uni-siegen.de")]
     27  [Author("Gerhard Junker", null, "private project member", "http://www.uni-siegen.de")]
    2828  [PluginInfo(false, "Whirlpool", "Whirlpool hash function", "", "Whirlpool/Whirlpool.png")]
    29         public class WPHash : IHash
    30         {
    31 
    32                 /// <summary>
    33                 /// can only handle one input canal
    34                 /// </summary>
    35                 private enum dataCanal
    36                 {
    37                         /// <summary>
    38                         /// nothing assigned
    39                         /// </summary>
    40                         none,
    41                         /// <summary>
    42                         /// using stream interface
    43                         /// </summary>
    44                         streamCanal,
    45                         /// <summary>
    46                         /// using byte array interface
    47                         /// </summary>
    48                         byteCanal
    49                 };
    50 
    51         WhirlpoolSettings whirlpoolSetting = new WhirlpoolSettings();
    52 
    53                 /// <summary>
    54                 /// Initializes a new instance of the <see cref="WPHash"/> class.
    55                 /// </summary>
    56                 public WPHash()
    57                 {
    58                 }
    59 
    60                 /// <summary>
    61                 /// Gets or sets the settings.
    62                 /// </summary>
    63                 /// <value>The settings.</value>
    64                 public ISettings Settings
    65                 {
    66                         get
    67             {
    68                 return whirlpoolSetting;
    69             }
    70                         set
    71                         {
    72                                 whirlpoolSetting = (WhirlpoolSettings)value;
    73                                 OnPropertyChanged("Settings");
    74                                 GuiLogMessage("Settings changed.", NotificationLevel.Debug);
    75                         }
    76 
    77                 }
    78 
    79 
    80                 #region Input data
    81 
    82                 // Input input
    83         private static byte[] empty = {};
    84                 private byte[] input = empty;
    85                 private dataCanal inputCanal = dataCanal.none;
    86 
    87                 /// <summary>
    88                 /// Notifies the update input.
    89                 /// </summary>
    90                 private void NotifyUpdateInput()
    91                 {
    92                         OnPropertyChanged("InputStream");
    93                         OnPropertyChanged("InputData");
    94                 }
    95 
    96                 /// <summary>
    97                 /// Gets or sets the input data.
    98                 /// </summary>
    99                 /// <value>The input input.</value>
    100                 [PropertyInfo(Direction.Input, "Input Stream", "Input stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    101                 public CryptoolStream InputStream
    102                 {
    103                         get
    104                         {
    105                                 CryptoolStream inputDataStream = new CryptoolStream();
    106                                 inputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, input);
    107                                 return inputDataStream;
    108                         }
    109                         set
    110                         {
    111                                 if (inputCanal != dataCanal.none && inputCanal != dataCanal.streamCanal)
    112                                         GuiLogMessage("Duplicate input key not allowed!", NotificationLevel.Error);
    113                                 inputCanal = dataCanal.streamCanal;
    114 
    115                 if (null == value)
    116                     input = empty;
    117                 else
    118                 {
    119                     long len = value.Length;
    120                     input = new byte[len];
    121 
    122                     for (long i = 0; i < len; i++)
    123                         input[i] = (byte)value.ReadByte();
    124                 }
    125                                 NotifyUpdateInput();
    126                                 GuiLogMessage("InputStream changed.", NotificationLevel.Debug);
    127                         }
    128                 }
    129 
    130                 /// <summary>
    131                 /// Gets the input data.
    132                 /// </summary>
    133                 /// <value>The input data.</value>
    134                 [PropertyInfo(Direction.Input, "Input Data", "Input stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    135                 public byte[] InputData
    136                 {
    137                         get
    138                         {
    139                                 return input;
    140                         }
    141                         set
    142                         {
    143                                 if (inputCanal != dataCanal.none && inputCanal != dataCanal.byteCanal)
    144                                         GuiLogMessage("Duplicate input data not allowed!", NotificationLevel.Error);
    145                                 inputCanal = dataCanal.byteCanal;
    146 
    147                 if (null == value)
    148                     input = empty;
    149                 else
    150                 {
    151                                     long len = value.Length;
    152                                     input = new byte[len];
    153 
    154                                     for (long i = 0; i < len; i++)
    155                                             input[i] = value[i];
    156                 }
    157                                 NotifyUpdateInput();
    158                                 GuiLogMessage("InputData changed.", NotificationLevel.Debug);
    159                         }
    160                 }
    161                 #endregion
    162 
    163                 #region Output
    164 
    165                 // Output
    166                 private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    167                 private byte[] outputData = { };
    168 
    169                 /// <summary>
    170                 /// Notifies the update output.
    171                 /// </summary>
    172                 private void NotifyUpdateOutput()
    173                 {
    174                         OnPropertyChanged("HashOutputStream");
    175                         OnPropertyChanged("HashOutputData");
    176                 }
    177 
    178 
    179                 /// <summary>
    180                 /// Gets or sets the output data stream.
    181                 /// </summary>
    182                 /// <value>The output data stream.</value>
    183                 [PropertyInfo(Direction.Output, "Hashed Stream", "Output stream of the hashed value", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    184                 public CryptoolStream HashOutputStream
    185                 {
    186                         get
    187                         {
    188                                 CryptoolStream outputDataStream = null;
    189                                 if (outputData != null)
    190                                 {
    191                                         outputDataStream = new CryptoolStream();
    192                                         listCryptoolStreamsOut.Add(outputDataStream);
    193                                         outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
    194                                 }
    195                                 GuiLogMessage("Got HashOutputStream.", NotificationLevel.Debug);
    196                                 return outputDataStream;
    197                         }
    198                         //set
    199                         //{
    200                         //} //readonly
    201                 }
    202 
    203                 /// <summary>
    204                 /// Gets the output data.
    205                 /// </summary>
    206                 /// <value>The output data.</value>
    207                 [PropertyInfo(Direction.Output, "Hashed Data", "Output data of the hashed value", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    208                 public byte[] HashOutputData
    209                 {
    210                         get
    211                         {
    212                                 GuiLogMessage("Got HashOutputData.", NotificationLevel.Debug);
    213                                 return this.outputData;
    214                         }
    215                         //set
    216                         //{
    217                         //    if (outputData != value)
    218                         //    {
    219                         //        this.outputData = value;
    220                         //    }
    221                         //    NotifyUpdateOutput();
    222                         //}
    223                 }
    224 
    225                 /// <summary>
    226                 /// Hashes this instance.
    227                 /// </summary>
    228                 public void Hash()
    229                 {
    230             WhirlpoolHash wh = new WhirlpoolHash();
    231 
    232             wh.Add(input);
    233             wh.Finish();
    234 
    235             outputData = wh.Hash;
    236             wh = null;
    237 
    238 
    239                         NotifyUpdateOutput();
    240                 }
    241                 #endregion
    242 
    243                 #region IPlugin Member
     29  public class WPHash : IHash
     30  {
     31
     32    /// <summary>
     33    /// can only handle one input canal
     34    /// </summary>
     35    private enum dataCanal
     36    {
     37      /// <summary>
     38      /// nothing assigned
     39      /// </summary>
     40      none,
     41      /// <summary>
     42      /// using stream interface
     43      /// </summary>
     44      streamCanal,
     45      /// <summary>
     46      /// using byte array interface
     47      /// </summary>
     48      byteCanal
     49    };
     50
     51    WhirlpoolSettings whirlpoolSetting = new WhirlpoolSettings();
     52
     53    /// <summary>
     54    /// Initializes a new instance of the <see cref="WPHash"/> class.
     55    /// </summary>
     56    public WPHash()
     57    {
     58    }
     59
     60    /// <summary>
     61    /// Gets or sets the settings.
     62    /// </summary>
     63    /// <value>The settings.</value>
     64    public ISettings Settings
     65    {
     66      get
     67      {
     68        return whirlpoolSetting;
     69      }
     70      set
     71      {
     72        whirlpoolSetting = (WhirlpoolSettings)value;
     73        OnPropertyChanged("Settings");
     74        GuiLogMessage("Settings changed.", NotificationLevel.Debug);
     75      }
     76
     77    }
     78
     79
     80    #region Input data
     81
     82    // Input input
     83    private static byte[] empty = { };
     84    private byte[] input = empty;
     85    private dataCanal inputCanal = dataCanal.none;
     86
     87    /// <summary>
     88    /// Notifies the update input.
     89    /// </summary>
     90    private void NotifyUpdateInput()
     91    {
     92      OnPropertyChanged("InputStream");
     93      OnPropertyChanged("InputData");
     94    }
     95
     96    /// <summary>
     97    /// Gets or sets the input data.
     98    /// </summary>
     99    /// <value>The input input.</value>
     100    [PropertyInfo(Direction.Input, "Input Stream", "Input stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     101    public CryptoolStream InputStream
     102    {
     103      get
     104      {
     105        CryptoolStream inputDataStream = new CryptoolStream();
     106        inputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, input);
     107        return inputDataStream;
     108      }
     109      set
     110      {
     111        if (inputCanal != dataCanal.none && inputCanal != dataCanal.streamCanal)
     112          GuiLogMessage("Duplicate input key not allowed!", NotificationLevel.Error);
     113        inputCanal = dataCanal.streamCanal;
     114
     115        if (null == value)
     116          input = empty;
     117        else
     118        {
     119          long len = value.Length;
     120          input = new byte[len];
     121
     122          for (long i = 0; i < len; i++)
     123            input[i] = (byte)value.ReadByte();
     124        }
     125        NotifyUpdateInput();
     126        GuiLogMessage("InputStream changed.", NotificationLevel.Debug);
     127      }
     128    }
     129
     130    /// <summary>
     131    /// Gets the input data.
     132    /// </summary>
     133    /// <value>The input data.</value>
     134    [PropertyInfo(Direction.Input, "Input Data", "Input stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     135    public byte[] InputData
     136    {
     137      get
     138      {
     139        return input;
     140      }
     141      set
     142      {
     143        if (inputCanal != dataCanal.none && inputCanal != dataCanal.byteCanal)
     144          GuiLogMessage("Duplicate input data not allowed!", NotificationLevel.Error);
     145        inputCanal = dataCanal.byteCanal;
     146
     147        if (null == value)
     148          input = empty;
     149        else
     150        {
     151          long len = value.Length;
     152          input = new byte[len];
     153
     154          for (long i = 0; i < len; i++)
     155            input[i] = value[i];
     156        }
     157        NotifyUpdateInput();
     158        GuiLogMessage("InputData changed.", NotificationLevel.Debug);
     159      }
     160    }
     161    #endregion
     162
     163    #region Output
     164
     165    // Output
     166    private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     167    private byte[] outputData = { };
     168
     169    /// <summary>
     170    /// Notifies the update output.
     171    /// </summary>
     172    private void NotifyUpdateOutput()
     173    {
     174      OnPropertyChanged("HashOutputStream");
     175      OnPropertyChanged("HashOutputData");
     176    }
     177
     178
     179    /// <summary>
     180    /// Gets or sets the output data stream.
     181    /// </summary>
     182    /// <value>The output data stream.</value>
     183    [PropertyInfo(Direction.Output, "Hashed Stream", "Output stream of the hashed value", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     184    public CryptoolStream HashOutputStream
     185    {
     186      get
     187      {
     188        CryptoolStream outputDataStream = null;
     189        if (outputData != null)
     190        {
     191          outputDataStream = new CryptoolStream();
     192          listCryptoolStreamsOut.Add(outputDataStream);
     193          outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
     194        }
     195        GuiLogMessage("Got HashOutputStream.", NotificationLevel.Debug);
     196        return outputDataStream;
     197      }
     198      //set
     199      //{
     200      //} //readonly
     201    }
     202
     203    /// <summary>
     204    /// Gets the output data.
     205    /// </summary>
     206    /// <value>The output data.</value>
     207    [PropertyInfo(Direction.Output, "Hashed Data", "Output data of the hashed value", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     208    public byte[] HashOutputData
     209    {
     210      get
     211      {
     212        GuiLogMessage("Got HashOutputData.", NotificationLevel.Debug);
     213        return this.outputData;
     214      }
     215      //set
     216      //{
     217      //    if (outputData != value)
     218      //    {
     219      //        this.outputData = value;
     220      //    }
     221      //    NotifyUpdateOutput();
     222      //}
     223    }
     224
     225    /// <summary>
     226    /// Hashes this instance.
     227    /// </summary>
     228    public void Hash()
     229    {
     230      WhirlpoolHash wh = new WhirlpoolHash();
     231
     232      wh.Add(input);
     233      wh.Finish();
     234
     235      outputData = wh.Hash;
     236      wh = null;
     237
     238
     239      NotifyUpdateOutput();
     240    }
     241    #endregion
     242
     243    #region IPlugin Member
    244244
    245245#pragma warning disable 67
    246                 public event StatusChangedEventHandler OnPluginStatusChanged;
    247                 public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    248                 public event PluginProgressChangedEventHandler OnPluginProgressChanged;
     246    public event StatusChangedEventHandler OnPluginStatusChanged;
     247    public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
     248    public event PluginProgressChangedEventHandler OnPluginProgressChanged;
    249249#pragma warning restore
    250250
    251                 /// <summary>
    252                 /// Provide all presentation stuff in this user control, it will be opened in an tab.
    253                 /// Return null if your plugin has no presentation.
    254                 /// </summary>
    255                 /// <value>The presentation.</value>
    256                 public System.Windows.Controls.UserControl Presentation
    257                 {
    258                         get
    259                         {
    260                                 return null;
    261                         }
    262                 }
    263 
    264                 /// <summary>
    265                 /// Gets the quick watch presentation - will be displayed inside of the plugin presentation-element. You
    266                 /// can return the existing Presentation if it makes sense to display it inside a small area. But be aware that
    267                 /// if Presentation is displayed in QuickWatchPresentation you can't open Presentation it in a tab before you
    268                 /// you close QuickWatchPresentation;
    269                 /// Return null if your plugin has no QuickWatchPresentation.
    270                 /// </summary>
    271                 /// <value>The quick watch presentation.</value>
    272                 public System.Windows.Controls.UserControl QuickWatchPresentation
    273                 {
    274                         get
    275                         {
    276                                 return null;
    277                         }
    278                 }
    279 
    280                 /// <summary>
    281                 /// Will be called from editor after restoring settings and before adding to workspace.
    282                 /// </summary>
    283                 public void Initialize()
    284                 {
    285                         GuiLogMessage("Initialize.", NotificationLevel.Debug);
    286                 }
    287 
    288                 /// <summary>
    289                 /// Will be called from editor before right before chain-run starts
    290                 /// </summary>
    291                 public void PreExecution()
    292                 {
    293                         GuiLogMessage("PreExecution.", NotificationLevel.Debug);
    294                 }
    295 
    296                 /// <summary>
    297                 /// Will be called from editor while chain-run is active and after last necessary input
    298                 /// for plugin has been set.
    299                 /// </summary>
    300                 public void Execute()
    301                 {
    302                         GuiLogMessage("Execute.", NotificationLevel.Debug);
    303                         Hash();
    304                 }
    305 
    306                 /// <summary>
    307                 /// Will be called from editor after last plugin in chain has finished its work.
    308                 /// </summary>
    309                 public void PostExecution()
    310                 {
    311                         GuiLogMessage("PostExecution.", NotificationLevel.Debug);
    312                 }
    313 
    314                 /// <summary>
    315                 /// Not defined yet.
    316                 /// </summary>
    317                 public void Pause()
    318                 {
    319                         GuiLogMessage("Pause.", NotificationLevel.Debug);
    320                 }
    321 
    322                 /// <summary>
    323                 /// Will be called from editor while chain-run is active. Plugin hast to stop work immediately.
    324                 /// </summary>
    325                 public void Stop()
    326                 {
    327                         GuiLogMessage("Stop.", NotificationLevel.Debug);
    328                 }
    329 
    330                 /// <summary>
    331                 /// Will be called from editor when element is deleted from worksapce.
    332                 /// Releases unmanaged and - optionally - managed resources
    333                 /// </summary>
    334                 public void Dispose()
    335                 {
    336                         foreach (CryptoolStream stream in listCryptoolStreamsOut)
    337                         {
    338                                 stream.Close();
    339                         }
    340                         listCryptoolStreamsOut.Clear();
    341                         GuiLogMessage("Dispose.", NotificationLevel.Debug);
    342                 }
    343 
    344                 #endregion
    345 
    346                 #region INotifyPropertyChanged Member
    347 
    348                 /// <summary>
    349                 /// Occurs when a property value changes.
    350                 /// </summary>
    351                 public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
    352 
    353                 /// <summary>
    354                 /// Called when [property changed].
    355                 /// </summary>
    356                 /// <param name="name">The name.</param>
    357                 protected void OnPropertyChanged(string name)
    358                 {
    359                         EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
    360                 }
    361 
    362                 /// <summary>
    363                 /// GUIs the log message.
    364                 /// </summary>
    365                 /// <param name="message">The message.</param>
    366                 /// <param name="logLevel">The log level.</param>
    367                 private void GuiLogMessage(string message, NotificationLevel logLevel)
    368                 {
    369                         EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
    370                 }
    371 
    372                 #endregion
    373         }
     251    /// <summary>
     252    /// Provide all presentation stuff in this user control, it will be opened in an tab.
     253    /// Return null if your plugin has no presentation.
     254    /// </summary>
     255    /// <value>The presentation.</value>
     256    public System.Windows.Controls.UserControl Presentation
     257    {
     258      get
     259      {
     260        return null;
     261      }
     262    }
     263
     264    /// <summary>
     265    /// Gets the quick watch presentation - will be displayed inside of the plugin presentation-element. You
     266    /// can return the existing Presentation if it makes sense to display it inside a small area. But be aware that
     267    /// if Presentation is displayed in QuickWatchPresentation you can't open Presentation it in a tab before you
     268    /// you close QuickWatchPresentation;
     269    /// Return null if your plugin has no QuickWatchPresentation.
     270    /// </summary>
     271    /// <value>The quick watch presentation.</value>
     272    public System.Windows.Controls.UserControl QuickWatchPresentation
     273    {
     274      get
     275      {
     276        return null;
     277      }
     278    }
     279
     280    /// <summary>
     281    /// Will be called from editor after restoring settings and before adding to workspace.
     282    /// </summary>
     283    public void Initialize()
     284    {
     285      GuiLogMessage("Initialize.", NotificationLevel.Debug);
     286    }
     287
     288    /// <summary>
     289    /// Will be called from editor before right before chain-run starts
     290    /// </summary>
     291    public void PreExecution()
     292    {
     293      GuiLogMessage("PreExecution.", NotificationLevel.Debug);
     294    }
     295
     296    /// <summary>
     297    /// Will be called from editor while chain-run is active and after last necessary input
     298    /// for plugin has been set.
     299    /// </summary>
     300    public void Execute()
     301    {
     302      GuiLogMessage("Execute.", NotificationLevel.Debug);
     303      Hash();
     304    }
     305
     306    /// <summary>
     307    /// Will be called from editor after last plugin in chain has finished its work.
     308    /// </summary>
     309    public void PostExecution()
     310    {
     311      GuiLogMessage("PostExecution.", NotificationLevel.Debug);
     312    }
     313
     314    /// <summary>
     315    /// Not defined yet.
     316    /// </summary>
     317    public void Pause()
     318    {
     319      GuiLogMessage("Pause.", NotificationLevel.Debug);
     320    }
     321
     322    /// <summary>
     323    /// Will be called from editor while chain-run is active. Plugin hast to stop work immediately.
     324    /// </summary>
     325    public void Stop()
     326    {
     327      GuiLogMessage("Stop.", NotificationLevel.Debug);
     328    }
     329
     330    /// <summary>
     331    /// Will be called from editor when element is deleted from worksapce.
     332    /// Releases unmanaged and - optionally - managed resources
     333    /// </summary>
     334    public void Dispose()
     335    {
     336      foreach (CryptoolStream stream in listCryptoolStreamsOut)
     337      {
     338        stream.Close();
     339      }
     340      listCryptoolStreamsOut.Clear();
     341      GuiLogMessage("Dispose.", NotificationLevel.Debug);
     342    }
     343
     344    #endregion
     345
     346    #region INotifyPropertyChanged Member
     347
     348    /// <summary>
     349    /// Occurs when a property value changes.
     350    /// </summary>
     351    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
     352
     353    /// <summary>
     354    /// Called when [property changed].
     355    /// </summary>
     356    /// <param name="name">The name.</param>
     357    protected void OnPropertyChanged(string name)
     358    {
     359      EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
     360    }
     361
     362    /// <summary>
     363    /// GUIs the log message.
     364    /// </summary>
     365    /// <param name="message">The message.</param>
     366    /// <param name="logLevel">The log level.</param>
     367    private void GuiLogMessage(string message, NotificationLevel logLevel)
     368    {
     369      EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
     370    }
     371
     372    #endregion
     373  }
    374374}
  • trunk/CrypPlugins/Whirlpool/whirlpool.cs

    r126 r138  
    2121namespace Whirlpool
    2222{
    23         /// <summary>
    24         // The Whirlpool algorithm was developed by
    25         // Paulo S. L. M. Barreto and Vincent Rijmen.
    26         //
    27         // See
    28         //      P.S.L.M. Barreto, V. Rijmen,
    29         //      ``The Whirlpool hashing function,''
    30         //      NESSIE submission, 2000 (tweaked version, 2001),
    31         //      <https://www.cosic.esat.kuleuven.ac.be/nessie/workshop/submissions/whirlpool.zip>
    32         //
    33         /// </summary>
    34         public class WhirlpoolHash
    35         {
    36                 const int DIGESTBYTES = 64;
    37                 const int DIGESTBITS  = DIGESTBYTES * 8;
    38                 const int WBLOCKBYTES = 64;
    39                 const int WBLOCKBITS  = WBLOCKBYTES * 8;
    40                 const int LENGTHBYTES = 32;
    41                 const int LENGTHBITS  = LENGTHBYTES * 8;
    42 
    43                 // The number of rounds of the internal dedicated block cipher.
    44                 const int R = 10;
    45 
    46                 byte[]  bitLength;  // global number of hashed bits (256-bit counter)
    47                 byte[]  buffer;           // buffer of data to hash
    48                 ulong   bufferBits; // current number of bits on the buffer
    49                 ulong   bufferPos;  // current (possibly incomplete) byte slot on the buffer
    50                 ulong[] hash;       // the hashing state
    51 
    52                 byte[]  digest;                 // the final whirlpool hash of input data
    53 
    54                 /// <summary>
    55                 /// Initializes a new instance of the <see cref="WhirlpoolHash"/> class.
    56                 /// </summary>
    57                 public WhirlpoolHash()
    58                 {
    59                         // all values are zeroed by default
    60                         bitLength = new byte[LENGTHBYTES];
    61                         buffer = new byte[WBLOCKBYTES];
    62                         hash = new ulong[DIGESTBYTES / 8];
    63                         digest = null;
    64                 }
    65 
    66                 /// <summary>
    67                 /// Releases unmanaged and - optionally - managed resources
    68                 /// </summary>
    69                 /// <param name="disposing"><c>true</c>to release both managed and unmanaged resources;
    70                 /// <c>false</c> to release only unmanaged resources.</param>
    71                 public void Dispose(bool disposing)
    72                 {
    73                         if (disposing)
    74                         {
    75                                 bitLength = null;
    76                                 buffer = null;
    77                                 hash = null;
    78                         }
    79                 }
    80 
    81                 /// <summary>
    82                 /// Adds the specified source.
    83                 /// </summary>
    84                 /// <param name="source">The source.</param>
    85                 public void Add(byte[] source)
    86                 {
    87                         ulong bits = 0;
    88                         if (null != source)
    89                                 bits = (ulong)source.Length * 8;
    90                         Add(source, bits);
    91                 }
    92 
    93                 /// <summary>
    94                 /// Adds data.
    95                 /// </summary>
    96                 /// <param name="source">plaintext data to hash.</param>
    97                 /// <param name="sourceBits">how many bits of plaintext to process.</param>
    98                 public void Add(byte[] source, ulong sourceBits)
    99                 {
    100                         //                    sourcePos
    101                         //                    |
    102                         //                    +-------+-------+-------
    103                         //                       ||||||||||||||||||||| source
    104                         //                    +-------+-------+-------
    105                         // +-------+-------+-------+-------+-------+-------
    106                         // ||||||||||||||||||||||                           buffer
    107                         // +-------+-------+-------+-------+-------+-------
    108                         //                 |
    109                         //                 bufferPos
    110 
    111                         // index of leftmost source ulong containing data (1 to 8 bits).
    112                         ulong sourcePos    = 0;
    113 
    114                         // space on source[sourcePos].
    115                         byte sourceGap    = (byte)((8 - (sourceBits % 8)) % 8);
    116 
    117                         // occupied bits on buffer[bufferPos].
    118                         byte bufferRem    = (byte)(bufferBits % 8);
    119                         ulong i;
    120                         byte b;
    121                         ulong carry;
    122 
    123                         // tally the length of the added data:
    124                         ulong value = sourceBits;
    125                         for (i = 31, carry = 0; i >= 0 && (carry != 0 || value != 0); i--)
    126                         {
    127                                 carry += bitLength[i] + (value & 0xff);
    128                                 bitLength[i] = (byte)carry;
    129                                 carry >>= 8;
    130                                 value >>= 8;
    131                         }
    132 
    133                         // process data in chunks of 8 bits
    134                         // (a more efficient approach would be to take whole-word chunks):
    135                         while (sourceBits > 8)
    136                         {
    137                                 // N.B. at least source[sourcePos] and source[sourcePos+1] contain data.
    138                                 // take a byte from the source:
    139                                 ulong s0 = source[sourcePos];
    140                                 ulong s1 = source[sourcePos + 1];
    141                                 b = (byte)(((s0 << sourceGap) & 0x00ff) |
    142                                                 ((s1 & 0x00ff) >> (8 - sourceGap)));
    143 
    144                                 // process this byte:
    145                                 buffer[bufferPos++] |= (byte)(b >> bufferRem);
    146                                 bufferBits += (ulong)(8 - bufferRem);
    147                                 if (bufferBits == DIGESTBITS)
    148                                 {
    149                                         // process data block:
    150                                         processBuffer();
    151                                         // reset buffer:
    152                                         bufferBits = bufferPos = 0;
    153                                 }
    154                                 buffer[bufferPos] = (byte)(b << (8 - bufferRem));
    155                                 bufferBits += bufferRem;
    156                                 // proceed to remaining data:
    157                                 sourceBits -= 8;
    158                                 sourcePos++;
    159                         }
    160 
    161                         // now 0 <= sourceBits <= 8;
    162                         // furthermore, all data (if any is left) is in source[sourcePos].
    163                         if (sourceBits > 0)
    164                         {
    165                                 b = (byte)((source[sourcePos] << sourceGap) & 0x00ff); /* bits are left-justified on b. */
    166                                 // process the remaining bits:
    167                                 buffer[bufferPos] |= (byte)(b >> bufferRem);
    168                         }
    169                         else
    170                         {
    171                                 b = 0;
    172                         }
    173                         if (bufferRem + sourceBits < 8)
    174                         {
    175                                 // all remaining data fits on buffer[bufferPos],
    176                                 // and there still remains some space.
    177                                 bufferBits += sourceBits;
    178                         }
    179                         else
    180                         {
    181                                 // buffer[bufferPos] is full:
    182                                 bufferPos++;
    183                                 ulong diff = (ulong)(8 - bufferRem); /* bufferBits = 8*bufferPos; */
    184                                 bufferBits += diff;
    185                                 sourceBits -= diff;
    186                                 // now 0 <= sourceBits < 8;
    187                                 // furthermore, all data (if any is left) is in source[sourcePos].
    188                                 if (bufferBits == DIGESTBITS)
    189                                 {
    190                                         // process data block:
    191                                         processBuffer();
    192                                         // reset buffer:
    193                                         bufferBits = bufferPos = 0;
    194                                 }
    195                                 buffer[bufferPos] = (byte)(b << (8 - bufferRem));
    196                                 bufferBits += sourceBits;
    197                         }
    198                 }
    199 
    200                 public void Finish()
    201                 {
    202                         // append a '1'-bit:
    203                         buffer[bufferPos] |= (byte)(0x80U >> (int)(bufferBits % 8));
    204                         // all remaining bits on the current ulong are set to zero.
    205                         bufferPos++;
    206 
    207                         // pad with zero bits to complete (N*WBLOCKBITS - LENGTHBITS) bits:
    208                         if (bufferPos > WBLOCKBYTES - LENGTHBYTES)
    209                         {
    210                                 if (bufferPos < WBLOCKBYTES)
    211                                 {
    212                                         for (ulong i = bufferPos; i < WBLOCKBYTES; i++)
    213                                                 buffer[i] = 0;
    214                                 }
    215                                 // process data block:
    216                                 processBuffer();
    217                                 // reset buffer:
    218                                 bufferPos = 0;
    219                         }
    220                         if (bufferPos < WBLOCKBYTES - LENGTHBYTES)
    221                         {
    222                                 for (ulong i = bufferPos; i < (WBLOCKBYTES - LENGTHBYTES); i++)
    223                                         buffer[i] = 0;
    224                         }
    225                         bufferPos = WBLOCKBYTES - LENGTHBYTES;
    226                         // append bit length of hashed data:
    227                         // memcpy(&buffer[WBLOCKBYTES - LENGTHBYTES], bitLength, LENGTHBYTES);
    228                         for (int i = 0; i < LENGTHBYTES; i++)
    229                         {
    230                                 int j = i + WBLOCKBYTES - LENGTHBYTES;
    231                                 buffer[j] = bitLength[i];
    232                         }
    233 
    234                         // process data block:
    235                         processBuffer();
    236 
    237                         digest = new byte[DIGESTBYTES];
    238 
    239                         for (int i = 0; i < DIGESTBYTES / 8; i++)
    240                         {
    241                                 int j = i * 8;
    242                                 digest[j + 0] = (byte)(hash[i] >> 56);
    243                                 digest[j + 1] = (byte)(hash[i] >> 48);
    244                                 digest[j + 2] = (byte)(hash[i] >> 40);
    245                                 digest[j + 3] = (byte)(hash[i] >> 32);
    246                                 digest[j + 4] = (byte)(hash[i] >> 24);
    247                                 digest[j + 5] = (byte)(hash[i] >> 16);
    248                                 digest[j + 6] = (byte)(hash[i] >> 8);
    249                                 digest[j + 7] = (byte)(hash[i]);
    250                         }
    251                 }
    252 
    253 
    254                 /// <summary>
    255                 /// Gets the hash.
    256                 /// </summary>
    257                 /// <value>The hash.</value>
    258                 public byte[] Hash
    259                 {
    260                         get
    261                         {
    262                                 return digest;
    263                         }
    264                 }
    265 
    266                 /// <summary>
    267                 /// Releases unmanaged resources and performs other cleanup operations before the
    268                 /// <see cref="WhirlpoolHash"/> is reclaimed by garbage collection.
    269                 /// </summary>
    270                 ~WhirlpoolHash()
    271                 {
    272                         bitLength = null;
    273                         buffer = null;
    274                         hash = null;
    275                 }
    276 
    277 
    278                 readonly static ulong[] C0 =
     23  /// <summary>
     24  // The Whirlpool algorithm was developed by
     25  // Paulo S. L. M. Barreto and Vincent Rijmen.
     26  //
     27  // See
     28  //      P.S.L.M. Barreto, V. Rijmen,
     29  //      ``The Whirlpool hashing function,''
     30  //      NESSIE submission, 2000 (tweaked version, 2001),
     31  //      <https://www.cosic.esat.kuleuven.ac.be/nessie/workshop/submissions/whirlpool.zip>
     32  //
     33  /// </summary>
     34  public class WhirlpoolHash
     35  {
     36    const int DIGESTBYTES = 64;
     37    const int DIGESTBITS  = DIGESTBYTES * 8;
     38    const int WBLOCKBYTES = 64;
     39    const int WBLOCKBITS  = WBLOCKBYTES * 8;
     40    const int LENGTHBYTES = 32;
     41    const int LENGTHBITS  = LENGTHBYTES * 8;
     42
     43    // The number of rounds of the internal dedicated block cipher.
     44    const int R = 10;
     45
     46    byte[]  bitLength;  // global number of hashed bits (256-bit counter)
     47    byte[]  buffer;               // buffer of data to hash
     48    ulong   bufferBits; // current number of bits on the buffer
     49    ulong   bufferPos;  // current (possibly incomplete) byte slot on the buffer
     50    ulong[] hash;       // the hashing state
     51
     52    byte[]  digest;                     // the final whirlpool hash of input data
     53
     54    /// <summary>
     55    /// Initializes a new instance of the <see cref="WhirlpoolHash"/> class.
     56    /// </summary>
     57    public WhirlpoolHash()
     58    {
     59      // all values are zeroed by default
     60      bitLength = new byte[LENGTHBYTES];
     61      buffer = new byte[WBLOCKBYTES];
     62      hash = new ulong[DIGESTBYTES / 8];
     63      digest = null;
     64    }
     65
     66    /// <summary>
     67    /// Releases unmanaged and - optionally - managed resources
     68    /// </summary>
     69    /// <param name="disposing"><c>true</c>to release both managed and unmanaged resources;
     70    /// <c>false</c> to release only unmanaged resources.</param>
     71    public void Dispose(bool disposing)
     72    {
     73      if (disposing)
     74      {
     75        bitLength = null;
     76        buffer = null;
     77        hash = null;
     78      }
     79    }
     80
     81    /// <summary>
     82    /// Adds the specified source.
     83    /// </summary>
     84    /// <param name="source">The source.</param>
     85    public void Add(byte[] source)
     86    {
     87      ulong bits = 0;
     88      if (null != source)
     89        bits = (ulong)source.Length * 8;
     90      Add(source, bits);
     91    }
     92
     93    /// <summary>
     94    /// Adds data.
     95    /// </summary>
     96    /// <param name="source">plaintext data to hash.</param>
     97    /// <param name="sourceBits">how many bits of plaintext to process.</param>
     98    public void Add(byte[] source, ulong sourceBits)
     99    {
     100      //                    sourcePos
     101      //                    |
     102      //                    +-------+-------+-------
     103      //                       ||||||||||||||||||||| source
     104      //                    +-------+-------+-------
     105      // +-------+-------+-------+-------+-------+-------
     106      // ||||||||||||||||||||||                           buffer
     107      // +-------+-------+-------+-------+-------+-------
     108      //                 |
     109      //                 bufferPos
     110
     111      // index of leftmost source ulong containing data (1 to 8 bits).
     112      ulong sourcePos    = 0;
     113
     114      // space on source[sourcePos].
     115      byte sourceGap    = (byte)((8 - (sourceBits % 8)) % 8);
     116
     117      // occupied bits on buffer[bufferPos].
     118      byte bufferRem    = (byte)(bufferBits % 8);
     119      ulong i;
     120      byte b;
     121      ulong carry;
     122
     123      // tally the length of the added data:
     124      ulong value = sourceBits;
     125      for (i = 31, carry = 0; i >= 0 && (carry != 0 || value != 0); i--)
     126      {
     127        carry += bitLength[i] + (value & 0xff);
     128        bitLength[i] = (byte)carry;
     129        carry >>= 8;
     130        value >>= 8;
     131      }
     132
     133      // process data in chunks of 8 bits
     134      // (a more efficient approach would be to take whole-word chunks):
     135      while (sourceBits > 8)
     136      {
     137        // N.B. at least source[sourcePos] and source[sourcePos+1] contain data.
     138        // take a byte from the source:
     139        ulong s0 = source[sourcePos];
     140        ulong s1 = source[sourcePos + 1];
     141        b = (byte)(((s0 << sourceGap) & 0x00ff) |
     142            ((s1 & 0x00ff) >> (8 - sourceGap)));
     143
     144        // process this byte:
     145        buffer[bufferPos++] |= (byte)(b >> bufferRem);
     146        bufferBits += (ulong)(8 - bufferRem);
     147        if (bufferBits == DIGESTBITS)
     148        {
     149          // process data block:
     150          processBuffer();
     151          // reset buffer:
     152          bufferBits = bufferPos = 0;
     153        }
     154        buffer[bufferPos] = (byte)(b << (8 - bufferRem));
     155        bufferBits += bufferRem;
     156        // proceed to remaining data:
     157        sourceBits -= 8;
     158        sourcePos++;
     159      }
     160
     161      // now 0 <= sourceBits <= 8;
     162      // furthermore, all data (if any is left) is in source[sourcePos].
     163      if (sourceBits > 0)
     164      {
     165        b = (byte)((source[sourcePos] << sourceGap) & 0x00ff); /* bits are left-justified on b. */
     166        // process the remaining bits:
     167        buffer[bufferPos] |= (byte)(b >> bufferRem);
     168      }
     169      else
     170      {
     171        b = 0;
     172      }
     173      if (bufferRem + sourceBits < 8)
     174      {
     175        // all remaining data fits on buffer[bufferPos],
     176        // and there still remains some space.
     177        bufferBits += sourceBits;
     178      }
     179      else
     180      {
     181        // buffer[bufferPos] is full:
     182        bufferPos++;
     183        ulong diff = (ulong)(8 - bufferRem); /* bufferBits = 8*bufferPos; */
     184        bufferBits += diff;
     185        sourceBits -= diff;
     186        // now 0 <= sourceBits < 8;
     187        // furthermore, all data (if any is left) is in source[sourcePos].
     188        if (bufferBits == DIGESTBITS)
     189        {
     190          // process data block:
     191          processBuffer();
     192          // reset buffer:
     193          bufferBits = bufferPos = 0;
     194        }
     195        buffer[bufferPos] = (byte)(b << (8 - bufferRem));
     196        bufferBits += sourceBits;
     197      }
     198    }
     199
     200    public void Finish()
     201    {
     202      // append a '1'-bit:
     203      buffer[bufferPos] |= (byte)(0x80U >> (int)(bufferBits % 8));
     204      // all remaining bits on the current ulong are set to zero.
     205      bufferPos++;
     206
     207      // pad with zero bits to complete (N*WBLOCKBITS - LENGTHBITS) bits:
     208      if (bufferPos > WBLOCKBYTES - LENGTHBYTES)
     209      {
     210        if (bufferPos < WBLOCKBYTES)
     211        {
     212          for (ulong i = bufferPos; i < WBLOCKBYTES; i++)
     213            buffer[i] = 0;
     214        }
     215        // process data block:
     216        processBuffer();
     217        // reset buffer:
     218        bufferPos = 0;
     219      }
     220      if (bufferPos < WBLOCKBYTES - LENGTHBYTES)
     221      {
     222        for (ulong i = bufferPos; i < (WBLOCKBYTES - LENGTHBYTES); i++)
     223          buffer[i] = 0;
     224      }
     225      bufferPos = WBLOCKBYTES - LENGTHBYTES;
     226      // append bit length of hashed data:
     227      // memcpy(&buffer[WBLOCKBYTES - LENGTHBYTES], bitLength, LENGTHBYTES);
     228      for (int i = 0; i < LENGTHBYTES; i++)
     229      {
     230        int j = i + WBLOCKBYTES - LENGTHBYTES;
     231        buffer[j] = bitLength[i];
     232      }
     233
     234      // process data block:
     235      processBuffer();
     236
     237      digest = new byte[DIGESTBYTES];
     238
     239      for (int i = 0; i < DIGESTBYTES / 8; i++)
     240      {
     241        int j = i * 8;
     242        digest[j + 0] = (byte)(hash[i] >> 56);
     243        digest[j + 1] = (byte)(hash[i] >> 48);
     244        digest[j + 2] = (byte)(hash[i] >> 40);
     245        digest[j + 3] = (byte)(hash[i] >> 32);
     246        digest[j + 4] = (byte)(hash[i] >> 24);
     247        digest[j + 5] = (byte)(hash[i] >> 16);
     248        digest[j + 6] = (byte)(hash[i] >> 8);
     249        digest[j + 7] = (byte)(hash[i]);
     250      }
     251    }
     252
     253
     254    /// <summary>
     255    /// Gets the hash.
     256    /// </summary>
     257    /// <value>The hash.</value>
     258    public byte[] Hash
     259    {
     260      get
     261      {
     262        return digest;
     263      }
     264    }
     265
     266    /// <summary>
     267    /// Releases unmanaged resources and performs other cleanup operations before the
     268    /// <see cref="WhirlpoolHash"/> is reclaimed by garbage collection.
     269    /// </summary>
     270    ~WhirlpoolHash()
     271    {
     272      bitLength = null;
     273      buffer = null;
     274      hash = null;
     275    }
     276
     277
     278    readonly static ulong[] C0 =
    279279                {
    280280                        0x18186018c07830d8, 0x23238c2305af4626, 0xc6c63fc67ef991b8, 0xe8e887e8136fcdfb,
     
    344344                };
    345345
    346                 readonly static ulong[] C1 =
     346    readonly static ulong[] C1 =
    347347                {
    348348                        0xd818186018c07830, 0x2623238c2305af46, 0xb8c6c63fc67ef991, 0xfbe8e887e8136fcd,
     
    412412                };
    413413
    414                 readonly static ulong[] C2 =
     414    readonly static ulong[] C2 =
    415415                {
    416416                        0x30d818186018c078, 0x462623238c2305af, 0x91b8c6c63fc67ef9, 0xcdfbe8e887e8136f,
     
    480480                };
    481481
    482                 readonly static ulong[] C3 =
     482    readonly static ulong[] C3 =
    483483                {
    484484                        0x7830d818186018c0, 0xaf462623238c2305, 0xf991b8c6c63fc67e, 0x6fcdfbe8e887e813,
     
    548548                };
    549549
    550                 readonly static ulong[] C4 =
     550    readonly static ulong[] C4 =
    551551                {
    552552                        0xc07830d818186018, 0x05af462623238c23, 0x7ef991b8c6c63fc6, 0x136fcdfbe8e887e8,
     
    616616                };
    617617
    618                 readonly static ulong[] C5 =
     618    readonly static ulong[] C5 =
    619619                {
    620620                        0x18c07830d8181860, 0x2305af462623238c, 0xc67ef991b8c6c63f, 0xe8136fcdfbe8e887,
     
    684684                };
    685685
    686                 readonly static ulong[] C6 =
     686    readonly static ulong[] C6 =
    687687                {
    688688                        0x6018c07830d81818, 0x8c2305af46262323, 0x3fc67ef991b8c6c6, 0x87e8136fcdfbe8e8,
     
    752752                };
    753753
    754                 readonly static ulong[] C7 =
     754    readonly static ulong[] C7 =
    755755                {
    756756                        0x186018c07830d818, 0x238c2305af462623, 0xc63fc67ef991b8c6, 0xe887e8136fcdfbe8,
     
    820820                };
    821821
    822                 readonly static ulong[] rc =
     822    readonly static ulong[] rc =
    823823                {
    824824                        0x0000000000000000,
     
    836836
    837837
    838                 // The core Whirlpool transform.
    839                 void processBuffer()
    840                 {
    841                         int r;
    842                         ulong[] K     = new ulong[8];    // the round input
    843                         ulong[] block = new ulong[8];    // mu(buffer)
    844                         ulong[] state = new ulong[8];    // the cipher state
    845                         ulong[] L     = new ulong[8];
     838    // The core Whirlpool transform.
     839    void processBuffer()
     840    {
     841      int r;
     842      ulong[] K     = new ulong[8];    // the round input
     843      ulong[] block = new ulong[8];    // mu(buffer)
     844      ulong[] state = new ulong[8];    // the cipher state
     845      ulong[] L     = new ulong[8];
    846846
    847847#if DEBUG2
     
    857857#endif
    858858
    859                         // map the buffer to a block:
    860                         for (int i = 0; i < 8; i++)
    861                         {
    862                                 int ibuffer = i * 8;
    863                                 block[i] =
    864                                                 (((ulong)buffer[ibuffer + 0]) << 56) ^
    865                                                 (((ulong)buffer[ibuffer + 1] & 0xffL) << 48) ^
    866                                                 (((ulong)buffer[ibuffer + 2] & 0xffL) << 40) ^
    867                                                 (((ulong)buffer[ibuffer + 3] & 0xffL) << 32) ^
    868                                                 (((ulong)buffer[ibuffer + 4] & 0xffL) << 24) ^
    869                                                 (((ulong)buffer[ibuffer + 5] & 0xffL) << 16) ^
    870                                                 (((ulong)buffer[ibuffer + 6] & 0xffL) << 8) ^
    871                                                 (((ulong)buffer[ibuffer + 7] & 0xffL));
    872                         }
    873 
    874                         // compute and apply K^0 to the cipher state:
    875                         state[0] = block[0] ^ (K[0] = hash[0]);
    876                         state[1] = block[1] ^ (K[1] = hash[1]);
    877                         state[2] = block[2] ^ (K[2] = hash[2]);
    878                         state[3] = block[3] ^ (K[3] = hash[3]);
    879                         state[4] = block[4] ^ (K[4] = hash[4]);
    880                         state[5] = block[5] ^ (K[5] = hash[5]);
    881                         state[6] = block[6] ^ (K[6] = hash[6]);
    882                         state[7] = block[7] ^ (K[7] = hash[7]);
     859      // map the buffer to a block:
     860      for (int i = 0; i < 8; i++)
     861      {
     862        int ibuffer = i * 8;
     863        block[i] =
     864            (((ulong)buffer[ibuffer + 0]) << 56) ^
     865            (((ulong)buffer[ibuffer + 1] & 0xffL) << 48) ^
     866            (((ulong)buffer[ibuffer + 2] & 0xffL) << 40) ^
     867            (((ulong)buffer[ibuffer + 3] & 0xffL) << 32) ^
     868            (((ulong)buffer[ibuffer + 4] & 0xffL) << 24) ^
     869            (((ulong)buffer[ibuffer + 5] & 0xffL) << 16) ^
     870            (((ulong)buffer[ibuffer + 6] & 0xffL) << 8) ^
     871            (((ulong)buffer[ibuffer + 7] & 0xffL));
     872      }
     873
     874      // compute and apply K^0 to the cipher state:
     875      state[0] = block[0] ^ (K[0] = hash[0]);
     876      state[1] = block[1] ^ (K[1] = hash[1]);
     877      state[2] = block[2] ^ (K[2] = hash[2]);
     878      state[3] = block[3] ^ (K[3] = hash[3]);
     879      state[4] = block[4] ^ (K[4] = hash[4]);
     880      state[5] = block[5] ^ (K[5] = hash[5]);
     881      state[6] = block[6] ^ (K[6] = hash[6]);
     882      state[7] = block[7] ^ (K[7] = hash[7]);
    883883
    884884#if DEBUG2
     
    894894                        Debug.WriteLine("");
    895895#endif
    896                         /*
     896      /*
    897897   * iterate over all rounds:
    898898   */
    899                         for (r = 1; r <= R; r++)
    900                         {
    901                                 /*
    902                                 * compute K^r from K^{r-1}:
    903                                 */
    904                                 L[0] =
    905                                                 C0[(ulong)(K[0] >> 56)] ^
    906                                                 C1[(ulong)(K[7] >> 48) & 0xff] ^
    907                                                 C2[(ulong)(K[6] >> 40) & 0xff] ^
    908                                                 C3[(ulong)(K[5] >> 32) & 0xff] ^
    909                                                 C4[(ulong)(K[4] >> 24) & 0xff] ^
    910                                                 C5[(ulong)(K[3] >> 16) & 0xff] ^
    911                                                 C6[(ulong)(K[2] >> 8) & 0xff] ^
    912                                                 C7[(ulong)(K[1]) & 0xff] ^ rc[r];
    913                                 L[1] =
    914                                                 C0[(ulong)(K[1] >> 56)] ^
    915                                                 C1[(ulong)(K[0] >> 48) & 0xff] ^
    916                                                 C2[(ulong)(K[7] >> 40) & 0xff] ^
    917                                                 C3[(ulong)(K[6] >> 32) & 0xff] ^
    918                                                 C4[(ulong)(K[5] >> 24) & 0xff] ^
    919                                                 C5[(ulong)(K[4] >> 16) & 0xff] ^
    920                                                 C6[(ulong)(K[3] >> 8) & 0xff] ^
    921                                                 C7[(ulong)(K[2]) & 0xff];
    922                                 L[2] =
    923                                                 C0[(ulong)(K[2] >> 56)] ^
    924                                                 C1[(ulong)(K[1] >> 48) & 0xff] ^
    925                                                 C2[(ulong)(K[0] >> 40) & 0xff] ^
    926                                                 C3[(ulong)(K[7] >> 32) & 0xff] ^
    927                                                 C4[(ulong)(K[6] >> 24) & 0xff] ^
    928                                                 C5[(ulong)(K[5] >> 16) & 0xff] ^
    929                                                 C6[(ulong)(K[4] >> 8) & 0xff] ^
    930                                                 C7[(ulong)(K[3]) & 0xff];
    931                                 L[3] =
    932                                                 C0[(ulong)(K[3] >> 56)] ^
    933                                                 C1[(ulong)(K[2] >> 48) & 0xff] ^
    934                                                 C2[(ulong)(K[1] >> 40) & 0xff] ^
    935                                                 C3[(ulong)(K[0] >> 32) & 0xff] ^
    936                                                 C4[(ulong)(K[7] >> 24) & 0xff] ^
    937                                                 C5[(ulong)(K[6] >> 16) & 0xff] ^
    938                                                 C6[(ulong)(K[5] >> 8) & 0xff] ^
    939                                                 C7[(ulong)(K[4]) & 0xff];
    940                                 L[4] =
    941                                                 C0[(ulong)(K[4] >> 56)] ^
    942                                                 C1[(ulong)(K[3] >> 48) & 0xff] ^
    943                                                 C2[(ulong)(K[2] >> 40) & 0xff] ^
    944                                                 C3[(ulong)(K[1] >> 32) & 0xff] ^
    945                                                 C4[(ulong)(K[0] >> 24) & 0xff] ^
    946                                                 C5[(ulong)(K[7] >> 16) & 0xff] ^
    947                                                 C6[(ulong)(K[6] >> 8) & 0xff] ^
    948                                                 C7[(ulong)(K[5]) & 0xff];
    949                                 L[5] =
    950                                                 C0[(ulong)(K[5] >> 56)] ^
    951                                                 C1[(ulong)(K[4] >> 48) & 0xff] ^
    952                                                 C2[(ulong)(K[3] >> 40) & 0xff] ^
    953                                                 C3[(ulong)(K[2] >> 32) & 0xff] ^
    954                                                 C4[(ulong)(K[1] >> 24) & 0xff] ^
    955                                                 C5[(ulong)(K[0] >> 16) & 0xff] ^
    956                                                 C6[(ulong)(K[7] >> 8) & 0xff] ^
    957                                                 C7[(ulong)(K[6]) & 0xff];
    958                                 L[6] =
    959                                                 C0[(ulong)(K[6] >> 56)] ^
    960                                                 C1[(ulong)(K[5] >> 48) & 0xff] ^
    961                                                 C2[(ulong)(K[4] >> 40) & 0xff] ^
    962                                                 C3[(ulong)(K[3] >> 32) & 0xff] ^
    963                                                 C4[(ulong)(K[2] >> 24) & 0xff] ^
    964                                                 C5[(ulong)(K[1] >> 16) & 0xff] ^
    965                                                 C6[(ulong)(K[0] >> 8) & 0xff] ^
    966                                                 C7[(ulong)(K[7]) & 0xff];
    967                                 L[7] =
    968                                                 C0[(ulong)(K[7] >> 56)] ^
    969                                                 C1[(ulong)(K[6] >> 48) & 0xff] ^
    970                                                 C2[(ulong)(K[5] >> 40) & 0xff] ^
    971                                                 C3[(ulong)(K[4] >> 32) & 0xff] ^
    972                                                 C4[(ulong)(K[3] >> 24) & 0xff] ^
    973                                                 C5[(ulong)(K[2] >> 16) & 0xff] ^
    974                                                 C6[(ulong)(K[1] >> 8) & 0xff] ^
    975                                                 C7[(ulong)(K[0]) & 0xff];
    976                                 K[0] = L[0];
    977                                 K[1] = L[1];
    978                                 K[2] = L[2];
    979                                 K[3] = L[3];
    980                                 K[4] = L[4];
    981                                 K[5] = L[5];
    982                                 K[6] = L[6];
    983                                 K[7] = L[7];
    984                                 /*
    985                                 * apply the r-th round transformation:
    986                                 */
    987                                 L[0] =
    988                                                 C0[(ulong)(state[0] >> 56)] ^
    989                                                 C1[(ulong)(state[7] >> 48) & 0xff] ^
    990                                                 C2[(ulong)(state[6] >> 40) & 0xff] ^
    991                                                 C3[(ulong)(state[5] >> 32) & 0xff] ^
    992                                                 C4[(ulong)(state[4] >> 24) & 0xff] ^
    993                                                 C5[(ulong)(state[3] >> 16) & 0xff] ^
    994                                                 C6[(ulong)(state[2] >> 8) & 0xff] ^
    995                                                 C7[(ulong)(state[1]) & 0xff] ^
    996                                                 K[0];
    997                                 L[1] =
    998                                                 C0[(ulong)(state[1] >> 56)] ^
    999                                                 C1[(ulong)(state[0] >> 48) & 0xff] ^
    1000                                                 C2[(ulong)(state[7] >> 40) & 0xff] ^
    1001                                                 C3[(ulong)(state[6] >> 32) & 0xff] ^
    1002                                                 C4[(ulong)(state[5] >> 24) & 0xff] ^
    1003                                                 C5[(ulong)(state[4] >> 16) & 0xff] ^
    1004                                                 C6[(ulong)(state[3] >> 8) & 0xff] ^
    1005                                                 C7[(ulong)(state[2]) & 0xff] ^
    1006                                                 K[1];
    1007                                 L[2] =
    1008                                                 C0[(ulong)(state[2] >> 56)] ^
    1009                                                 C1[(ulong)(state[1] >> 48) & 0xff] ^
    1010                                                 C2[(ulong)(state[0] >> 40) & 0xff] ^
    1011                                                 C3[(ulong)(state[7] >> 32) & 0xff] ^
    1012                                                 C4[(ulong)(state[6] >> 24) & 0xff] ^
    1013                                                 C5[(ulong)(state[5] >> 16) & 0xff] ^
    1014                                                 C6[(ulong)(state[4] >> 8) & 0xff] ^
    1015                                                 C7[(ulong)(state[3]) & 0xff] ^
    1016                                                 K[2];
    1017                                 L[3] =
    1018                                                 C0[(ulong)(state[3] >> 56)] ^
    1019                                                 C1[(ulong)(state[2] >> 48) & 0xff] ^
    1020                                                 C2[(ulong)(state[1] >> 40) & 0xff] ^
    1021                                                 C3[(ulong)(state[0] >> 32) & 0xff] ^
    1022                                                 C4[(ulong)(state[7] >> 24) & 0xff] ^
    1023                                                 C5[(ulong)(state[6] >> 16) & 0xff] ^
    1024                                                 C6[(ulong)(state[5] >> 8) & 0xff] ^
    1025                                                 C7[(ulong)(state[4]) & 0xff] ^
    1026                                                 K[3];
    1027                                 L[4] =
    1028                                                 C0[(ulong)(state[4] >> 56)] ^
    1029                                                 C1[(ulong)(state[3] >> 48) & 0xff] ^
    1030                                                 C2[(ulong)(state[2] >> 40) & 0xff] ^
    1031                                                 C3[(ulong)(state[1] >> 32) & 0xff] ^
    1032                                                 C4[(ulong)(state[0] >> 24) & 0xff] ^
    1033                                                 C5[(ulong)(state[7] >> 16) & 0xff] ^
    1034                                                 C6[(ulong)(state[6] >> 8) & 0xff] ^
    1035                                                 C7[(ulong)(state[5]) & 0xff] ^
    1036                                                 K[4];
    1037                                 L[5] =
    1038                                                 C0[(ulong)(state[5] >> 56)] ^
    1039                                                 C1[(ulong)(state[4] >> 48) & 0xff] ^
    1040                                                 C2[(ulong)(state[3] >> 40) & 0xff] ^
    1041                                                 C3[(ulong)(state[2] >> 32) & 0xff] ^
    1042                                                 C4[(ulong)(state[1] >> 24) & 0xff] ^
    1043                                                 C5[(ulong)(state[0] >> 16) & 0xff] ^
    1044                                                 C6[(ulong)(state[7] >> 8) & 0xff] ^
    1045                                                 C7[(ulong)(state[6]) & 0xff] ^
    1046                                                 K[5];
    1047                                 L[6] =
    1048                                                 C0[(ulong)(state[6] >> 56)] ^
    1049                                                 C1[(ulong)(state[5] >> 48) & 0xff] ^
    1050                                                 C2[(ulong)(state[4] >> 40) & 0xff] ^
    1051                                                 C3[(ulong)(state[3] >> 32) & 0xff] ^
    1052                                                 C4[(ulong)(state[2] >> 24) & 0xff] ^
    1053                                                 C5[(ulong)(state[1] >> 16) & 0xff] ^
    1054                                                 C6[(ulong)(state[0] >> 8) & 0xff] ^
    1055                                                 C7[(ulong)(state[7]) & 0xff] ^
    1056                                                 K[6];
    1057                                 L[7] =
    1058                                                 C0[(ulong)(state[7] >> 56)] ^
    1059                                                 C1[(ulong)(state[6] >> 48) & 0xff] ^
    1060                                                 C2[(ulong)(state[5] >> 40) & 0xff] ^
    1061                                                 C3[(ulong)(state[4] >> 32) & 0xff] ^
    1062                                                 C4[(ulong)(state[3] >> 24) & 0xff] ^
    1063                                                 C5[(ulong)(state[2] >> 16) & 0xff] ^
    1064                                                 C6[(ulong)(state[1] >> 8) & 0xff] ^
    1065                                                 C7[(ulong)(state[0]) & 0xff] ^
    1066                                                 K[7];
    1067                                 state[0] = L[0];
    1068                                 state[1] = L[1];
    1069                                 state[2] = L[2];
    1070                                 state[3] = L[3];
    1071                                 state[4] = L[4];
    1072                                 state[5] = L[5];
    1073                                 state[6] = L[6];
    1074                                 state[7] = L[7];
     899      for (r = 1; r <= R; r++)
     900      {
     901        /*
     902        * compute K^r from K^{r-1}:
     903        */
     904        L[0] =
     905            C0[(ulong)(K[0] >> 56)] ^
     906            C1[(ulong)(K[7] >> 48) & 0xff] ^
     907            C2[(ulong)(K[6] >> 40) & 0xff] ^
     908            C3[(ulong)(K[5] >> 32) & 0xff] ^
     909            C4[(ulong)(K[4] >> 24) & 0xff] ^
     910            C5[(ulong)(K[3] >> 16) & 0xff] ^
     911            C6[(ulong)(K[2] >> 8) & 0xff] ^
     912            C7[(ulong)(K[1]) & 0xff] ^ rc[r];
     913        L[1] =
     914            C0[(ulong)(K[1] >> 56)] ^
     915            C1[(ulong)(K[0] >> 48) & 0xff] ^
     916            C2[(ulong)(K[7] >> 40) & 0xff] ^
     917            C3[(ulong)(K[6] >> 32) & 0xff] ^
     918            C4[(ulong)(K[5] >> 24) & 0xff] ^
     919            C5[(ulong)(K[4] >> 16) & 0xff] ^
     920            C6[(ulong)(K[3] >> 8) & 0xff] ^
     921            C7[(ulong)(K[2]) & 0xff];
     922        L[2] =
     923            C0[(ulong)(K[2] >> 56)] ^
     924            C1[(ulong)(K[1] >> 48) & 0xff] ^
     925            C2[(ulong)(K[0] >> 40) & 0xff] ^
     926            C3[(ulong)(K[7] >> 32) & 0xff] ^
     927            C4[(ulong)(K[6] >> 24) & 0xff] ^
     928            C5[(ulong)(K[5] >> 16) & 0xff] ^
     929            C6[(ulong)(K[4] >> 8) & 0xff] ^
     930            C7[(ulong)(K[3]) & 0xff];
     931        L[3] =
     932            C0[(ulong)(K[3] >> 56)] ^
     933            C1[(ulong)(K[2] >> 48) & 0xff] ^
     934            C2[(ulong)(K[1] >> 40) & 0xff] ^
     935            C3[(ulong)(K[0] >> 32) & 0xff] ^
     936            C4[(ulong)(K[7] >> 24) & 0xff] ^
     937            C5[(ulong)(K[6] >> 16) & 0xff] ^
     938            C6[(ulong)(K[5] >> 8) & 0xff] ^
     939            C7[(ulong)(K[4]) & 0xff];
     940        L[4] =
     941            C0[(ulong)(K[4] >> 56)] ^
     942            C1[(ulong)(K[3] >> 48) & 0xff] ^
     943            C2[(ulong)(K[2] >> 40) & 0xff] ^
     944            C3[(ulong)(K[1] >> 32) & 0xff] ^
     945            C4[(ulong)(K[0] >> 24) & 0xff] ^
     946            C5[(ulong)(K[7] >> 16) & 0xff] ^
     947            C6[(ulong)(K[6] >> 8) & 0xff] ^
     948            C7[(ulong)(K[5]) & 0xff];
     949        L[5] =
     950            C0[(ulong)(K[5] >> 56)] ^
     951            C1[(ulong)(K[4] >> 48) & 0xff] ^
     952            C2[(ulong)(K[3] >> 40) & 0xff] ^
     953            C3[(ulong)(K[2] >> 32) & 0xff] ^
     954            C4[(ulong)(K[1] >> 24) & 0xff] ^
     955            C5[(ulong)(K[0] >> 16) & 0xff] ^
     956            C6[(ulong)(K[7] >> 8) & 0xff] ^
     957            C7[(ulong)(K[6]) & 0xff];
     958        L[6] =
     959            C0[(ulong)(K[6] >> 56)] ^
     960            C1[(ulong)(K[5] >> 48) & 0xff] ^
     961            C2[(ulong)(K[4] >> 40) & 0xff] ^
     962            C3[(ulong)(K[3] >> 32) & 0xff] ^
     963            C4[(ulong)(K[2] >> 24) & 0xff] ^
     964            C5[(ulong)(K[1] >> 16) & 0xff] ^
     965            C6[(ulong)(K[0] >> 8) & 0xff] ^
     966            C7[(ulong)(K[7]) & 0xff];
     967        L[7] =
     968            C0[(ulong)(K[7] >> 56)] ^
     969            C1[(ulong)(K[6] >> 48) & 0xff] ^
     970            C2[(ulong)(K[5] >> 40) & 0xff] ^
     971            C3[(ulong)(K[4] >> 32) & 0xff] ^
     972            C4[(ulong)(K[3] >> 24) & 0xff] ^
     973            C5[(ulong)(K[2] >> 16) & 0xff] ^
     974            C6[(ulong)(K[1] >> 8) & 0xff] ^
     975            C7[(ulong)(K[0]) & 0xff];
     976        K[0] = L[0];
     977        K[1] = L[1];
     978        K[2] = L[2];
     979        K[3] = L[3];
     980        K[4] = L[4];
     981        K[5] = L[5];
     982        K[6] = L[6];
     983        K[7] = L[7];
     984        /*
     985        * apply the r-th round transformation:
     986        */
     987        L[0] =
     988            C0[(ulong)(state[0] >> 56)] ^
     989            C1[(ulong)(state[7] >> 48) & 0xff] ^
     990            C2[(ulong)(state[6] >> 40) & 0xff] ^
     991            C3[(ulong)(state[5] >> 32) & 0xff] ^
     992            C4[(ulong)(state[4] >> 24) & 0xff] ^
     993            C5[(ulong)(state[3] >> 16) & 0xff] ^
     994            C6[(ulong)(state[2] >> 8) & 0xff] ^
     995            C7[(ulong)(state[1]) & 0xff] ^
     996            K[0];
     997        L[1] =
     998            C0[(ulong)(state[1] >> 56)] ^
     999            C1[(ulong)(state[0] >> 48) & 0xff] ^
     1000            C2[(ulong)(state[7] >> 40) & 0xff] ^
     1001            C3[(ulong)(state[6] >> 32) & 0xff] ^
     1002            C4[(ulong)(state[5] >> 24) & 0xff] ^
     1003            C5[(ulong)(state[4] >> 16) & 0xff] ^
     1004            C6[(ulong)(state[3] >> 8) & 0xff] ^
     1005            C7[(ulong)(state[2]) & 0xff] ^
     1006            K[1];
     1007        L[2] =
     1008            C0[(ulong)(state[2] >> 56)] ^
     1009            C1[(ulong)(state[1] >> 48) & 0xff] ^
     1010            C2[(ulong)(state[0] >> 40) & 0xff] ^
     1011            C3[(ulong)(state[7] >> 32) & 0xff] ^
     1012            C4[(ulong)(state[6] >> 24) & 0xff] ^
     1013            C5[(ulong)(state[5] >> 16) & 0xff] ^
     1014            C6[(ulong)(state[4] >> 8) & 0xff] ^
     1015            C7[(ulong)(state[3]) & 0xff] ^
     1016            K[2];
     1017        L[3] =
     1018            C0[(ulong)(state[3] >> 56)] ^
     1019            C1[(ulong)(state[2] >> 48) & 0xff] ^
     1020            C2[(ulong)(state[1] >> 40) & 0xff] ^
     1021            C3[(ulong)(state[0] >> 32) & 0xff] ^
     1022            C4[(ulong)(state[7] >> 24) & 0xff] ^
     1023            C5[(ulong)(state[6] >> 16) & 0xff] ^
     1024            C6[(ulong)(state[5] >> 8) & 0xff] ^
     1025            C7[(ulong)(state[4]) & 0xff] ^
     1026            K[3];
     1027        L[4] =
     1028            C0[(ulong)(state[4] >> 56)] ^
     1029            C1[(ulong)(state[3] >> 48) & 0xff] ^
     1030            C2[(ulong)(state[2] >> 40) & 0xff] ^
     1031            C3[(ulong)(state[1] >> 32) & 0xff] ^
     1032            C4[(ulong)(state[0] >> 24) & 0xff] ^
     1033            C5[(ulong)(state[7] >> 16) & 0xff] ^
     1034            C6[(ulong)(state[6] >> 8) & 0xff] ^
     1035            C7[(ulong)(state[5]) & 0xff] ^
     1036            K[4];
     1037        L[5] =
     1038            C0[(ulong)(state[5] >> 56)] ^
     1039            C1[(ulong)(state[4] >> 48) & 0xff] ^
     1040            C2[(ulong)(state[3] >> 40) & 0xff] ^
     1041            C3[(ulong)(state[2] >> 32) & 0xff] ^
     1042            C4[(ulong)(state[1] >> 24) & 0xff] ^
     1043            C5[(ulong)(state[0] >> 16) & 0xff] ^
     1044            C6[(ulong)(state[7] >> 8) & 0xff] ^
     1045            C7[(ulong)(state[6]) & 0xff] ^
     1046            K[5];
     1047        L[6] =
     1048            C0[(ulong)(state[6] >> 56)] ^
     1049            C1[(ulong)(state[5] >> 48) & 0xff] ^
     1050            C2[(ulong)(state[4] >> 40) & 0xff] ^
     1051            C3[(ulong)(state[3] >> 32) & 0xff] ^
     1052            C4[(ulong)(state[2] >> 24) & 0xff] ^
     1053            C5[(ulong)(state[1] >> 16) & 0xff] ^
     1054            C6[(ulong)(state[0] >> 8) & 0xff] ^
     1055            C7[(ulong)(state[7]) & 0xff] ^
     1056            K[6];
     1057        L[7] =
     1058            C0[(ulong)(state[7] >> 56)] ^
     1059            C1[(ulong)(state[6] >> 48) & 0xff] ^
     1060            C2[(ulong)(state[5] >> 40) & 0xff] ^
     1061            C3[(ulong)(state[4] >> 32) & 0xff] ^
     1062            C4[(ulong)(state[3] >> 24) & 0xff] ^
     1063            C5[(ulong)(state[2] >> 16) & 0xff] ^
     1064            C6[(ulong)(state[1] >> 8) & 0xff] ^
     1065            C7[(ulong)(state[0]) & 0xff] ^
     1066            K[7];
     1067        state[0] = L[0];
     1068        state[1] = L[1];
     1069        state[2] = L[2];
     1070        state[3] = L[3];
     1071        state[4] = L[4];
     1072        state[5] = L[5];
     1073        state[6] = L[6];
     1074        state[7] = L[7];
    10751075#if DEBUG2
    10761076                                Debug.WriteLine("i = " + r + "\n");
     
    10831083#endif
    10841084
    1085                         } // for (r = 1; r <= R; r++)
    1086 
    1087                         // apply the Miyaguchi-Preneel compression function:
    1088                         hash[0] ^= state[0] ^ block[0];
    1089                         hash[1] ^= state[1] ^ block[1];
    1090                         hash[2] ^= state[2] ^ block[2];
    1091                         hash[3] ^= state[3] ^ block[3];
    1092                         hash[4] ^= state[4] ^ block[4];
    1093                         hash[5] ^= state[5] ^ block[5];
    1094                         hash[6] ^= state[6] ^ block[6];
    1095                         hash[7] ^= state[7] ^ block[7];
     1085      } // for (r = 1; r <= R; r++)
     1086
     1087      // apply the Miyaguchi-Preneel compression function:
     1088      hash[0] ^= state[0] ^ block[0];
     1089      hash[1] ^= state[1] ^ block[1];
     1090      hash[2] ^= state[2] ^ block[2];
     1091      hash[3] ^= state[3] ^ block[3];
     1092      hash[4] ^= state[4] ^ block[4];
     1093      hash[5] ^= state[5] ^ block[5];
     1094      hash[6] ^= state[6] ^ block[6];
     1095      hash[7] ^= state[7] ^ block[7];
    10961096
    10971097#if DEBUG2
     
    11051105                        Debug.WriteLine("");
    11061106#endif
    1107                 } // processBuffer
    1108         }
     1107    } // processBuffer
     1108  }
    11091109}
    11101110
  • trunk/DevTestMethods/TigerTest.cs

    r131 r138  
    1313using System;
    1414using System.Text;
     15
     16using System.Security.Cryptography;
     17
    1518using Microsoft.VisualStudio.TestTools.UnitTesting;
    1619
    17 namespace Tiger
     20namespace Tests
    1821{
    19         /// <summary>
    20         /// Zusammenfassungsbeschreibung für UnitTest1
    21         /// </summary>
    22         [TestClass]
    23         public class Tiger
    24         {
    25                 public Tiger()
    26                 {
    27                 }
     22  /// <summary>
     23  /// Testclass for Tiger hash
     24  /// </summary>
     25  [TestClass]
     26  public class TigerTest
     27  {
    2828
    29                 private TestContext testContextInstance;
     29    public TigerTest()
     30    {
     31      // nothing to do
     32    }
    3033
    31                 /// <summary>
    32                 ///Ruft den Textkontext mit Informationen über
    33                 ///den aktueen Testlauf sowie Funktionalität für diesen auf oder legt diese fest.
    34                 ///</summary>
    35                 public TestContext TestContext
    36                 {
    37                         get
    38                         {
    39                                 return testContextInstance;
    40                         }
    41                         set
    42                         {
    43                                 testContextInstance = value;
    44                         }
    45                 }
     34    private TestContext testContextInstance;
     35    public TestContext TestContext
     36    {
     37      get
     38      {
     39        return testContextInstance;
     40      }
     41      set
     42      {
     43        testContextInstance = value;
     44      }
     45    }
    4646
    47                 #region Zusätzliche Testattribute
    48                 //
    49                 // Sie können beim Schreiben der Tests folgende zusätzliche Attribute verwenden:
    50                 //
    51                 // Verwenden Sie ClassInitialize, um vor Ausführung des ersten Tests in der Klasse Code auszuführen.
    52                 // [ClassInitialize()]
    53                 // public static void MyClassInitialize(TestContext testContext) { }
    54                 //
    55                 // Verwenden Sie ClassCleanup, um nach Ausführung aer Tests in einer Klasse Code auszuführen.
    56                 // [ClassCleanup()]
    57                 // public static void MyClassCleanup() { }
    58                 //
    59                 // Mit TestInitialize können Sie vor jedem einzelnen Test Code ausführen.
    60                 // [TestInitialize()]
    61                 // public void MyTestInitialize() { }
    62                 //
    63                 // Mit TestCleanup können Sie nach jedem einzelnen Test Code ausführen.
    64                 // [TestCleanup()]
    65                 // public void MyTestCleanup() { }
    66                 //
    67                 #endregion
     47    [TestMethod]
     48    public void TigerTestMethod()
     49    {
    6850
    69                 [TestMethod]
    70                 public void TigerTestMethod()
    71                 {
    72                         // iso_test_vectors
     51      string TEST_DATA = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
     52      byte[] TEST_HASH = {
     53                      0xF, 0x7B, 0xF9, 0xA1, 0x9B, 0x9C, 0x58, 0xF2,
     54                      0xB7, 0x61, 0xD, 0xF7, 0xE8, 0x4F, 0xA, 0xC3,
     55                      0xA7, 0x1C, 0x63, 0x1E, 0x7B, 0x53, 0xF7, 0x8E};
    7356
    74                         string[] source =
    75                         {
    76                                 ""
    77                         };
     57     
     58      ASCIIEncoding enc = new ASCIIEncoding();
     59     
     60      TIGER tg = new TIGER();
    7861
    79                         // ToDo !!!!!!!!!!!!
    80                         string[] result =
    81                         {
    82                                 "19FA61D75522A4669B44E39C1D2E1726C530232130D407F89AFEE0964997F7A73E83BE698B288FEBCF88E3E03C4F0757EA8964E59B63D93708B138CC42A66EB3"
    83                         };
     62      tg.Initialize();
    8463
     64      byte[] hash = tg.ComputeHash(enc.GetBytes(TEST_DATA));
    8565
    86                         int tests = source.Length;
    87                         for (int t = 0; t < tests; t++)
    88                         {
    89                                 //TigerHash wh = new TigerHash();
     66      Assert.AreEqual(hash.Length, TEST_HASH.Length, "invalid hash length.");
    9067
    91                                 //testContextInstance.WriteLine(" Test " + t.ToString());
    92                                 //testContextInstance.WriteLine(" data = " + source[t]);
    93 
    94                                 //char[] src = source[t].ToCharArray();
    95                                 //int length = src.Length;
    96                                 //byte[] data = new byte[length];
    97 
    98                                 //for (uint i = 0; i < length; i++)
    99                                 //  data[i] = (byte)(src[i]);
    100 
    101                                 //wh.Add(data, (ulong)(length * 8));
    102                                 //wh.Finish();
    103 
    104                                 //byte[] res = wh.Hash;
    105 
    106                                 //Assert.AreEqual(res.Length, 64, "Hash Length invalid.");
    107 
    108                                 //string tmp = "";
    109                                 //foreach (byte b in res)
    110                                 //{
    111                                 //  if (b < 0x10)
    112                                 //    tmp += "0";
    113                                 //  tmp += b.ToString("X");
    114                                 //}
    115                                 //Assert.AreEqual(result[t], tmp, "Hash is invalid.");
    116 
    117                                 //testContextInstance.WriteLine(" expected   = " + result[t]);
    118                                 //testContextInstance.WriteLine(" calculated = " + tmp);
    119                         }
    120                 }
    121         }
     68      for (int i = 0; i < hash.Length; i++)
     69        Assert.AreEqual(hash[i], TEST_HASH[i], "Invalid hash value.");
     70    }
     71  }
    12272}
  • trunk/DevTestMethods/WhirlpoolTest.cs

    r97 r138  
    9696                        };
    9797
     98      ASCIIEncoding enc = new ASCIIEncoding();
    9899
    99100                        int tests = source.Length;
     
    105106                                testContextInstance.WriteLine(" data = " + source[t]);
    106107
    107                                 char[] src = source[t].ToCharArray();
    108                                 int length = src.Length;
    109                                 byte[] data = new byte[length];
     108        byte[] data = enc.GetBytes(source[t]);
    110109
    111                                 for (uint i = 0; i < length; i++)
    112                                         data[i] = (byte)(src[i]);
    113 
    114                                 wh.Add(data, (ulong)(length * 8));
     110                                wh.Add(data);
    115111                                wh.Finish();
    116112
  • trunk/DevTestMethods/pkcsTest.cs

    r133 r138  
    2020namespace Tests
    2121{
    22     /// <summary>
    23     /// test methods for PKCS#5 Plugin
    24     /// </summary>
    25     [TestClass]
    26     public class pkcsTest
     22  /// <summary>
     23  /// test methods for PKCS#5 Plugin
     24  /// </summary>
     25  [TestClass]
     26  public class pkcsTest
     27  {
     28    public pkcsTest()
    2729    {
    28         public pkcsTest()
    29         {
    30             // nothing to do
    31         }
     30      // nothing to do
     31    }
    3232
    33         private TestContext testContextInstance;
    34         public TestContext TestContext
    35         {
    36             get
    37             {
    38                 return testContextInstance;
    39             }
    40             set
    41             {
    42                 testContextInstance = value;
    43             }
    44         }
     33    private TestContext testContextInstance;
     34    public TestContext TestContext
     35    {
     36      get
     37      {
     38        return testContextInstance;
     39      }
     40      set
     41      {
     42        testContextInstance = value;
     43      }
     44    }
    4545
    46         private void pkcs5part(byte[] key, byte[] salt, int hmac, int count, byte[] result)
    47         {
    48             PKCS5Settings set = new PKCS5Settings();
    49             set.Count = count;
    50             set.SHAFunction = hmac;
    51             set.Length = result.Length * 8; // Length must be in bits and not in bytes
     46    private void pkcs5part(byte[] key, byte[] salt, int hmac, int count, byte[] result)
     47    {
     48      PKCS5Settings set = new PKCS5Settings();
     49      set.Count = count;
     50      set.SHAFunction = hmac;
     51      set.Length = result.Length * 8; // Length must be in bits and not in bytes
    5252
    53             PKCS5.PKCS5 p = new PKCS5.PKCS5();
    54             p.Settings = set;
    55             p.KeyData = key;
    56             p.SaltData = salt;
     53      PKCS5.PKCS5 p = new PKCS5.PKCS5();
     54      p.Settings = set;
     55      p.KeyData = key;
     56      p.SaltData = salt;
    5757
    58             string tmp = "key is  ";
    59             foreach (byte b in key)
    60                 tmp += b.ToString("x2") + " ";
    61             testContextInstance.WriteLine(tmp);
     58      string tmp = "key is  ";
     59      foreach (byte b in key)
     60        tmp += b.ToString("x2") + " ";
     61      testContextInstance.WriteLine(tmp);
    6262
    63             tmp = "salt is ";
    64             foreach (byte b in salt)
    65                 tmp += b.ToString("x2") + " ";
    66             testContextInstance.WriteLine(tmp);
     63      tmp = "salt is ";
     64      foreach (byte b in salt)
     65        tmp += b.ToString("x2") + " ";
     66      testContextInstance.WriteLine(tmp);
    6767
    68             p.Hash();
    69             byte[] h = p.HashOutputData;
    70             p.Dispose();
     68      p.Hash();
     69      byte[] h = p.HashOutputData;
     70      p.Dispose();
    7171
    72             // both arrays of same size?
    73             Assert.AreEqual(h.Length, result.Length, "Different hash sizes found");
     72      // both arrays of same size?
     73      Assert.AreEqual(h.Length, result.Length, "Different hash sizes found");
    7474
    75             tmp = "expected hash is  ";
    76             foreach (byte b in result)
    77                 tmp += b.ToString("x2") + " ";
    78             testContextInstance.WriteLine(tmp);
     75      tmp = "expected hash is  ";
     76      foreach (byte b in result)
     77        tmp += b.ToString("x2") + " ";
     78      testContextInstance.WriteLine(tmp);
    7979
    80             tmp = "calculated hash is ";
    81             foreach (byte b in h)
    82                 tmp += b.ToString("x2") + " ";
    83             testContextInstance.WriteLine(tmp);
     80      tmp = "calculated hash is ";
     81      foreach (byte b in h)
     82        tmp += b.ToString("x2") + " ";
     83      testContextInstance.WriteLine(tmp);
    8484
    85             // the next compares references etc ... but not the array content :-(
    86             // Assert.AreEqual<byte[]>(result, h, "Different hash values found");
    87             // compare by hand ...
    88             for (int i = 0; i < h.Length; i++)
    89             {
    90                 Assert.AreEqual(result[i], h[i], "Different hash values found");
    91             }
     85      // the next compares references etc ... but not the array content :-(
     86      // Assert.AreEqual<byte[]>(result, h, "Different hash values found");
     87      // compare by hand ...
     88      for (int i = 0; i < h.Length; i++)
     89      {
     90        Assert.AreEqual(result[i], h[i], "Different hash values found");
     91      }
    9292
    93             testContextInstance.WriteLine("----");
    94         }
     93      testContextInstance.WriteLine("----");
     94    }
    9595
    96         [TestMethod]
    97         public void pkcs5TestMethodMD5()
    98         {
    99             byte[] key = { 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64 };   // "password"
    100             byte[] salt = { 0x78, 0x57, 0x8E, 0x5A, 0x5D, 0x63, 0xCB, 0x06 };
     96    [TestMethod]
     97    public void pkcs5TestMethodMD5()
     98    {
     99      byte[] key = { 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64 };   // "password"
     100      byte[] salt = { 0x78, 0x57, 0x8E, 0x5A, 0x5D, 0x63, 0xCB, 0x06 };
    101101
    102             ///
    103             /// referenced test values taken from
    104             /// http://cryptosys.net/cgi-bin/manual.cgi?m=api&name=PBE_Kdf2
    105             ///
    106             //Derived key {HMAC-MD5}    = 66991b7f8010a0ba5d8a2e1e1a38341007f2eda8a79619d6 // reference needed
    107             //Derived key {HMAC-SHA1}   = BFDE6BE94DF7E11DD409BCE20A0255EC327CB936FFE93643
    108             //Derived key {HMAC-SHA256} = 97B5A91D35AF542324881315C4F849E327C4707D1BC9D322
    109             //Derived key {HMAC-SHA384} = bd6078731cef2cf5bdc48748a9da182ddc7b48a3cc28069e // reference needed
    110             //Derived key {HMAC-SHA512} = e6fa68fec0a2be2477809f8983e2719eb29415c61efacf34 // reference needed
     102      ///
     103      /// referenced test values taken from
     104      /// http://cryptosys.net/cgi-bin/manual.cgi?m=api&name=PBE_Kdf2
     105      ///
     106      //Derived key {HMAC-MD5}    = 66991b7f8010a0ba5d8a2e1e1a38341007f2eda8a79619d6 // reference needed
     107      //Derived key {HMAC-SHA1}   = BFDE6BE94DF7E11DD409BCE20A0255EC327CB936FFE93643
     108      //Derived key {HMAC-SHA256} = 97B5A91D35AF542324881315C4F849E327C4707D1BC9D322
     109      //Derived key {HMAC-SHA384} = bd6078731cef2cf5bdc48748a9da182ddc7b48a3cc28069e // reference needed
     110      //Derived key {HMAC-SHA512} = e6fa68fec0a2be2477809f8983e2719eb29415c61efacf34 // reference needed
    111111
    112             byte[] result_MD5    = { 0x66, 0x99, 0x1b, 0x7f, 0x80, 0x10, 0xa0, 0xba, 0x5d, 0x8a, 0x2e, 0x1e, 0x1a, 0x38, 0x34, 0x10, 0x07, 0xf2, 0xed, 0xa8, 0xa7, 0x96, 0x19, 0xd6 };
    113             byte[] result_SHA1   = { 0xBF, 0xDE, 0x6B, 0xE9, 0x4D, 0xF7, 0xE1, 0x1D, 0xD4, 0x09, 0xBC, 0xE2, 0x0A, 0x02, 0x55, 0xEC, 0x32, 0x7C, 0xB9, 0x36, 0xFF, 0xE9, 0x36, 0x43 };
    114             byte[] result_SHA256 = { 0x97, 0xB5, 0xA9, 0x1D, 0x35, 0xAF, 0x54, 0x23, 0x24, 0x88, 0x13, 0x15, 0xC4, 0xF8, 0x49, 0xE3, 0x27, 0xC4, 0x70, 0x7D, 0x1B, 0xC9, 0xD3, 0x22 };
    115             byte[] result_SHA384 = { 0xbd, 0x60, 0x78, 0x73, 0x1c, 0xef, 0x2c, 0xf5, 0xbd, 0xc4, 0x87, 0x48, 0xa9, 0xda, 0x18, 0x2d, 0xdc, 0x7b, 0x48, 0xa3, 0xcc, 0x28, 0x06, 0x9e };
    116             byte[] result_SHA512 = { 0xe6, 0xfa, 0x68, 0xfe, 0xc0, 0xa2, 0xbe, 0x24, 0x77, 0x80, 0x9f, 0x89, 0x83, 0xe2, 0x71, 0x9e, 0xb2, 0x94, 0x15, 0xc6, 0x1e, 0xfa, 0xcf, 0x34 };
     112      byte[] result_MD5    = { 0x66, 0x99, 0x1b, 0x7f, 0x80, 0x10, 0xa0, 0xba, 0x5d, 0x8a, 0x2e, 0x1e,
     113                               0x1a, 0x38, 0x34, 0x10, 0x07, 0xf2, 0xed, 0xa8, 0xa7, 0x96, 0x19, 0xd6 };
     114      byte[] result_SHA1   = { 0xBF, 0xDE, 0x6B, 0xE9, 0x4D, 0xF7, 0xE1, 0x1D, 0xD4, 0x09, 0xBC, 0xE2,
     115                               0x0A, 0x02, 0x55, 0xEC, 0x32, 0x7C, 0xB9, 0x36, 0xFF, 0xE9, 0x36, 0x43 };
     116      byte[] result_SHA256 = { 0x97, 0xB5, 0xA9, 0x1D, 0x35, 0xAF, 0x54, 0x23, 0x24, 0x88, 0x13, 0x15,
     117                               0xC4, 0xF8, 0x49, 0xE3, 0x27, 0xC4, 0x70, 0x7D, 0x1B, 0xC9, 0xD3, 0x22 };
     118      byte[] result_SHA384 = { 0xbd, 0x60, 0x78, 0x73, 0x1c, 0xef, 0x2c, 0xf5, 0xbd, 0xc4, 0x87, 0x48,
     119                               0xa9, 0xda, 0x18, 0x2d, 0xdc, 0x7b, 0x48, 0xa3, 0xcc, 0x28, 0x06, 0x9e };
     120      byte[] result_SHA512 = { 0xe6, 0xfa, 0x68, 0xfe, 0xc0, 0xa2, 0xbe, 0x24, 0x77, 0x80, 0x9f, 0x89,
     121                               0x83, 0xe2, 0x71, 0x9e, 0xb2, 0x94, 0x15, 0xc6, 0x1e, 0xfa, 0xcf, 0x34 };
    117122
    118             pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.MD5,    2048, result_MD5);
    119             pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1,  2048, result_SHA1);
    120             pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA256, 2048, result_SHA256);
    121             pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA384, 2048, result_SHA384);
    122             pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA512, 2048, result_SHA512);
     123      pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.MD5, 2048, result_MD5);
     124      pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 2048, result_SHA1);
     125      pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA256, 2048, result_SHA256);
     126      pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA384, 2048, result_SHA384);
     127      pkcs5part(key, salt, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA512, 2048, result_SHA512);
    123128
    124             // http://www.ietf.org/rfc/rfc3962.txt
    125             // Appendix B.  Sample Test Vectors, page 9
     129      // http://www.ietf.org/rfc/rfc3962.txt
     130      // Appendix B.  Sample Test Vectors, page 9
    126131
    127             byte[] salt2 = { 0x41, 0x54, 0x48, 0x45, 0x4e, 0x41, 0x2e, 0x4d, 0x49, 0x54, 0x2e, 0x45, 0x44, 0x55, 0x72, 0x61, 0x65, 0x62, 0x75, 0x72, 0x6e }; // "ATHENA.MIT.EDUraeburn"
     132      byte[] salt2 = { 0x41, 0x54, 0x48, 0x45, 0x4e, 0x41, 0x2e, 0x4d, 0x49, 0x54, 0x2e,
     133                       0x45, 0x44, 0x55, 0x72, 0x61, 0x65, 0x62, 0x75, 0x72, 0x6e }; // "ATHENA.MIT.EDUraeburn"
    128134
    129             byte[] result1a = { 0xcd, 0xed, 0xb5, 0x28, 0x1b, 0xb2, 0xf8, 0x01, 0x56, 0x5a, 0x11, 0x22, 0xb2, 0x56, 0x35, 0x15 };
    130             byte[] result1b = { 0xcd, 0xed, 0xb5, 0x28, 0x1b, 0xb2, 0xf8, 0x01, 0x56, 0x5a, 0x11, 0x22, 0xb2, 0x56, 0x35, 0x15, 0x0a, 0xd1, 0xf7, 0xa0, 0x4b, 0xb9, 0xf3, 0xa3, 0x33, 0xec, 0xc0, 0xe2, 0xe1, 0xf7, 0x08, 0x37 };
     135      byte[] result1a = { 0xcd, 0xed, 0xb5, 0x28, 0x1b, 0xb2, 0xf8, 0x01,
     136                          0x56, 0x5a, 0x11, 0x22, 0xb2, 0x56, 0x35, 0x15 };
    131137
    132             pkcs5part(key, salt2, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 1, result1a);
    133             pkcs5part(key, salt2, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 1, result1b);
     138      byte[] result1b = { 0xcd, 0xed, 0xb5, 0x28, 0x1b, 0xb2, 0xf8, 0x01, 0x56, 0x5a, 0x11,
     139                          0x22, 0xb2, 0x56, 0x35, 0x15, 0x0a, 0xd1, 0xf7, 0xa0, 0x4b, 0xb9,
     140                          0xf3, 0xa3, 0x33, 0xec, 0xc0, 0xe2, 0xe1, 0xf7, 0x08, 0x37 };
    134141
    135             byte[] result2a = { 0x01, 0xdb, 0xee, 0x7f, 0x4a, 0x9e, 0x24, 0x3e, 0x98, 0x8b, 0x62, 0xc7, 0x3c, 0xda, 0x93, 0x5d };
    136             byte[] result2b = { 0x01, 0xdb, 0xee, 0x7f, 0x4a, 0x9e, 0x24, 0x3e, 0x98, 0x8b, 0x62, 0xc7, 0x3c, 0xda, 0x93, 0x5d, 0xa0, 0x53, 0x78, 0xb9, 0x32, 0x44, 0xec, 0x8f, 0x48, 0xa9, 0x9e, 0x61, 0xad, 0x79, 0x9d, 0x86 };
     142      pkcs5part(key, salt2, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 1, result1a);
     143      pkcs5part(key, salt2, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 1, result1b);
    137144
    138             pkcs5part(key, salt2, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 2, result2a);
    139             pkcs5part(key, salt2, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 2, result2b);
     145      byte[] result2a = { 0x01, 0xdb, 0xee, 0x7f, 0x4a, 0x9e, 0x24, 0x3e,
     146                          0x98, 0x8b, 0x62, 0xc7, 0x3c, 0xda, 0x93, 0x5d };
     147      byte[] result2b = { 0x01, 0xdb, 0xee, 0x7f, 0x4a, 0x9e, 0x24, 0x3e, 0x98, 0x8b, 0x62,
     148                          0xc7, 0x3c, 0xda, 0x93, 0x5d, 0xa0, 0x53, 0x78, 0xb9, 0x32, 0x44,
     149                          0xec, 0x8f, 0x48, 0xa9, 0x9e, 0x61, 0xad, 0x79, 0x9d, 0x86 };
    140150
    141         }
     151      pkcs5part(key, salt2, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 2, result2a);
     152      pkcs5part(key, salt2, (int)System.Security.Cryptography.PKCS5MaskGenerationMethod.ShaFunction.SHA1, 2, result2b);
     153
    142154    }
     155  }
    143156}
  • trunk/SSCext/SSCTiger.cs

    r134 r138  
    2323namespace System.Security.Cryptography
    2424{
    25         public class Tiger : HashAlgorithm
     25        public class TIGER : HashAlgorithm
    2626        {
    2727
     
    4343
    4444                /// <summary>
    45                 /// Initializes A new instance of the <see cref="Tiger"/> class.
     45                /// Initializes A new instance of the <see cref="TIGER"/> class.
    4646                /// </summary>
    47                 public Tiger() : base()
     47                public TIGER() : base()
    4848                {
    4949                        buffer = new byte[BLOCKSIZE];
     
    585585}
    586586
    587 
    588 
    589 //        Public Shared Function SelfTest() As Boolean
    590 
    591 //            ' (NESSIE test vector)
    592 //            Dim TEST_DATA As String = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
    593 //            Dim TEST_HASH() As Byte = { _
    594 //                0xF, 0x7B, 0xF9, 0xA1, 0x9B, 0x9C, 0x58, 0xF2,
    595 //                0xB7, 0x61, 0xD, 0xF7, 0xE8, 0x4F, 0xA, 0xC3,
    596 //                0xA7, 0x1C, 0x63, 0x1E, 0x7B, 0x53, 0xF7, 0x8E}
    597 
    598 //            Dim i As Integer
    599 //            Dim tg As Tiger
    600 //            Dim hash() As Byte
    601 //            Dim enc As ASCIIEncoding
    602 
    603 //            tg = New Tiger
    604 //            tg.Initialize()
    605 
    606 //            enc = New ASCIIEncoding
    607 //            hash = tg.ComputeHash(enc.GetBytes(TEST_DATA))
    608 
    609 //            If hash.Length <> TEST_HASH.Length Then
    610 //                Return False
    611 //            End If
    612 
    613 //            For i = 0 To TEST_HASH.Length - 1
    614 //                If hash(i) <> TEST_HASH(i) Then
    615 //                    Return False
    616 //                End If
    617 //            Next
    618 
    619 //            Return True
    620 //        End Function
    621 
  • trunk/SSCext/SSCext.csproj

    r134 r138  
    5151    <Compile Include="SSCwhirl.cs" />
    5252  </ItemGroup>
     53  <ItemGroup>
     54    <Content Include="license.txt" />
     55  </ItemGroup>
    5356  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    5457  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Note: See TracChangeset for help on using the changeset viewer.