Changeset 345


Ignore:
Timestamp:
Jun 7, 2009, 11:09:03 AM (13 years ago)
Author:
Gerhard Junker
Message:

PKCS5: NOW! with dynamic inputs: byte array, string, stream

Location:
trunk
Files:
3 edited

Legend:

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

    r198 r345  
    3333  public class PKCS5 : IHash
    3434  {
     35    private enum argType
     36    {
     37      Object, // unknown - default
     38      Stream,
     39      ByteArray,
     40      String
     41    };
    3542
    3643    /// <summary>
     
    8794    #endregion
    8895
     96    private string GetStringForSelectedEncoding(byte[] arrByte)
     97    {
     98      if (arrByte != null)
     99      {
     100        string returnValue;
     101
     102        // here conversion happens
     103        switch (settings.Encoding)
     104        {
     105          case PKCS5Settings.EncodingTypes.Default:
     106            returnValue = Encoding.Default.GetString(arrByte, 0, arrByte.Length);
     107            break;
     108          case PKCS5Settings.EncodingTypes.Unicode:
     109            returnValue = Encoding.Unicode.GetString(arrByte, 0, arrByte.Length);
     110            break;
     111          case PKCS5Settings.EncodingTypes.UTF7:
     112            returnValue = Encoding.UTF7.GetString(arrByte, 0, arrByte.Length);
     113            break;
     114          case PKCS5Settings.EncodingTypes.UTF8:
     115            returnValue = Encoding.UTF8.GetString(arrByte, 0, arrByte.Length);
     116            break;
     117          case PKCS5Settings.EncodingTypes.UTF32:
     118            returnValue = Encoding.UTF32.GetString(arrByte, 0, arrByte.Length);
     119            break;
     120          case PKCS5Settings.EncodingTypes.ASCII:
     121            returnValue = Encoding.ASCII.GetString(arrByte, 0, arrByte.Length);
     122            break;
     123          case PKCS5Settings.EncodingTypes.BigEndianUnicode:
     124            returnValue = Encoding.BigEndianUnicode.GetString(arrByte, 0, arrByte.Length);
     125            break;
     126          default:
     127            returnValue = Encoding.Default.GetString(arrByte, 0, arrByte.Length);
     128            break;
     129        }
     130        return returnValue;
     131      }
     132      return null;
     133    }
     134
     135
     136    public byte[] GetByteArrayForSelectedEncodingByteArray(string data)
     137    {
     138      byte[] byteArrayOutput = null;
     139
     140      if ((data != null) && (data.Length != 0))
     141      {
     142        // here conversion happens       
     143        switch (settings.Encoding)
     144        {
     145          case PKCS5Settings.EncodingTypes.Default:
     146            byteArrayOutput = Encoding.Default.GetBytes(data.ToCharArray());
     147            break;
     148          case PKCS5Settings.EncodingTypes.Unicode:
     149            byteArrayOutput = Encoding.Unicode.GetBytes(data.ToCharArray());
     150            break;
     151          case PKCS5Settings.EncodingTypes.UTF7:
     152            byteArrayOutput = Encoding.UTF7.GetBytes(data.ToCharArray());
     153            break;
     154          case PKCS5Settings.EncodingTypes.UTF8:
     155            byteArrayOutput = Encoding.UTF8.GetBytes(data.ToCharArray());
     156            break;
     157          case PKCS5Settings.EncodingTypes.UTF32:
     158            byteArrayOutput = Encoding.UTF32.GetBytes(data.ToCharArray());
     159            break;
     160          case PKCS5Settings.EncodingTypes.ASCII:
     161            byteArrayOutput = Encoding.ASCII.GetBytes(data.ToCharArray());
     162            break;
     163          case PKCS5Settings.EncodingTypes.BigEndianUnicode:
     164            byteArrayOutput = Encoding.BigEndianUnicode.GetBytes(data.ToCharArray());
     165            break;
     166          default:
     167            byteArrayOutput = Encoding.Default.GetBytes(data.ToCharArray());
     168            break;
     169        }
     170        return byteArrayOutput;
     171      }
     172
     173      return null;
     174    }
     175
     176
    89177    #region Input key / password
    90178
    91179    // Input key
    92180    private byte[] key = { };
    93 
    94     /// <summary>
    95     /// Notifies the update input.
    96     /// </summary>
    97     private void NotifyUpdateKey()
    98     {
    99       OnPropertyChanged("KeyStream");
    100       OnPropertyChanged("KeyData");
    101     }
     181    private argType keyType = argType.Object;
    102182
    103183    /// <summary>
     
    105185    /// </summary>
    106186    /// <value>The input key.</value>
    107     [PropertyInfo(Direction.Input, "Key Stream", "Key stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    108     public CryptoolStream KeyStream
    109     {
    110       get
    111       {
    112         CryptoolStream keyDataStream = new CryptoolStream();
    113         keyDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, key);
    114         return keyDataStream;
     187    [PropertyInfo(Direction.Input, "Key", "Key to be hashed", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     188    public System.Object Key
     189    {
     190      get
     191      {
     192        switch(keyType)
     193        {
     194          default:
     195          //case argType.Object:
     196          //case argType.Stream:
     197            {
     198              CryptoolStream keyDataStream = new CryptoolStream();
     199              keyDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, key);
     200              return keyDataStream;
     201            }
     202
     203          case argType.ByteArray:
     204            return key;
     205
     206          case argType.String:
     207            return GetStringForSelectedEncoding(key);
     208        }
    115209      }
    116210      set
     
    119213          return;
    120214
    121         long len = value.Length;
    122         key = new byte[len];
    123 
    124         for (long i = 0; i < len; i++)
    125           key[i] = (byte)value.ReadByte();
    126 
    127         NotifyUpdateKey();
    128         GuiLogMessage("KeyStream changed.", NotificationLevel.Debug);
    129       }
    130     }
    131 
    132     /// <summary>
    133     /// Gets the input data.
    134     /// </summary>
    135     /// <value>The input data.</value>
    136     [PropertyInfo(Direction.Input, "Key Data", "Key stream to be hashed", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    137     public byte[] KeyData
    138     {
    139       get
    140       {
    141         return key;
    142       }
    143       set
    144       {
    145         long len = value.Length;
    146         key = new byte[len];
    147 
    148         for (long i = 0; i < len; i++)
    149           key[i] = value[i];
    150 
    151         NotifyUpdateKey();
    152         GuiLogMessage("KeyData changed.", NotificationLevel.Debug);
    153       }
    154     }
     215        if (Object.ReferenceEquals(value.GetType(), typeof(CryptoolStream)))
     216        {
     217          keyType = argType.Stream;
     218
     219          CryptoolStream cst = (CryptoolStream)value;
     220          long len = cst.Length;
     221          key = new byte[len];
     222
     223          for (long i = 0; i < len; i++)
     224            key[i] = (byte)cst.ReadByte();
     225
     226        }
     227        else if (Object.ReferenceEquals(value.GetType(), typeof(byte[])))
     228        {
     229          keyType = argType.ByteArray;
     230
     231          byte[] ba = (byte[])value;
     232         
     233          long len = ba.Length;
     234          key = new byte[len];
     235
     236          for (long i = 0; i < len; i++)
     237            key[i] = ba[i];
     238        }
     239        else if (Object.ReferenceEquals(value.GetType(), typeof(string)))
     240        {
     241          string str = (string) value;
     242          key = GetByteArrayForSelectedEncodingByteArray(str);
     243        }
     244        else
     245        {
     246          throw new InvalidCastException("Invalid data type for Key property.");
     247        }
     248
     249        OnPropertyChanged("Key");
     250        GuiLogMessage("Key changed.", NotificationLevel.Debug);
     251      }
     252    }
     253
    155254    #endregion
    156255
     
    159258    // Salt Data
    160259    private byte[] salt = { };
    161 
    162     /// <summary>
    163     /// Notifies the update salt.
    164     /// </summary>
    165     private void NotifyUpdateSalt()
    166     {
    167       OnPropertyChanged("SaltStream");
    168       OnPropertyChanged("SaltData");
    169     }
     260    argType saltType = argType.Object;
    170261
    171262    /// <summary>
     
    173264    /// </summary>
    174265    /// <value>The salt data.</value>
    175     [PropertyInfo(Direction.Input, "Salt Stream", "Salt - Input salt data to change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    176     public CryptoolStream SaltStream
    177     {
    178       get
    179       {
    180         CryptoolStream saltDataStream = new CryptoolStream();
    181         saltDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, salt);
    182         return saltDataStream;
     266    [PropertyInfo(Direction.Input, "Salt", "Salt - Input salt data to change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     267    public Object Salt
     268    {
     269      get
     270      {
     271        switch (saltType)
     272        {
     273          default:
     274          //case argType.Object:
     275          //case argType.Stream:
     276            {
     277              CryptoolStream saltDataStream = new CryptoolStream();
     278              saltDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, salt);
     279              return saltDataStream;
     280            }
     281
     282          case argType.ByteArray:
     283            return salt;
     284
     285          case argType.String:
     286            return GetStringForSelectedEncoding(salt);
     287        }
    183288      }
    184289      set
     
    186291        if (null == value)
    187292          return;
    188         long len = value.Length;
    189         salt = new byte[len];
    190 
    191         for (long i = 0; i < len; i++)
    192           salt[i] = (byte)value.ReadByte();
    193 
    194         NotifyUpdateSalt();
    195         GuiLogMessage("SaltStream changed.", NotificationLevel.Debug);
    196       }
    197     }
    198 
    199     /// <summary>
    200     /// Gets or sets the salt data.
    201     /// </summary>
    202     /// <value>The salt data.</value>
    203     [PropertyInfo(Direction.Input, "Salt Data", "Salt - Input salt data to to be change the PKCS hash", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    204     public byte[] SaltData
    205     {
    206       get
    207       {
    208         return salt;
    209       }
    210 
    211       set
    212       {
    213         long len = value.Length;
    214         salt = new byte[len];
    215 
    216         for (long i = 0; i < len; i++)
    217           salt[i] = value[i];
    218 
    219         NotifyUpdateSalt();
    220         GuiLogMessage("SaltData changed.", NotificationLevel.Debug);
    221       }
    222     }
     293
     294        if (Object.ReferenceEquals(value.GetType(), typeof(CryptoolStream)))
     295        {
     296          saltType = argType.Stream;
     297
     298          CryptoolStream cst = (CryptoolStream)value;
     299          long len = cst.Length;
     300          salt = new byte[len];
     301
     302          for (long i = 0; i < len; i++)
     303            salt[i] = (byte)cst.ReadByte();
     304        }
     305        else if (Object.ReferenceEquals(value.GetType(), typeof(byte[])))
     306        {
     307          saltType = argType.ByteArray;
     308
     309          byte[] ba = (byte[])value;
     310
     311          long len = ba.Length;
     312          salt = new byte[len];
     313
     314          for (long i = 0; i < len; i++)
     315            salt[i] = ba[i];
     316        }
     317        else if (Object.ReferenceEquals(value.GetType(), typeof(string)))
     318        {
     319          string str = (string)value;
     320          salt = GetByteArrayForSelectedEncodingByteArray(str);
     321        }
     322
     323        else
     324        {
     325          throw new InvalidCastException("Invalid data type for Salt property.");
     326        }
     327
     328        OnPropertyChanged("Salt");
     329        GuiLogMessage("Salt changed.", NotificationLevel.Debug);
     330      }
     331    }
     332 
    223333    #endregion
    224334
  • trunk/CrypPlugins/PKCS5/PKCS5Settings.cs

    r198 r345  
    3737    #region ISettings Member
    3838
     39    public enum EncodingTypes
     40    {
     41      Default = 0,
     42      Unicode = 1,
     43      UTF7 = 2,
     44      UTF8 = 3,
     45      UTF32 = 4,
     46      ASCII = 5,
     47      BigEndianUnicode = 6
     48    };
     49    private EncodingTypes encoding = EncodingTypes.Default;
     50    /// <summary>
     51    /// Retrieves the current used encoding, or sets it.
     52    /// </summary>
     53    public EncodingTypes Encoding
     54    {
     55      get
     56      {
     57        return this.encoding;
     58      }
     59      set
     60      {
     61        if (this.Encoding != value)
     62          hasChanges = true;
     63        this.encoding = value;
     64        OnPropertyChanged("EncodingSetting");
     65      }
     66    }
    3967
    4068    /// <summary>
     
    120148    }
    121149
     150
     151
     152    /// <summary>
     153    /// Encoding property used in the Settings pane.
     154    /// </summary>
     155    [ContextMenu("String encoding", "Choose the expected encoding of strings (input & output).", 1, DisplayLevel.Experienced, ContextMenuControlType.ComboBox, null,
     156      new string[] { "Default system encoding", "Unicode", "UTF-7", "UTF-8", "UTF-32", "ASCII", "Big endian unicode" })]
     157    [TaskPane("String encoding", "Choose the expected encoding of strings (input & output).",
     158      null, 1, false, DisplayLevel.Experienced, ControlType.RadioButton,
     159      new string[] { "Default system encoding", "Unicode", "UTF-7", "UTF-8", "UTF-32", "ASCII", "Big endian unicode" })]
     160    public int EncodingSetting
     161    {
     162      get
     163      {
     164        return (int)this.encoding;
     165      }
     166      set
     167      {
     168        if (this.encoding != (EncodingTypes)value)
     169          HasChanges = true;
     170        this.encoding = (EncodingTypes)value;
     171        OnPropertyChanged("EncodingSetting");
     172      }
     173    }
     174
     175
    122176    /// <summary>
    123177    /// Checks the length.
  • trunk/DevTestMethods/pkcsTest.cs

    r157 r345  
    8989      PKCS5.PKCS5 p = new PKCS5.PKCS5();
    9090      p.Settings = set;
    91       p.KeyData = key;
    92       p.SaltData = salt;
     91      p.Key = key;
     92      p.Salt = salt;
    9393
    9494      testContextInstance.WriteLine("key is  " + ConvertByteToHex(key));
Note: See TracChangeset for help on using the changeset viewer.