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/CrypPlugins/Whirlpool
Files:
4 edited
1 copied

Legend:

Unmodified
Added
Removed
  • 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
Note: See TracChangeset for help on using the changeset viewer.