Changeset 198


Ignore:
Timestamp:
Jan 16, 2009, 11:18:00 AM (13 years ago)
Author:
Gerhard Junker
Message:

Implementing Tiger and Whirlpool as HMAC (was HashAlgorithm)
Added Tiger and Whirlpool to PKCS#5

Location:
trunk
Files:
7 edited

Legend:

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

    r155 r198  
    3535
    3636    /// <summary>
    37     /// can only handle one input canal
    38     /// </summary>
    39     private enum dataCanal
    40     {
    41       /// <summary>
    42       /// nothing assigned
    43       /// </summary>
    44       none,
    45       /// <summary>
    46       /// using stream interface
    47       /// </summary>
    48       streamCanal,
    49       /// <summary>
    50       /// using byte array interface
    51       /// </summary>
    52       byteCanal
    53     };
    54 
    55 
    56     /// <summary>
    5737    /// Initializes a new instance of the <see cref="PKCS5"/> class.
    5838    /// </summary>
     
    11191    // Input key
    11292    private byte[] key = { };
    113     private dataCanal keyCanal = dataCanal.none;
    11493
    11594    /// <summary>
     
    140119          return;
    141120
    142         if (keyCanal != dataCanal.none && keyCanal != dataCanal.streamCanal)
    143           GuiLogMessage("Duplicate input key not allowed!", NotificationLevel.Warning);
    144         keyCanal = dataCanal.streamCanal;
    145 
    146121        long len = value.Length;
    147122        key = new byte[len];
     
    168143      set
    169144      {
    170         if (keyCanal != dataCanal.none && keyCanal != dataCanal.byteCanal)
    171           GuiLogMessage("Duplicate key data not allowed!", NotificationLevel.Warning);
    172         keyCanal = dataCanal.byteCanal;
    173 
    174145        long len = value.Length;
    175146        key = new byte[len];
     
    188159    // Salt Data
    189160    private byte[] salt = { };
    190     private dataCanal saltCanal = dataCanal.none;
    191161
    192162    /// <summary>
     
    216186        if (null == value)
    217187          return;
    218 
    219         if (saltCanal != dataCanal.none && saltCanal != dataCanal.streamCanal)
    220           GuiLogMessage("Duplicate salt input not allowed!", NotificationLevel.Warning);
    221         saltCanal = dataCanal.streamCanal;
    222 
    223188        long len = value.Length;
    224189        salt = new byte[len];
     
    246211      set
    247212      {
    248         if (saltCanal != dataCanal.none && saltCanal != dataCanal.byteCanal)
    249           GuiLogMessage("Duplicate salt input not allowed!", NotificationLevel.Warning);
    250         saltCanal = dataCanal.byteCanal;
    251 
    252213        long len = value.Length;
    253214        salt = new byte[len];
     
    316277        return this.outputData;
    317278      }
    318       //set
    319       //{
    320       //    if (outputData != value)
    321       //    {
    322       //        this.outputData = value;
    323       //    }
    324       //    NotifyUpdateOutput();
    325       //}
    326279    }
    327280
  • trunk/CrypPlugins/PKCS5/PKCS5Settings.cs

    r138 r198  
    4444                                        = PKCS5MaskGenerationMethod.ShaFunction.SHA256;
    4545
    46     [ContextMenu("SHA Function",
    47       "Select the hash function (MD5, SHA1 or one out of the SHA2 family)", 0,
     46    [ContextMenu("Hash Function",
     47      "Select the hash function (MD5, one out of the SHA family, TIGER or WHIRLPOOL)", 0,
    4848      DisplayLevel.Beginner, ContextMenuControlType.ComboBox, null,
    49       new string[] { "MD5", "SHA1", "SHA256", "SHA384", "SHA512" })]
     49      new string[] { "MD5", "SHA1", "SHA256", "SHA384", "SHA512", "TIGER", "WHIRLPOOL" })]
    5050    [TaskPane("Select hash function",
    51       "Select the hash function (MD2, SHA1 or one out of the SHA2 family)", "", 0, true,
     51      "Select the hash function (MD5, one out of the SHA family, TIGER or WHIRLPOOL)", "", 0, true,
    5252      DisplayLevel.Beginner, ControlType.ComboBox,
    53       new string[] { "MD5", "SHA1", "SHA256", "SHA384", "SHA512" })]
     53      new string[] { "MD5", "SHA1", "SHA256", "SHA384", "SHA512", "TIGER", "WHIRLPOOL" })]
    5454    public int SHAFunction
    5555    {
     
    6161      {
    6262        this.selectedShaFunction = (PKCS5MaskGenerationMethod.ShaFunction)value;
    63         //CheckLength();
    6463        // set to max hash length
    6564        length = PKCS5MaskGenerationMethod.GetHashLength(selectedShaFunction) * 8;
     
    115114        while ((length & 0x07) != 0) // go to the next multiple of 8
    116115          length++;
    117 
    118         //CheckLength();
    119116
    120117        hasChanges = true;
  • trunk/CrypPlugins/Tiger/Tiger.cs

    r159 r198  
    3838{
    3939
    40         [Author("Gerhard Junker", null, "private project member", null)]
    41   [PluginInfo(false, "Tiger", "Tiger2 V1.0.2 Hash", 
     40  [Author("Gerhard Junker", null, "private project member", null)]
     41  [PluginInfo(false, "Tiger", "Tiger2 V1.0.2 Hash",
    4242    "http://en.wikipedia.org/wiki/Tiger_(cryptography)", "Tiger/Tiger1.png")]
    43         public class Tiger : IHash
    44         {
    45 
    46                 /// <summary>
    47                 /// can only handle one input canal
    48                 /// </summary>
    49                 private enum dataCanal
    50                 {
    51                         /// <summary>
    52                         /// nothing assigned
    53                         /// </summary>
    54                         none,
    55                         /// <summary>
    56                         /// using stream interface
    57                         /// </summary>
    58                         streamCanal,
    59                         /// <summary>
    60                         /// using byte array interface
    61                         /// </summary>
    62                         byteCanal
    63                 };
    64 
    65 
    66                 /// <summary>
    67                 /// Initializes A new instance of the <see cref="Tiger"/> class.
    68                 /// </summary>
    69                 public Tiger()
    70                 {
    71                         this.settings = new TigerSettings();
    72                 }
    73 
    74                 #region Settings
    75                 TigerSettings settings;
    76 
    77                 /// <summary>
    78                 /// Gets or sets the settings.
    79                 /// </summary>
    80                 /// <value>The settings.</value>
     43  public class Tiger : IHash
     44  {
     45
     46    /// <summary>
     47    /// can only handle one input canal
     48    /// </summary>
     49    private enum dataCanal
     50    {
     51      /// <summary>
     52      /// nothing assigned
     53      /// </summary>
     54      none,
     55      /// <summary>
     56      /// using stream interface
     57      /// </summary>
     58      streamCanal,
     59      /// <summary>
     60      /// using byte array interface
     61      /// </summary>
     62      byteCanal
     63    };
     64
     65
     66    /// <summary>
     67    /// Initializes A new instance of the <see cref="Tiger"/> class.
     68    /// </summary>
     69    public Tiger()
     70    {
     71      this.settings = new TigerSettings();
     72    }
     73
     74    #region Settings
     75    TigerSettings settings;
     76
     77    /// <summary>
     78    /// Gets or sets the settings.
     79    /// </summary>
     80    /// <value>The settings.</value>
    8181    public ISettings Settings
    8282    {
     
    9393    }
    9494
    95                 /// <summary>
    96                 /// Gets or sets A value indicating whether this instance has changes.
    97                 /// </summary>
    98                 /// <value>
    99                 ///     <c>true</c> if this instance has changes; otherwise, <c>false</c>.
    100                 /// </value>
    101                 public bool HasChanges
    102                 {
    103                         get
    104                         {
    105                                 return settings.HasChanges;
    106                         }
    107 
    108                         set
    109                         {
    110                                 settings.HasChanges = value;
    111                                 GuiLogMessage("HasChanges changed.", NotificationLevel.Debug);
    112                         }
    113                 }
    114 
    115                 #endregion
    116 
    117                 #region Input inputdata / password
    118 
    119                 // Input inputdata
    120                 private byte[] inputdata = { };
    121                 //private dataCanal inputCanal = dataCanal.none;
    122 
    123                 /// <summary>
    124                 /// Notifies the update input.
    125                 /// </summary>
    126                 private void NotifyUpdateInput()
    127                 {
    128                         OnPropertyChanged("InputStream");
    129                         OnPropertyChanged("InputData");
    130                 }
    131 
    132                 /// <summary>
    133                 /// Gets or sets the input inputdata.
    134                 /// </summary>
    135                 /// <value>The input inputdata.</value>
    136                 [PropertyInfo(Direction.Input, "Input Data Stream", "Input data stream to be hashed", "",
     95    /// <summary>
     96    /// Gets or sets A value indicating whether this instance has changes.
     97    /// </summary>
     98    /// <value>
     99    ///         <c>true</c> if this instance has changes; otherwise, <c>false</c>.
     100    /// </value>
     101    public bool HasChanges
     102    {
     103      get
     104      {
     105        return settings.HasChanges;
     106      }
     107
     108      set
     109      {
     110        settings.HasChanges = value;
     111        GuiLogMessage("HasChanges changed.", NotificationLevel.Debug);
     112      }
     113    }
     114
     115    #endregion
     116
     117    #region Input inputdata / password
     118
     119    // Input inputdata
     120    private byte[] inputdata = { };
     121    //private dataCanal inputCanal = dataCanal.none;
     122
     123    /// <summary>
     124    /// Notifies the update input.
     125    /// </summary>
     126    private void NotifyUpdateInput()
     127    {
     128      OnPropertyChanged("InputStream");
     129      OnPropertyChanged("InputData");
     130    }
     131
     132    /// <summary>
     133    /// Gets or sets the input inputdata.
     134    /// </summary>
     135    /// <value>The input inputdata.</value>
     136    [PropertyInfo(Direction.Input, "Input Data Stream", "Input data stream to be hashed", "",
    137137      false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    138                 public CryptoolStream InputStream
    139                 {
    140                         get
    141                         {
    142                                 CryptoolStream inputStream = new CryptoolStream();
    143                                 inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, inputdata);
    144                                 return inputStream;
    145                         }
    146                         set
    147                         {
     138    public CryptoolStream InputStream
     139    {
     140      get
     141      {
     142        CryptoolStream inputStream = new CryptoolStream();
     143        inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, inputdata);
     144        return inputStream;
     145      }
     146      set
     147      {
    148148        if (null == value)
    149149        {
     
    155155        //inputCanal = dataCanal.streamCanal;
    156156
    157                                 long len = value.Length;
    158                                 inputdata = new byte[len];
    159 
    160                                 for (long i = 0; i < len; i++)
    161                                         inputdata[i] = (byte)value.ReadByte();
    162 
    163                                 NotifyUpdateInput();
    164                                 GuiLogMessage("InputStream changed.", NotificationLevel.Debug);
    165                         }
    166                 }
    167 
    168                 /// <summary>
    169                 /// Gets the input data.
    170                 /// </summary>
    171                 /// <value>The input data.</value>
    172                 [PropertyInfo(Direction.Input, "Input Data", "Input Data to be hashed", "",
     157        long len = value.Length;
     158        inputdata = new byte[len];
     159
     160        for (long i = 0; i < len; i++)
     161          inputdata[i] = (byte)value.ReadByte();
     162
     163        NotifyUpdateInput();
     164        GuiLogMessage("InputStream changed.", NotificationLevel.Debug);
     165      }
     166    }
     167
     168    /// <summary>
     169    /// Gets the input data.
     170    /// </summary>
     171    /// <value>The input data.</value>
     172    [PropertyInfo(Direction.Input, "Input Data", "Input Data to be hashed", "",
    173173      false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    174                 public byte[] InputData
    175                 {
    176                         get
    177                         {
    178                                 return inputdata;
    179                         }
    180                         set
    181                         {
     174    public byte[] InputData
     175    {
     176      get
     177      {
     178        return inputdata;
     179      }
     180      set
     181      {
    182182        //if (inputCanal != dataCanal.none && inputCanal != dataCanal.byteCanal)
    183183        //  GuiLogMessage("Duplicate Data data not allowed!", NotificationLevel.Error);
     
    188188          return;
    189189        }
    190                                 long len = value.Length;
    191                                 inputdata = new byte[len];
    192 
    193                                 for (long i = 0; i < len; i++)
    194                                         inputdata[i] = value[i];
    195 
    196                                 NotifyUpdateInput();
    197                                 GuiLogMessage("InputData changed.", NotificationLevel.Debug);
    198                         }
    199                 }
    200                 #endregion
    201 
    202                 #region Output
    203 
    204                 // Output
    205                 private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    206                 private byte[] outputData = { };
    207 
    208                 /// <summary>
    209                 /// Notifies the update output.
    210                 /// </summary>
    211                 private void NotifyUpdateOutput()
    212                 {
    213                         OnPropertyChanged("HashOutputStream");
    214                         OnPropertyChanged("HashOutputData");
    215                 }
    216 
    217 
    218                 /// <summary>
    219                 /// Gets or sets the output inputdata stream.
    220                 /// </summary>
    221                 /// <value>The output inputdata stream.</value>
    222                 [PropertyInfo(Direction.Output, "Hashed Stream", "Output stream of the hashed value", "",
    223                         true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    224                 public CryptoolStream HashOutputStream
    225                 {
    226                         get
    227                         {
    228                                 CryptoolStream outputDataStream = null;
    229                                 if (outputData != null)
    230                                 {
    231                                         outputDataStream = new CryptoolStream();
    232                                         outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
    233                                         listCryptoolStreamsOut.Add(outputDataStream);
    234                                 }
    235                                 GuiLogMessage("Got HashOutputStream.", NotificationLevel.Debug);
    236                                 return outputDataStream;
    237                         }
    238                         //set
    239                         //{
    240                         //} //readonly
    241                 }
    242 
    243                 /// <summary>
    244                 /// Gets the output inputdata.
    245                 /// </summary>
    246                 /// <value>The output inputdata.</value>
    247                 [PropertyInfo(Direction.Output, "Hashed Data", "Output data of the hashed value", "",
    248                         true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    249                 public byte[] HashOutputData
    250                 {
    251                         get
    252                         {
    253                                 GuiLogMessage("Got HashOutputData.", NotificationLevel.Debug);
    254                                 return this.outputData;
    255                         }
    256                 }
    257 
    258                 #endregion
     190        long len = value.Length;
     191        inputdata = new byte[len];
     192
     193        for (long i = 0; i < len; i++)
     194          inputdata[i] = value[i];
     195
     196        NotifyUpdateInput();
     197        GuiLogMessage("InputData changed.", NotificationLevel.Debug);
     198      }
     199    }
     200    #endregion
     201
     202    #region Output
     203
     204    // Output
     205    private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     206    private byte[] outputData = { };
     207
     208    /// <summary>
     209    /// Notifies the update output.
     210    /// </summary>
     211    private void NotifyUpdateOutput()
     212    {
     213      OnPropertyChanged("HashOutputStream");
     214      OnPropertyChanged("HashOutputData");
     215    }
     216
     217
     218    /// <summary>
     219    /// Gets or sets the output inputdata stream.
     220    /// </summary>
     221    /// <value>The output inputdata stream.</value>
     222    [PropertyInfo(Direction.Output, "Hashed Stream", "Output stream of the hashed value", "",
     223      true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     224    public CryptoolStream HashOutputStream
     225    {
     226      get
     227      {
     228        CryptoolStream outputDataStream = null;
     229        if (outputData != null)
     230        {
     231          outputDataStream = new CryptoolStream();
     232          outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
     233          listCryptoolStreamsOut.Add(outputDataStream);
     234        }
     235        GuiLogMessage("Got HashOutputStream.", NotificationLevel.Debug);
     236        return outputDataStream;
     237      }
     238      //set
     239      //{
     240      //} //readonly
     241    }
     242
     243    /// <summary>
     244    /// Gets the output inputdata.
     245    /// </summary>
     246    /// <value>The output inputdata.</value>
     247    [PropertyInfo(Direction.Output, "Hashed Data", "Output data of the hashed value", "",
     248      true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     249    public byte[] HashOutputData
     250    {
     251      get
     252      {
     253        GuiLogMessage("Got HashOutputData.", NotificationLevel.Debug);
     254        return this.outputData;
     255      }
     256    }
     257
     258    #endregion
    259259
    260260    void Hash()
     
    265265    }
    266266
    267                 #region IPlugin Member
     267    #region IPlugin Member
    268268
    269269
    270270#pragma warning disable 67
    271                 public event StatusChangedEventHandler OnPluginStatusChanged;
    272                 public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    273                 public event PluginProgressChangedEventHandler OnPluginProgressChanged;
     271    public event StatusChangedEventHandler OnPluginStatusChanged;
     272    public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
     273    public event PluginProgressChangedEventHandler OnPluginProgressChanged;
    274274#pragma warning restore
    275275
     
    280280    /// </summary>
    281281    /// <value>The presentation.</value>
    282                 public System.Windows.Controls.UserControl Presentation
    283                 {
    284                         get
    285                         {
     282    public System.Windows.Controls.UserControl Presentation
     283    {
     284      get
     285      {
    286286        return null;
    287                         }
    288                 }
     287      }
     288    }
    289289
    290290    /// <summary>
     
    292292    /// </summary>
    293293    /// <value>The quick watch presentation.</value>
    294                 public System.Windows.Controls.UserControl QuickWatchPresentation
    295                 {
    296                         get
    297                         {
     294    public System.Windows.Controls.UserControl QuickWatchPresentation
     295    {
     296      get
     297      {
    298298        return null;
    299                         }
    300                 }
     299      }
     300    }
    301301
    302302    /// <summary>
    303303    /// Will be called from editor before right before chain-run starts
    304304    /// </summary>
    305                 public void PreExecution()
    306                 {
    307                 }
     305    public void PreExecution()
     306    {
     307    }
    308308
    309309    /// <summary>
     
    311311    /// for plugin has been set.
    312312    /// </summary>
    313                 public void Execute()
    314                 {
     313    public void Execute()
     314    {
    315315      Hash();
    316                 }
     316    }
    317317
    318318    /// <summary>
    319319    /// Will be called from editor after last plugin in chain has finished its work.
    320320    /// </summary>
    321                 public void PostExecution()
    322                 {
    323                 }
    324 
    325 
    326                 public void Pause()
    327                 {
    328                 }
     321    public void PostExecution()
     322    {
     323    }
     324
     325
     326    public void Pause()
     327    {
     328    }
    329329
    330330    /// <summary>
    331331    /// Will be called from editor while chain-run is active. Plugin hast to stop work immediately.
    332332    /// </summary>
    333                 public void Stop()
    334                 {
    335                 }
     333    public void Stop()
     334    {
     335    }
    336336
    337337    /// <summary>
    338338    /// Will be called from editor after restoring settings and before adding to workspace.
    339339    /// </summary>
    340                 public void Initialize()
    341                 {
    342                 }
     340    public void Initialize()
     341    {
     342    }
    343343
    344344    /// <summary>
     
    346346    /// Releases unmanaged and - optionally - managed resources
    347347    /// </summary>
    348                 public void Dispose()
    349                 {
     348    public void Dispose()
     349    {
    350350      foreach (CryptoolStream stream in listCryptoolStreamsOut)
    351351      {
     
    353353      }
    354354      listCryptoolStreamsOut.Clear();
    355                 }
    356 
    357                 #endregion
    358 
    359                 #region INotifyPropertyChanged Member
    360 
    361                 public event PropertyChangedEventHandler  PropertyChanged;
    362 
    363                 /// <summary>
    364                 /// Called when [property changed].
    365                 /// </summary>
    366                 /// <param name="name">The name.</param>
    367                 protected void OnPropertyChanged(string name)
    368                 {
    369                         if (PropertyChanged != null)
    370                         {
     355    }
     356
     357    #endregion
     358
     359    #region INotifyPropertyChanged Member
     360
     361    public event PropertyChangedEventHandler  PropertyChanged;
     362
     363    /// <summary>
     364    /// Called when [property changed].
     365    /// </summary>
     366    /// <param name="name">The name.</param>
     367    protected void OnPropertyChanged(string name)
     368    {
     369      if (PropertyChanged != null)
     370      {
    371371        if (name == "Settings")
    372372        {
     
    375375        else
    376376          PropertyChanged(this, new PropertyChangedEventArgs(name));
    377                         }
    378                 }
    379 
    380 
    381                 /// <summary>
    382                 /// GUIs the log message.
    383                 /// </summary>
    384                 /// <param name="message">The message.</param>
    385                 /// <param name="logLevel">The log level.</param>
    386                 private void GuiLogMessage(string message, NotificationLevel logLevel)
    387                 {
    388                         EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this,
    389                                 new GuiLogEventArgs(message, this, logLevel));
    390                 }
    391 
    392                 #endregion
    393         }
     377      }
     378    }
     379
     380
     381    /// <summary>
     382    /// GUIs the log message.
     383    /// </summary>
     384    /// <param name="message">The message.</param>
     385    /// <param name="logLevel">The log level.</param>
     386    private void GuiLogMessage(string message, NotificationLevel logLevel)
     387    {
     388      EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this,
     389        new GuiLogEventArgs(message, this, logLevel));
     390    }
     391
     392    #endregion
     393  }
    394394}
  • trunk/SSCext/SSCTiger.cs

    r141 r198  
    2525namespace System.Security.Cryptography
    2626{
    27   public class HMACTIGER : HashAlgorithm
     27  public class HMACTIGER : HMAC
    2828  {
    2929
     
    6464      bufPos = 0;
    6565      length = 0;
    66     }
    67 
    68 
     66
     67      HashName = "Tiger1";
     68
     69      //Key
     70      if ((KeyValue != null) && (KeyValue.Length > 0))
     71        HashCore(KeyValue, 0, KeyValue.Length);
     72    }
     73
     74    /// <summary>
     75    /// Gets or sets the key to use in the hash algorithm.
     76    /// </summary>
     77    /// <value></value>
     78    /// <returns>
     79    /// The key to use in the hash algorithm.
     80    /// </returns>
     81    /// <exception cref="T:System.Security.Cryptography.CryptographicException">
     82    /// An attempt is made to change the <see cref="P:System.Security.Cryptography.HMAC.Key"/> property
     83    /// after hashing has begun.
     84    /// </exception>
     85    public override byte[] Key
     86    {
     87      get
     88      {
     89        return base.Key;
     90      }
     91      set
     92      {
     93        base.Key = value;
     94        Initialize();
     95      }
     96    }
     97
     98   
    6999    /// <summary>
    70100    /// When overridden in A derived class, gets A value indicating whether multiple blocks can be transformed.
  • trunk/SSCext/SSCpkcs5.cs

    r134 r198  
    2323namespace System.Security.Cryptography
    2424{
    25     /// <summary>
    26     /// insert PKSC #5 v2 into default namespace
    27     /// </summary>
     25  /// <summary>
     26  /// insert PKSC #5 v2 into default namespace
     27  /// </summary>
     28  [ComVisibleAttribute(true)]
     29  public class PKCS5MaskGenerationMethod : System.Security.Cryptography.MaskGenerationMethod
     30  {
     31
     32    /// <summary>
     33    /// implemented hash functions
     34    /// </summary>
     35    public enum ShaFunction
     36    {
     37      MD5,
     38      SHA1,
     39      SHA256,
     40      SHA384,
     41      SHA512,
     42      TIGER,
     43      WHIRLPOOL
     44    };
     45
     46    private ShaFunction selectedShaFunction = ShaFunction.SHA256;
     47
     48    /// <summary>
     49    /// Gets or sets the selected sha function.
     50    /// </summary>
     51    /// <value>The selected sha function.</value>
     52    public ShaFunction SelectedShaFunction
     53    {
     54      get
     55      {
     56        return selectedShaFunction;
     57      }
     58      set
     59      {
     60        selectedShaFunction = value;
     61      }
     62    }
     63
     64
     65    /// <summary>
     66    /// Gets the length of the hash in Bytes.
     67    /// </summary>
     68    /// <param name="SelectedShaFunction">The selected sha function.</param>
     69    /// <returns></returns>
     70    public static int GetHashLength(ShaFunction SelectedShaFunction)
     71    {
     72      int[] length =
     73      {
     74        16, // MD5
     75        20, // SHA1
     76        32, // SHA256
     77        48, // SHA384
     78        64, // SHA512
     79        24, // TIGER
     80        64  // WHIRLPOOL
     81      };
     82
     83      return length[(int)SelectedShaFunction];
     84    }
     85
     86    /// <summary>
     87    /// Gets the sha hash.
     88    /// </summary>
     89    /// <param name="key">The key.</param>
     90    /// <param name="salt">The salt.</param>
     91    /// <returns></returns>
     92    private byte[] GetShaHash(byte[] key, byte[] salt)
     93    {
     94      HMAC ha;
     95
     96      switch (selectedShaFunction)
     97      {
     98        case ShaFunction.MD5:
     99          ha = (HMAC)new System.Security.Cryptography.HMACMD5();
     100          break;
     101
     102        case ShaFunction.SHA1:
     103          ha = (HMAC)new System.Security.Cryptography.HMACSHA1();
     104          break;
     105
     106        case ShaFunction.SHA256:
     107          ha = (HMAC)new System.Security.Cryptography.HMACSHA256();
     108          break;
     109
     110        case ShaFunction.SHA384:
     111          ha = (HMAC)new System.Security.Cryptography.HMACSHA384();
     112          break;
     113
     114        case ShaFunction.SHA512:
     115          ha = (HMAC)new System.Security.Cryptography.HMACSHA512();
     116          break;
     117
     118        case ShaFunction.TIGER:
     119          ha = (HMAC)new System.Security.Cryptography.HMACTIGER2();
     120          break;
     121
     122        case ShaFunction.WHIRLPOOL:
     123          ha = (HMAC)new System.Security.Cryptography.HMACWHIRLPOOL();
     124          break;
     125
     126        default:
     127          throw new ArgumentOutOfRangeException("SelectedShaFunction");
     128      }
     129
     130      ha.Key = key;
     131      byte[] h = ha.ComputeHash(salt);
     132      ha.Clear();
     133
     134      return h;
     135    }
     136
     137    /// <summary>
     138    /// Gens the key block.
     139    /// </summary>
     140    /// <param name="password">The password.</param>
     141    /// <param name="salt">The salt.</param>
     142    /// <param name="count">The count.</param>
     143    /// <param name="blockIndex">Index of the block.</param>
     144    /// <returns></returns>
     145    private byte[] GenKeyBlock(byte[] password, byte[] salt, int count, int blockIndex)
     146    {
     147      int len = salt.Length;
     148      byte[] data = new byte[len + 4];
     149
     150      for (int i = 0; i < len; i++)
     151        data[i] = salt[i];
     152
     153      data[len] = data[len + 1] = data[len + 2] = 0;
     154      data[len + 3] = (byte)blockIndex;
     155
     156      byte[] u1 = GetShaHash(password, data);
     157
     158      byte[] result = new byte[u1.Length];
     159      for (int i = 0; i < u1.Length; i++)
     160        result[i] = u1[i];
     161
     162      for (int c = 1; c < count; c++)
     163      {
     164        byte[] u2 = GetShaHash(password, u1);
     165
     166        for (int i = 0; i < result.Length; i++)
     167        {
     168          result[i] ^= u2[i];
     169          u1[i] = u2[i];
     170        }
     171      }
     172
     173      return result;
     174    }
     175
     176    /// <summary>
     177    /// When overridden in a derived class,
     178    /// generates a mask with the specified length using the specified random salt.
     179    /// </summary>
     180    /// <param name="rgbSalt">The random salt to use to compute the mask.</param>
     181    /// <param name="cbReturn">The length of the generated mask in bytes.</param>
     182    /// <returns>
     183    /// A randomly generated mask whose length is equal to the <paramref name="cbReturn"/> parameter.
     184    /// </returns>
    28185    [ComVisibleAttribute(true)]
    29     public class PKCS5MaskGenerationMethod : System.Security.Cryptography.MaskGenerationMethod
    30     {
    31 
    32         /// <summary>
    33         /// implemented hash functions
    34         /// </summary>
    35         public enum ShaFunction
    36         {
    37             MD5,
    38             SHA1,
    39             SHA256,
    40             SHA384,
    41             SHA512
    42         };
    43 
    44         private ShaFunction selectedShaFunction = ShaFunction.SHA256;
    45 
    46         /// <summary>
    47         /// Gets or sets the selected sha function.
    48         /// </summary>
    49         /// <value>The selected sha function.</value>
    50         public ShaFunction SelectedShaFunction
    51         {
    52             get
    53             {
    54                 return selectedShaFunction;
    55             }
    56             set
    57             {
    58                 selectedShaFunction = value;
    59             }
    60         }
    61 
    62 
    63                                 /// <summary>
    64                                 /// Gets the length of the hash.
    65                                 /// </summary>
    66                                 /// <param name="SelectedShaFunction">The selected sha function.</param>
    67                                 /// <returns></returns>
    68                                 public static int GetHashLength(ShaFunction SelectedShaFunction)
    69         {
    70             switch (SelectedShaFunction)
    71             {
    72                 case ShaFunction.MD5:
    73                     return 16;
    74 
    75                 case ShaFunction.SHA1:
    76                     return 20;
    77 
    78                 case ShaFunction.SHA256:
    79                     return 32;
    80 
    81                 case ShaFunction.SHA384:
    82                     return 48;
    83 
    84                 case ShaFunction.SHA512:
    85                     return 64;
    86 
    87                 default:
    88                     throw new ArgumentOutOfRangeException("SelectedShaFunction");
    89             }
    90         }
    91 
    92         /// <summary>
    93         /// Gets the sha hash.
    94         /// </summary>
    95         /// <param name="key">The key.</param>
    96         /// <param name="salt">The salt.</param>
    97         /// <returns></returns>
    98         private byte[] GetShaHash(byte[] key, byte[] salt)
    99         {
    100             HMAC ha;
    101 
    102             switch (selectedShaFunction)
    103             {
    104                 case ShaFunction.MD5:
    105                     ha = (HMAC)new System.Security.Cryptography.HMACMD5();
    106                     break;
    107 
    108                 case ShaFunction.SHA1:
    109                     ha = (HMAC)new System.Security.Cryptography.HMACSHA1();
    110                     break;
    111 
    112                 case ShaFunction.SHA256:
    113                     ha = (HMAC)new System.Security.Cryptography.HMACSHA256();
    114                     break;
    115 
    116                 case ShaFunction.SHA384:
    117                     ha = (HMAC)new System.Security.Cryptography.HMACSHA384();
    118                     break;
    119 
    120                 case ShaFunction.SHA512:
    121                     ha = (HMAC)new System.Security.Cryptography.HMACSHA512();
    122                     break;
    123 
    124                 default:
    125                     throw new ArgumentOutOfRangeException("SelectedShaFunction");
    126             }
    127          
    128             ha.Key = key;
    129             byte[] h = ha.ComputeHash(salt);
    130             ha.Clear();
    131 
    132             return h;
    133         }
    134 
    135         /// <summary>
    136         /// Gens the key block.
    137         /// </summary>
    138         /// <param name="password">The password.</param>
    139         /// <param name="salt">The salt.</param>
    140         /// <param name="count">The count.</param>
    141         /// <param name="blockIndex">Index of the block.</param>
    142         /// <returns></returns>
    143         private byte[] GenKeyBlock(byte[] password, byte[] salt, int count, int blockIndex)
    144         {
    145             int len = salt.Length;
    146             byte[] data = new byte[len + 4];
    147 
    148             for (int i = 0; i < len; i++)
    149                 data[i] = salt[i];
    150 
    151             data[len] = data[len + 1] = data[len + 2] = 0;
    152             data[len + 3] = (byte)blockIndex;
    153 
    154             byte[] u1 = GetShaHash(password, data);
    155 
    156             byte[] result = new byte[u1.Length];
    157             for (int i = 0; i < u1.Length; i++)
    158                 result[i] = u1[i];
    159 
    160             for (int c = 1; c < count; c++)
    161             {
    162                 byte[] u2 = GetShaHash(password, u1);
    163 
    164                 for (int i = 0; i < result.Length; i++)
    165                 {
    166                     result[i] ^= u2[i];
    167                     u1[i] = u2[i];
    168                 }
    169             }
    170 
    171             return result;
    172         }
    173 
    174         /// <summary>
    175         /// When overridden in a derived class, generates a mask with the specified length using the specified random salt.
    176         /// </summary>
    177         /// <param name="rgbSalt">The random salt to use to compute the mask.</param>
    178         /// <param name="cbReturn">The length of the generated mask in bytes.</param>
    179         /// <returns>
    180         /// A randomly generated mask whose length is equal to the <paramref name="cbReturn"/> parameter.
    181         /// </returns>
    182         [ComVisibleAttribute(true)]
    183         public override byte[] GenerateMask
    184             (
    185                 byte[] rgbSalt,
    186                 int cbReturn
    187             )
    188         {
    189             // member implemented for compatibility only ....
    190             // throw new System.NotImplementedException("GenerateMask needs more parameters");
    191 
    192             // Computes masks according to PKCS #1 for use by key exchange algorithms.
    193             // Generates and returns a mask from the specified random salt of the specified length.
    194             PKCS1MaskGenerationMethod pkcs1 = new PKCS1MaskGenerationMethod();
    195             return pkcs1.GenerateMask(rgbSalt, cbReturn);
    196         }
    197 
    198         /// <summary>
    199         /// When overridden in a derived class, generates a mask with the specified length using the specified password and random salt.
    200         /// Implementing PBKDF2 of PKCS #5 v2.1 Password-Basd Cryptography Standard
    201         /// </summary>
    202         /// <param name="password">The password to use to compute the mask.</param>
    203         /// <param name="rgbSalt">The random salt (seed) to use to compute the mask.</param>
    204         /// <param name="count">The iteration count, a positive integer</param>
    205         /// <param name="cbReturn">The length of the generated mask in bytes.</param>
    206         /// <returns>
    207         /// A randomly generated mask whose length is equal to the <paramref name="cbReturn"/> parameter.
    208         /// </returns>
    209         [ComVisibleAttribute(true)]
    210         public byte[] GenerateMask
    211             (
    212                 byte[] password,
    213                 byte[] rgbSalt,
    214                 int count,
    215                 int cbReturn
    216             )
    217         {
    218             if (cbReturn <= 0)
    219                 cbReturn = 1;
    220             //throw new ArgumentOutOfRangeException("cbReturn", "cbReturn must be positive.");
    221 
    222             byte[] key = new byte[cbReturn];
    223             for (int i = 0; i < cbReturn; i++)
    224                 key[i] = 0;
    225 
    226             if (count <= 0)
    227                 count = 1;
    228 
    229                                                 int hLen = GetHashLength(this.SelectedShaFunction);
    230 
    231             // Let blockCount be the number of hLen-bytes blocks in the derived key, rounding up,
    232             // let fillBytes be the number of bytes in the last block.
    233             int blockCount = cbReturn / hLen + 1;
    234             int fillBytes = cbReturn - (blockCount - 1) * hLen;
    235 
    236 //#if DEBUG
    237 //            {
    238 //                string msg = string.Format("Generate {0} blocks with {1} bytes.", blockCount, hLen);
    239 //                Debug.WriteLine(msg);
    240 //                msg = string.Format("The last block has {0} bytes.", fillBytes);
    241 //                Debug.WriteLine(msg);
    242 //                msg = string.Format("requested bytes {0} - generating {1} bytes.", cbReturn, (blockCount - 1) * hLen + fillBytes);
    243 //                Debug.WriteLine(msg);
    244 //            }
    245 //#endif
    246 
    247             if (blockCount > 255)
    248             {
    249                 string msg = string.Format("cbReturn must be lesser than {0} by implementation limits.", hLen * 255);
    250                 throw new ArgumentOutOfRangeException("cbReturn", "msg");
    251             }
    252 
    253             int outPos = 0;
    254 
    255             for (int blockIndex = 0; blockIndex < blockCount - 1; blockIndex++)
    256             {
    257                 byte[] block = GenKeyBlock(password, rgbSalt, count, blockIndex+1);
    258                 for (int i = 0; i < hLen; i++)
    259                     key[outPos++] = block[i];
    260             }
    261 
    262             // last block
    263             if (fillBytes > 0)
    264             {
    265                 byte[] block = GenKeyBlock(password, rgbSalt, count, blockCount);
    266                 for (int i = 0; i < fillBytes; i++)
    267                     key[outPos++] = block[i];
    268             }
    269 
    270             return key;
    271         } // PBKDF2
    272     } // class
     186    public override byte[] GenerateMask
     187        (
     188            byte[] rgbSalt,
     189            int cbReturn
     190        )
     191    {
     192      // member implemented for compatibility only ....
     193      // throw new System.NotImplementedException("GenerateMask needs more parameters");
     194
     195      // Computes masks according to PKCS #1 for use by key exchange algorithms.
     196      // Generates and returns a mask from the specified random salt of the specified length.
     197      PKCS1MaskGenerationMethod pkcs1 = new PKCS1MaskGenerationMethod();
     198      return pkcs1.GenerateMask(rgbSalt, cbReturn);
     199    }
     200
     201    /// <summary>
     202    /// When overridden in a derived class,
     203    /// generates a mask with the specified length using the specified password and random salt.
     204    /// Implementing PBKDF2 of PKCS #5 v2.1 Password-Basd Cryptography Standard
     205    /// </summary>
     206    /// <param name="password">The password to use to compute the mask.</param>
     207    /// <param name="rgbSalt">The random salt (seed) to use to compute the mask.</param>
     208    /// <param name="count">The iteration count, a positive integer</param>
     209    /// <param name="cbReturn">The length of the generated mask in bytes.</param>
     210    /// <returns>
     211    /// A randomly generated mask whose length is equal to the <paramref name="cbReturn"/> parameter.
     212    /// </returns>
     213    [ComVisibleAttribute(true)]
     214    public byte[] GenerateMask
     215        (
     216            byte[] password,
     217            byte[] rgbSalt,
     218            int count,
     219            int cbReturn
     220        )
     221    {
     222      if (cbReturn <= 0)
     223        cbReturn = 1;
     224      //throw new ArgumentOutOfRangeException("cbReturn", "cbReturn must be positive.");
     225
     226      byte[] key = new byte[cbReturn];
     227      for (int i = 0; i < cbReturn; i++)
     228        key[i] = 0;
     229
     230      if (count <= 0)
     231        count = 1;
     232
     233      int hLen = GetHashLength(this.SelectedShaFunction);
     234
     235      // Let blockCount be the number of hLen-bytes blocks in the derived key, rounding up,
     236      // let fillBytes be the number of bytes in the last block.
     237      int blockCount = cbReturn / hLen + 1;
     238      int fillBytes = cbReturn - (blockCount - 1) * hLen;
     239
     240      if (blockCount > 255)
     241      {
     242        string msg = string.Format("cbReturn must be lesser than {0} by implementation limits.", hLen * 255);
     243        throw new ArgumentOutOfRangeException("cbReturn", "msg");
     244      }
     245
     246      int outPos = 0;
     247
     248      for (int blockIndex = 0; blockIndex < blockCount - 1; blockIndex++)
     249      {
     250        byte[] block = GenKeyBlock(password, rgbSalt, count, blockIndex + 1);
     251        for (int i = 0; i < hLen; i++)
     252          key[outPos++] = block[i];
     253      }
     254
     255      // last block
     256      if (fillBytes > 0)
     257      {
     258        byte[] block = GenKeyBlock(password, rgbSalt, count, blockCount);
     259        for (int i = 0; i < fillBytes; i++)
     260          key[outPos++] = block[i];
     261      }
     262
     263      return key;
     264    } // PBKDF2
     265  } // class
    273266}
    274267
  • trunk/SSCext/SSCwhirl.cs

    r139 r198  
    2323namespace System.Security.Cryptography
    2424{
    25   public class HMACWHIRLPOOL : HashAlgorithm
     25  public class HMACWHIRLPOOL : HMAC
    2626  {
    2727    const int DIGESTBYTES = 64;
     
    5555      buffer = new byte[WBLOCKBYTES];
    5656      hash = new ulong[DIGESTBYTES / 8];
     57
     58      HashName = "Whirlpool";
     59
     60      //Key
     61      if ((KeyValue != null) && (KeyValue.Length > 0))
     62        HashCore(KeyValue, 0, KeyValue.Length);
    5763    }
    5864
     65    /// <summary>
     66    /// When overridden in A derived class, gets A value indicating whether multiple blocks can be transformed.
     67    /// </summary>
     68    /// <value></value>
     69    /// <returns>true if multiple blocks can be transformed; otherwise, false.
     70    /// </returns>
     71    public override bool CanTransformMultipleBlocks
     72    {
     73      get
     74      {
     75        return true;
     76      }
     77    }
     78
     79    /// <summary>
     80    /// Gets or sets the key to use in the hash algorithm.
     81    /// </summary>
     82    /// <value></value>
     83    /// <returns>
     84    /// The key to use in the hash algorithm.
     85    /// </returns>
     86    /// <exception cref="T:System.Security.Cryptography.CryptographicException">
     87    /// An attempt is made to change the <see cref="P:System.Security.Cryptography.HMAC.Key"/> property
     88    /// after hashing has begun.
     89    /// </exception>
     90    public override byte[] Key
     91    {
     92      get
     93      {
     94        return base.Key;
     95      }
     96      set
     97      {
     98        base.Key = value;
     99        Initialize();
     100      }
     101    }
    59102
    60103    /// <summary>
     
    167210      }
    168211    }
    169 
    170 
    171212
    172213    /// <summary>
     
    825866      state[7] = block[7] ^ (K[7] = hash[7]);
    826867
    827      // iterate over all rounds:
     868      // iterate over all rounds:
    828869      for (r = 1; r <= R; r++)
    829870      {
Note: See TracChangeset for help on using the changeset viewer.