public static void main(String[] args) throws IOException, TokenException {
    if (args.length != 1) {
      printUsage();
      System.exit(1);
    }

    Module pkcs11Module = Module.getInstance(args[0]);
    pkcs11Module.initialize(null);

    Slot[] slots = pkcs11Module.getSlotList(Module.SlotRequirement.TOKEN_PRESENT);

    if (slots.length == 0) {
      System.out.println("No slot with present token found!");
      System.exit(0);
    }

    Slot selectedSlot = slots[0];
    Token token = selectedSlot.getToken();

    System.out.println(
        "################################################################################");
    System.out.print("trying to set Notify callback handler... ");

    NotifyDemo callback = new NotifyDemo();
    String applicationData = "Hello Application!";
    Session session =
        token.openSession(
            Token.SessionType.SERIAL_SESSION,
            Token.SessionReadWriteBehavior.RO_SESSION,
            applicationData,
            callback);

    System.out.println("finished");
    System.out.println(
        "################################################################################");

    // FIXME, insert any code that causes a callback

    session.closeSession();
    pkcs11Module.finalize(null);
  }
Ejemplo n.º 2
0
  /** Usage: InitToken PKCS#11-module Card-Label [slot-id] [SO Pin] [User Pin] */
  public static void main(String[] args) throws TokenException, IOException {
    if (args.length < 2) {
      printUsage();
      throw new IOException("Missing argument!");
    }

    Module pkcs11Module = Module.getInstance(args[0]);
    pkcs11Module.initialize(null);

    try {
      Token token;
      if (2 < args.length) token = Util.selectToken(pkcs11Module, output_, input_, args[2]);
      else token = Util.selectToken(pkcs11Module, output_, input_, null);

      if (token == null) {
        output_.println("We have no token to proceed. Finished.");
        output_.flush();
        throw new TokenException("No token found!");
      }

      TokenInfo tokenInfo = token.getTokenInfo();

      output_.println(
          "################################################################################");
      output_.println("Information of Token to be initialized:");
      output_.println(tokenInfo);
      output_.println(
          "################################################################################");

      /*
       * output_.println(
       * "################################################################################");
       * output_.println(
       * "ATTENTION! Initialization will start in 10 seconds. You have time to remove the token or press any key to abort. Countdown... "
       * );
       *
       * InputStreamReader inputReader = new InputStreamReader(System.in); for (int i = 10; i >= 0;
       * i--) { output_.print("\r"); output_.print(i); output_.print(' '); output_.flush();
       * Thread.sleep(1000); if (inputReader.ready()) { output_.println("Aborted...EXIT");
       * output_.flush(); pkcs11Module.finalize(null); } } output_.println();
       */
      output_.print("initializing... ");

      String soPINString = null;
      if (tokenInfo.isProtectedAuthenticationPath()) {
        output_.print("Please enter the SO-PIN at the PIN-pad of your reader.");
        token.initToken(null, args[1]);
        ; // the token prompts the PIN by other means; e.g. PIN-pad
      } else {
        output_.print("Enter the SO-PIN and press [return key]: ");
        output_.flush();
        if (3 < args.length) {
          soPINString = args[3];
          output_.print(args[3] + "\n");
        } else soPINString = input_.readLine();
        token.initToken(soPINString.toCharArray(), args[1]);
      }
      output_.println("FINISHED");

      // login security officer
      // if (tokenInfo.isLoginRequired()) {
      output_.print("initializing user-PIN... ");
      Session session =
          token.openSession(
              Token.SessionType.SERIAL_SESSION,
              Token.SessionReadWriteBehavior.RW_SESSION,
              null,
              null);

      if (tokenInfo.isProtectedAuthenticationPath()) {
        output_.print("Please enter the SO-PIN at the PIN-pad of your reader.");
        output_.flush();
        session.login(Session.UserType.SO, null); // the token prompts the PIN by other means; e.g.
        // PIN-pad
        output_.print("Please enter the user-PIN at the PIN-pad of your reader.");
        output_.flush();
        session.initPIN(null);
      } else {
        if (soPINString != null) {
          session.login(Session.UserType.SO, soPINString.toCharArray());
        } else {
          output_.print("Enter the SO-PIN and press [return key]: ");
          output_.flush();
          if (3 < args.length) {
            soPINString = args[3];
            output_.print(args[3] + "\n");
          } else soPINString = input_.readLine();
          session.login(Session.UserType.SO, soPINString.toCharArray());
        }
        output_.print("Enter the user-PIN and press [return key]: ");
        output_.flush();
        String userPINString;
        if (4 < args.length) {
          userPINString = args[4];
          output_.print(args[4] + "\n");
        } else userPINString = input_.readLine();
        session.initPIN(userPINString.toCharArray());
      }
      session.closeSession();
      output_.println("FINISHED");
      // }

      output_.println(
          "################################################################################");

      tokenInfo = token.getTokenInfo();

      output_.println(
          "################################################################################");
      output_.println("Information of initialized Token:");
      output_.println(tokenInfo);
      output_.println(
          "################################################################################");

    } finally {
      pkcs11Module.finalize(null);
    }
  }
