001    /* Copyright  (c) 2002 Graz University of Technology. All rights reserved.
002     *
003     * Redistribution and use in  source and binary forms, with or without 
004     * modification, are permitted  provided that the following conditions are met:
005     *
006     * 1. Redistributions of  source code must retain the above copyright notice,
007     *    this list of conditions and the following disclaimer.
008     *
009     * 2. Redistributions in  binary form must reproduce the above copyright notice,
010     *    this list of conditions and the following disclaimer in the documentation
011     *    and/or other materials provided with the distribution.
012     *  
013     * 3. The end-user documentation included with the redistribution, if any, must
014     *    include the following acknowledgment:
015     * 
016     *    "This product includes software developed by IAIK of Graz University of
017     *     Technology."
018     * 
019     *    Alternately, this acknowledgment may appear in the software itself, if 
020     *    and wherever such third-party acknowledgments normally appear.
021     *  
022     * 4. The names "Graz University of Technology" and "IAIK of Graz University of
023     *    Technology" must not be used to endorse or promote products derived from 
024     *    this software without prior written permission.
025     *  
026     * 5. Products derived from this software may not be called 
027     *    "IAIK PKCS Wrapper", nor may "IAIK" appear in their name, without prior 
028     *    written permission of Graz University of Technology.
029     *  
030     *  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
031     *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
032     *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
033     *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR BE
034     *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
035     *  OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
036     *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
037     *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
038     *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
039     *  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
040     *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
041     *  POSSIBILITY  OF SUCH DAMAGE.
042     */
043    
044    package demo.pkcs.pkcs11;
045    
046    import java.io.BufferedReader;
047    import java.io.InputStreamReader;
048    import java.io.PrintWriter;
049    
050    import iaik.pkcs.pkcs11.Mechanism;
051    import iaik.pkcs.pkcs11.Module;
052    import iaik.pkcs.pkcs11.Session;
053    import iaik.pkcs.pkcs11.Slot;
054    import iaik.pkcs.pkcs11.Token;
055    import iaik.pkcs.pkcs11.objects.Key;
056    import iaik.pkcs.pkcs11.parameters.DHKeyDerivationParameters;
057    import iaik.pkcs.pkcs11.parameters.Parameters;
058    import iaik.pkcs.pkcs11.parameters.X942DH2KeyDerivationParameters;
059    
060    
061    
062    /**
063     * Just to test the parameters classes.
064     *
065     * @author <a href="mailto:Karl.Scheibelhofer@iaik.at"> Karl Scheibelhofer </a>
066     * @version 0.1
067     * @invariants
068     */
069    public class ParametersTest {
070    
071      static PrintWriter output_;
072    
073      static BufferedReader input_;
074    
075      static {
076        try {
077          //output_ = new PrintWriter(new FileWriter("GetInfo_output.txt"), true);
078          output_ = new PrintWriter(System.out, true);
079          input_ = new BufferedReader(new InputStreamReader(System.in));
080        } catch (Throwable thr) {
081          thr.printStackTrace();
082          output_ = new PrintWriter(System.out, true);
083          input_ = new BufferedReader(new InputStreamReader(System.in));
084        }
085      }
086    
087      public static void main(String[] args) {
088        if (args.length != 1) {
089          printUsage();
090          System.exit(1);
091        }
092    
093        try {
094    
095            Module pkcs11Module = Module.getInstance(args[0]);
096            pkcs11Module.initialize(null);
097    
098            Slot[] slots = pkcs11Module.getSlotList(Module.SlotRequirement.TOKEN_PRESENT);
099    
100            if (slots.length == 0) {
101              output_.println("No slot with present token found!");
102              output_.flush();
103              System.exit(0);
104            }
105    
106            Slot selectedSlot = slots[0];
107            Token token = selectedSlot.getToken();
108    
109            Session session =
110                token.openSession(Token.SessionType.SERIAL_SESSION, Token.SessionReadWriteBehavior.RO_SESSION, null, null);
111    
112            output_.println("################################################################################");
113    
114            Mechanism mechanism;
115            Parameters parameters;
116            Key key = new Key(); // create a dummy key
117            Key anotherKey = new Key(); // create a dummy key
118            key.setObjectHandle(1);
119            anotherKey.setObjectHandle(2);
120    
121    /*
122            output_.print("testing DHPkcsDeriveParameters... ");
123            mechanism = (Mechanism) Mechanism.DH_PKCS_DERIVE.clone();
124            byte[] publicValue = { 1, 2, 3, 4, 5, 6, 7, 8 };
125            parameters = new DHPkcsDeriveParameters(publicValue);
126            mechanism.setParameters(parameters);
127            session.deriveKey(mechanism, key, null);
128            output_.println("finished");
129            output_.flush();
130     */
131    
132    /*
133            output_.print("testing ExtractParameters... ");
134            mechanism = (Mechanism) Mechanism.EXTRACT_KEY_FROM_KEY.clone();
135            parameters = new ExtractParameters(4);
136            mechanism.setParameters(parameters);
137            session.deriveKey(mechanism, key, null);
138            output_.println("finished");
139            output_.flush();
140     */
141    
142    /*
143            output_.print("testing InitializationVectorParameters... ");
144            mechanism = (Mechanism) Mechanism.DES3_CBC_PAD.clone();
145            byte[] iv = { 1, 2, 3, 4, 5, 6, 7, 8 };
146            parameters = new InitializationVectorParameters(iv);
147            mechanism.setParameters(parameters);
148            session.encryptInit(mechanism, key);
149            output_.println("finished");
150            output_.flush();
151     */
152    
153    /*
154            output_.print("testing KEADeriveParameters... ");
155            mechanism = (Mechanism) Mechanism.EXTRACT_KEY_FROM_KEY.clone();
156            byte[] randomA = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
157            byte[] randomB = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
158            byte[] publicData = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 };
159            parameters = new KEADeriveParameters(true, randomA, randomB, publicData);
160            mechanism.setParameters(parameters);
161            session.deriveKey(mechanism, key, null);
162            output_.println("finished");
163            output_.flush();
164     */
165    
166    /*
167            output_.print("testing KeyDerivationStringDataParameters... ");
168            byte[] data = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
169            parameters = new KeyDerivationStringDataParameters(data);
170            mechanism = (Mechanism) Mechanism.CONCATENATE_BASE_AND_DATA.clone();
171            mechanism.setParameters(parameters);
172            session.deriveKey(mechanism, key, null);
173            output_.println("finished");
174            output_.flush();
175     */
176    
177    /*
178            output_.print("testing KeyWrapSetOaepParameters... ");
179            byte[] x = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
180            parameters = new KeyWrapSetOaepParameters((byte) 0xEF, x);
181            mechanism = (Mechanism) Mechanism.KEY_WRAP_SET_OAEP.clone();
182            mechanism.setParameters(parameters);
183            session.wrapKey(mechanism, key, anotherKey);
184            output_.println("finished");
185            output_.flush();
186     */
187    
188    /*
189            output_.print("testing MacGeneralParameters... ");
190            byte[] x = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
191            parameters = new MacGeneralParameters(16);
192            mechanism = (Mechanism) Mechanism.DES3_MAC_GENERAL.clone();
193            mechanism.setParameters(parameters);
194            session.signInit(mechanism, key);
195            output_.println("finished");
196            output_.flush();
197     */
198    
199    /*
200            output_.print("testing ObjectHandleParameters... ");
201            Key parameterKey = new Key(); // create a dummy key
202            parameterKey.setObjectHandle(3);
203            parameters = new ObjectHandleParameters(parameterKey);
204            mechanism = (Mechanism) Mechanism.CONCATENATE_BASE_AND_KEY.clone();
205            mechanism.setParameters(parameters);
206            session.deriveKey(mechanism, key, anotherKey);
207            output_.println("finished");
208            output_.flush();
209    */
210    
211    /*
212            output_.print("testing PBEParameters... ");
213            mechanism = (Mechanism) Mechanism.PBE_SHA1_DES3_EDE_CBC.clone();
214            char[] iv = "initiali".toCharArray();
215            char[] password = "password".toCharArray();
216            char[] salt = "salt".toCharArray();
217            long iterations = 1000;
218            parameters = new PBEParameters(iv, password, salt, iterations);
219            mechanism.setParameters(parameters);
220            session.encryptInit(mechanism, key);
221            output_.println("finished");
222            output_.flush();
223     */
224    
225    /*
226            output_.print("testing PKCS5PBKD2Parameters... ");
227            mechanism = (Mechanism) Mechanism.PBE_SHA1_DES3_EDE_CBC.clone();
228            long saltSource = PKCS5PBKD2Parameters.SaltSourceType.SALT_SPECIFIED;
229            byte[] saltSourceData = "salt".getBytes("ASCII");
230            long iterations = 1000;
231            long pseudoRandomFunction = PKCS5PBKD2Parameters.PseudoRandomFunctionType.HMAC_SHA1;
232            byte[] pseudoRandomFunctionData = "datadata".getBytes("ASCII");
233            parameters = new PKCS5PBKD2Parameters(saltSource, saltSourceData, iterations,
234                                                  pseudoRandomFunction, pseudoRandomFunctionData);
235            mechanism.setParameters(parameters);
236            SecretKey secretKeyTemplate = new SecretKey();
237            secretKeyTemplate.setObjectHandle(4);
238            session.generateKey(mechanism, secretKeyTemplate);
239            output_.println("finished");
240            output_.flush();
241     */
242    
243    /*
244            output_.print("testing RC2CbcParameters... ");
245            byte[] iv = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
246            parameters = new RC2CbcParameters(42, iv);
247            mechanism = (Mechanism) Mechanism.RC2_CBC_PAD.clone();
248            mechanism.setParameters(parameters);
249            session.encryptInit(mechanism, key);
250            output_.println("finished");
251            output_.flush();
252     */
253    
254    /*
255            output_.print("testing RC2MacGeneralParameters... ");
256            parameters = new RC2MacGeneralParameters(128, 16);
257            mechanism = (Mechanism) Mechanism.RC2_MAC_GENERAL.clone();
258            mechanism.setParameters(parameters);
259            session.signInit(mechanism, key);
260            output_.println("finished");
261            output_.flush();
262     */
263    
264    /*
265            output_.print("testing RC2Parameters... ");
266            parameters = new RC2Parameters(128);
267            mechanism = (Mechanism) Mechanism.RC2_MAC.clone();
268            mechanism.setParameters(parameters);
269            session.signInit(mechanism, key);
270            output_.println("finished");
271            output_.flush();
272     */
273    
274    /*
275            output_.print("testing RC5CbcParameters... ");
276            byte[] iv = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
277            parameters = new RC5CbcParameters(4, 16, iv);
278            mechanism = (Mechanism) Mechanism.RC5_CBC_PAD.clone();
279            mechanism.setParameters(parameters);
280            session.encryptInit(mechanism, key);
281            output_.println("finished");
282            output_.flush();
283     */
284    
285    /*
286            output_.print("testing RC5MacGeneralParameters... ");
287            parameters = new RC5MacGeneralParameters(4, 16, 12);
288            mechanism = (Mechanism) Mechanism.RC5_MAC_GENERAL.clone();
289            mechanism.setParameters(parameters);
290            session.signInit(mechanism, key);
291            output_.println("finished");
292            output_.flush();
293     */
294    
295    /*
296            output_.print("testing RC5Parameters... ");
297            parameters = new RC5Parameters(4, 16);
298            mechanism = (Mechanism) Mechanism.RC5_MAC.clone();
299            mechanism.setParameters(parameters);
300            session.signInit(mechanism, key);
301            output_.println("finished");
302            output_.flush();
303     */
304    
305    /*
306            output_.print("testing RSAPkcsOaepParameters... ");
307            Mechanism hashAlgorithm = Mechanism.SHA_1;
308            long maskGenerationFunction = RSAPkcsParameters.MessageGenerationFunctionType.SHA1;
309            long source = RSAPkcsOaepParameters.SourceType.DATA_SPECIFIED;
310            byte[] sourceData = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
311            parameters = new RSAPkcsOaepParameters(hashAlgorithm, maskGenerationFunction, source, sourceData);
312            mechanism = (Mechanism) Mechanism.RC5_MAC.clone();
313            mechanism.setParameters(parameters);
314            session.encryptInit(mechanism, key);
315            output_.println("finished");
316            output_.flush();
317     */
318    
319    /*
320            output_.print("testing SkipJackPrivateWrapParameters... ");
321            byte[] password = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
322            byte[] publicData = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
323            byte[] randomA = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 };
324            byte[] primeP = { 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F };
325            byte[] baseG = { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27 };
326            byte[] subprimeQ = { 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F };
327            parameters = new SkipJackPrivateWrapParameters(password, publicData, randomA, primeP, baseG, subprimeQ);
328            mechanism = (Mechanism) Mechanism.SKIPJACK_PRIVATE_WRAP.clone();
329            mechanism.setParameters(parameters);
330            session.wrapKey(mechanism, key, anotherKey);
331            output_.println("finished");
332            output_.flush();
333     */
334    
335    /*
336            output_.print("testing SkipJackRelayXParameters... ");
337            byte[] oldWrappedX = { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37 };
338            byte[] oldPassword = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
339            byte[] oldPublicData = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
340            byte[] oldRandomA = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 };
341            byte[] newPassword = { 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F };
342            byte[] newPublicData = { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27 };
343            byte[] newRandomA = { 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F };
344            parameters = new SkipJackRelayXParameters(oldWrappedX, oldPassword, oldPublicData, oldRandomA,
345                                                      newPassword, newPublicData, newRandomA);
346            mechanism = (Mechanism) Mechanism.SKIPJACK_RELAYX.clone();
347            mechanism.setParameters(parameters);
348            session.wrapKey(mechanism, key, anotherKey);
349            output_.println("finished");
350            output_.flush();
351    
352     */
353    
354            // SSL* and Version parameters tested in SSLMechanismsDemo
355    
356    /*
357            output_.print("testing RSAPkcsPssParameters... ");
358            Mechanism hashAlgorithm = Mechanism.SHA_1;
359            long maskGenerationFunction = RSAPkcsParameters.MessageGenerationFunctionType.SHA1;
360            long saltLength = 16;
361            parameters = new RSAPkcsPssParameters(hashAlgorithm, maskGenerationFunction, saltLength);
362            mechanism = (Mechanism) Mechanism.RSA_PKCS_PSS.clone();
363            mechanism.setParameters(parameters);
364            session.signInit(mechanism, key);
365            output_.println("finished");
366            output_.flush();
367     */
368    
369    /*
370            output_.print("testing EcDH1KeyDerivationParameters... ");
371            long keyDerivationFunction = DHKeyDerivationParameters.KeyDerivationFunctionType.SHA1_KDF;
372            byte[] sharedData = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
373            byte[] publicData = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
374            parameters = new EcDH1KeyDerivationParameters(keyDerivationFunction, sharedData, publicData);
375            mechanism = (Mechanism) Mechanism.ECDH1_DERIVE.clone();
376            mechanism.setParameters(parameters);
377            session.deriveKey(mechanism, key, anotherKey);
378            output_.println("finished");
379            output_.flush();
380     */
381    
382    /*
383            output_.print("testing EcDH2KeyDerivationParameters... ");
384            long keyDerivationFunction = DHKeyDerivationParameters.KeyDerivationFunctionType.SHA1_KDF;
385            byte[] sharedData = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
386            byte[] publicData = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
387            byte[] publicData2 = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 };
388            long privateDataLength = 16;
389            Key privateData = new Key();
390            privateData.setObjectHandle(3);
391            parameters = new EcDH2KeyDerivationParameters(keyDerivationFunction, sharedData, publicData,
392                                                          privateDataLength, privateData, publicData2);
393            mechanism = (Mechanism) Mechanism.ECMQV_DERIVE.clone();
394            mechanism.setParameters(parameters);
395            session.deriveKey(mechanism, key, anotherKey);
396            output_.println("finished");
397            output_.flush();
398     */
399    
400    /*
401            output_.print("testing X942DH1KeyDerivationParameters... ");
402            long keyDerivationFunction = DHKeyDerivationParameters.KeyDerivationFunctionType.SHA1_KDF_ASN1;
403            byte[] otherInfo = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
404            byte[] publicData = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
405            parameters = new X942DH1KeyDerivationParameters(keyDerivationFunction, otherInfo, publicData);
406            mechanism = (Mechanism) Mechanism.X9_42_DH_DERIVE.clone();
407            mechanism.setParameters(parameters);
408            session.deriveKey(mechanism, key, anotherKey);
409            output_.println("finished");
410            output_.flush();
411     */
412    
413            output_.print("testing X942DH2KeyDerivationParameters... ");
414            long keyDerivationFunction = DHKeyDerivationParameters.KeyDerivationFunctionType.SHA1_KDF_ASN1;
415            byte[] otherInfo = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
416            byte[] publicData = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
417            byte[] publicData2 = { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 };
418            long privateDataLength = 16;
419            Key privateData = new Key();
420            privateData.setObjectHandle(3);
421            parameters = new X942DH2KeyDerivationParameters(keyDerivationFunction, otherInfo, publicData,
422                                                            privateDataLength, privateData, publicData2);
423            mechanism = (Mechanism) Mechanism.X9_42_DH_HYBRID_DERIVE.clone();
424            mechanism.setParameters(parameters);
425            session.deriveKey(mechanism, key, anotherKey);
426            output_.println("finished");
427            output_.flush();
428    
429            output_.println("################################################################################");
430            session.closeSession();
431            pkcs11Module.finalize(null);
432    
433        } catch (Throwable thr) {
434          thr.printStackTrace();
435        }
436        output_.println("press any key to continue...");
437        try {
438          input_.read();
439        } catch (Throwable thr) {
440          thr.printStackTrace();
441        }
442      }
443    
444      public static void printUsage() {
445        output_.println("Usage: ParametersTest <PKCS#11 module>");
446        output_.println(" e.g.: ParametersTest pk2priv.dll");
447        output_.println("The given DLL must be in the search path of the system.");
448      }
449    
450    }