    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    }