Ejemplo n.º 3
0
  public static void main(String[] args) {
    if (args.length != 3) {
      printUsage();
      System.exit(1);
    }

    try {
      // Security.addProvider(new IAIK());

      Module pkcs11Module = Module.getInstance(args[0]);
      pkcs11Module.initialize(null);

      Slot[] slots = pkcs11Module.getSlotList(Module.SlotRequirement.TOKEN_PRESENT);

      if (slots.length == 0) {
        output_.println("No slot with present token found!");
        System.exit(0);
      }

      Slot selectedSlot = slots[0];
      Token token = selectedSlot.getToken();

      Session session =
          token.openSession(
              Token.SessionType.SERIAL_SESSION,
              Token.SessionReadWriteBehavior.RO_SESSION,
              null,
              null);

      // login user
      // session.login(Session.UserType.USER, args[1].toCharArray());

      output_.println(
          "################################################################################");
      output_.println("generate secret MAC key");

      Mechanism keyMechanism = Mechanism.DES3_KEY_GEN;
      DES3SecretKey secretMACKeyTemplate = new DES3SecretKey();
      secretMACKeyTemplate.getSign().setBooleanValue(Boolean.TRUE);
      secretMACKeyTemplate.getVerify().setBooleanValue(Boolean.TRUE);

      DES3SecretKey secretMACKey =
          (DES3SecretKey) session.generateKey(keyMechanism, secretMACKeyTemplate);

      /*
              GenericSecretKey secretMACKeyTemplate = new GenericSecretKey();
              secretMACKeyTemplate.getSign().setBooleanValue(Boolean.TRUE);
              secretMACKeyTemplate.getVerify().setBooleanValue(Boolean.TRUE);
              secretMACKeyTemplate.getToken().setBooleanValue(Boolean.FALSE);

              // generate some bytes random data that we can use as test key
              byte[] randomData = session.generateRandom(16);

              secretMACKeyTemplate.getValue().setByteArrayValue(randomData);
              secretMACKeyTemplate.getValueLen().setLongValue(new Long(randomData.length));

              GenericSecretKey secretMACKey = (GenericSecretKey) session.createObject(secretMACKeyTemplate);
      */

      output_.println(
          "################################################################################");

      output_.println(
          "################################################################################");
      output_.println("MACing data from file: " + args[2]);

      InputStream dataInputStream = new FileInputStream(args[2]);

      // be sure that your token can process the specified mechanism
      Mechanism signatureMechanism = Mechanism.SHA_1_HMAC;
      // initialize for signing
      session.signInit(signatureMechanism, secretMACKey);

      byte[] dataBuffer = new byte[1024];
      int bytesRead;
      ByteArrayOutputStream streamBuffer = new ByteArrayOutputStream();

      // feed in all data from the input stream
      while ((bytesRead = dataInputStream.read(dataBuffer)) >= 0) {
        streamBuffer.write(dataBuffer, 0, bytesRead);
      }
      Arrays.fill(dataBuffer, (byte) 0); // ensure that no data is left in the memory
      streamBuffer.flush();
      streamBuffer.close();
      dataInputStream.close();
      byte[] rawData = streamBuffer.toByteArray();

      byte[] macValue = session.sign(rawData);

      output_.println("The MAC value is: " + new BigInteger(1, macValue).toString(16));

      output_.println(
          "################################################################################");

      output_.println(
          "################################################################################");
      output_.print("verification of the MAC... ");

      dataInputStream = new FileInputStream(args[2]);

      // initialize for verification
      session.verifyInit(signatureMechanism, secretMACKey);

      streamBuffer = new ByteArrayOutputStream();

      // feed in all data from the input stream
      while ((bytesRead = dataInputStream.read(dataBuffer)) >= 0) {
        streamBuffer.write(dataBuffer, 0, bytesRead);
      }
      Arrays.fill(dataBuffer, (byte) 0); // ensure that no data is left in the memory
      streamBuffer.flush();
      streamBuffer.close();
      dataInputStream.close();
      rawData = streamBuffer.toByteArray();

      try {
        session.verify(rawData, macValue); // throws an exception upon unsuccessful verification
        output_.println("successful");
      } catch (TokenException ex) {
        output_.println("FAILED: " + ex.getMessage());
      }

      output_.println(
          "################################################################################");

      session.closeSession();
      pkcs11Module.finalize(null);

    } catch (Throwable thr) {
      thr.printStackTrace();
    }
  }