/**
  * Test for <code>KeyStoreException(Throwable)</code> constructor Assertion: constructs
  * KeyStoreException when <code>cause</code> is not null
  */
 public void testKeyStoreException05() {
   KeyStoreException tE = new KeyStoreException(tCause);
   if (tE.getMessage() != null) {
     String toS = tCause.toString();
     String getM = tE.getMessage();
     assertTrue("getMessage() should contain ".concat(toS), (getM.indexOf(toS) != -1));
   }
   assertNotNull("getCause() must not return null", tE.getCause());
   assertEquals("getCause() must return ".concat(tCause.toString()), tE.getCause(), tCause);
 }
  /**
   * ִ��http���á�true:�ɹ� false:ʧ��
   *
   * @return boolean
   */
  public boolean call() {

    boolean isRet = false;

    // http
    if (null == this.caFile && null == this.certFile) {
      try {
        this.callHttp();
        isRet = true;
      } catch (IOException e) {
        this.errInfo = e.getMessage();
      }
      return isRet;
    }

    // https
    try {
      this.callHttps();
      isRet = true;
    } catch (UnrecoverableKeyException e) {
      this.errInfo = e.getMessage();
    } catch (KeyManagementException e) {
      this.errInfo = e.getMessage();
    } catch (CertificateException e) {
      this.errInfo = e.getMessage();
    } catch (KeyStoreException e) {
      this.errInfo = e.getMessage();
    } catch (NoSuchAlgorithmException e) {
      this.errInfo = e.getMessage();
    } catch (IOException e) {
      this.errInfo = e.getMessage();
    }

    return isRet;
  }
예제 #3
0
  public static KeyPair getPrivateKey(String alias, char[] password)
      throws FileNotFoundException, IOException, CertificateException {
    try {

      KeyStore ks = KeyStore.getInstance("JKS");

      char[] passPhrase = "123456".toCharArray();
      // BASE64Encoder myB64 = new BASE64Encoder();

      File certificateFile = new File("C:\\Temp\\repositorio.jks");
      ks.load(new FileInputStream(certificateFile), passPhrase);

      // Get private key
      Key key = ks.getKey(alias, password);
      if (key instanceof PrivateKey) {
        // Get certificate of public key
        Certificate cert = ks.getCertificate(alias);

        // Get public key
        PublicKey publicKey = cert.getPublicKey();

        // Return a key pair
        return new KeyPair(publicKey, (PrivateKey) key);
      }
    } catch (UnrecoverableKeyException e) {
      System.out.print(e.getMessage());
    } catch (NoSuchAlgorithmException e) {
      System.out.print(e.getMessage());
    } catch (KeyStoreException e) {
      System.out.print(e.getMessage());
    }
    return null;
  }
 /**
  * Test for <code>KeyStoreException(String)</code> constructor Assertion: constructs
  * KeyStoreException with detail message msg. Parameter <code>msg</code> is not null.
  */
 public void testKeyStoreException02() {
   KeyStoreException tE;
   for (int i = 0; i < msgs.length; i++) {
     tE = new KeyStoreException(msgs[i]);
     assertEquals("getMessage() must return: ".concat(msgs[i]), tE.getMessage(), msgs[i]);
     assertNull("getCause() must return null", tE.getCause());
   }
 }
 private SSLSocketFactory getSSLSocketFactory(String keyStoreName, String password) {
   KeyStore ks = getKeyStore(keyStoreName, password);
   KeyManagerFactory keyManagerFactory = null;
   try {
     keyManagerFactory = KeyManagerFactory.getInstance("SunX509");
     keyManagerFactory.init(ks, password.toCharArray());
     SSLContext context = SSLContext.getInstance("TLS");
     context.init(keyManagerFactory.getKeyManagers(), null, new SecureRandom());
     return context.getSocketFactory();
   } catch (NoSuchAlgorithmException e) {
     logger.error(e.getMessage(), e);
     throw new RuntimeException(e.getMessage(), e);
   } catch (KeyStoreException e) {
     logger.error(e.getMessage(), e);
     throw new RuntimeException(e.getMessage(), e);
   } catch (UnrecoverableKeyException e) {
     logger.error(e.getMessage(), e);
     throw new RuntimeException(e.getMessage(), e);
   } catch (KeyManagementException e) {
     logger.error(e.getMessage(), e);
     throw new RuntimeException(e.getMessage(), e);
   }
 }
  private KeyStore getKeyStore(String keyStoreName, String password) {
    KeyStore ks = null;
    FileInputStream fis = null;
    try {
      ks = KeyStore.getInstance("JKS");
      char[] passwordArray = password.toCharArray();
      fis = new java.io.FileInputStream(keyStoreName);
      ks.load(fis, passwordArray);
      fis.close();

    } catch (CertificateException e) {
      logger.error(e.getMessage(), e);
      throw new RuntimeException(e.getMessage(), e);
    } catch (NoSuchAlgorithmException e) {
      logger.error(e.getMessage(), e);
      throw new RuntimeException(e.getMessage(), e);
    } catch (KeyStoreException e) {
      logger.error(e.getMessage(), e);
      throw new RuntimeException(e.getMessage(), e);
    } catch (FileNotFoundException e) {
      logger.error(e.getMessage(), e);
      throw new RuntimeException(e.getMessage(), e);
    } catch (IOException e) {
      logger.error(e.getMessage(), e);
      throw new RuntimeException(e.getMessage(), e);
    } finally {
      if (fis != null) {
        try {
          fis.close();
        } catch (IOException e) {
          logger.error(e.getMessage(), e);
        }
      }
    }
    return ks;
  }
  private void sslFileTransfer(String filename) {
    try {
      KeyStore trusted = KeyStore.getInstance("BKS");
      // Get the raw resource, which contains the keystore with
      // your trusted certificates (root and any intermediate certs)
      InputStream in =
          context.getResources().openRawResource(tracker.springversion1.R.raw.mykeystore);
      trusted.load(in, "mysecret".toCharArray());

      String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
      TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
      tmf.init(trusted);

      // Create an SSLContext that uses our TrustManager
      SSLContext context = SSLContext.getInstance("TLS");
      context.init(null, tmf.getTrustManagers(), null);

      URL url = new URL(host);
      HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
      urlConnection.setSSLSocketFactory(context.getSocketFactory());

      transfer(urlConnection, filename);

      //			SSLSocketFactory sf = new SSLSocketFactory(trusted);
      //			// Hostname verification from certificate
      //			// http://hc.apache.org/httpcomponents-client-ga/tutorial/html/connmgmt.html#d4e506
      //			sf.setHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER);
      //
      //			Socket sslsocket = sf.createSocket();
      //			sslsocket.setKeepAlive(true);
      //
      //			InetSocketAddress address = new InetSocketAddress(host, 443);
      //			sslsocket.connect(address);
      //
      //			OutputStream sout = sslsocket.getOutputStream();

    } catch (KeyStoreException e) {
      Log.v("mark", "KeyStoreException:" + e.getMessage());
    } catch (NoSuchAlgorithmException e) {
      Log.v("mark", "NoSuchAlgorithmException:" + e.getMessage());
    } catch (CertificateException e) {
      Log.v("mark", "CertificateException:" + e.getMessage());
    } catch (IOException e) {
      Log.v("mark", "IOException:" + e.getMessage());
    } catch (KeyManagementException e) {
      Log.v("mark", "KeyManagementException:" + e.getMessage());
    }
  }
예제 #8
0
  private static String getAlias(KeyStore keyStore) throws IOException {
    String alias = null;

    try {
      Enumeration nombres = keyStore.aliases();
      while (nombres.hasMoreElements()) {
        String tmpAlias = (String) nombres.nextElement();
        if (keyStore.isKeyEntry(tmpAlias)) {
          alias = tmpAlias;
        }
      }
    } catch (KeyStoreException e) {
      throw new IOException("Error: " + e.getMessage());
    }
    return alias;
  }
 /**
  * Test for <code>KeyStoreException(String, Throwable)</code> constructor Assertion: constructs
  * KeyStoreException when <code>cause</code> is not null <code>msg</code> is not null
  */
 public void testKeyStoreException09() {
   KeyStoreException tE;
   for (int i = 0; i < msgs.length; i++) {
     tE = new KeyStoreException(msgs[i], tCause);
     String getM = tE.getMessage();
     String toS = tCause.toString();
     if (msgs[i].length() > 0) {
       assertTrue("getMessage() must contain ".concat(msgs[i]), getM.indexOf(msgs[i]) != -1);
       if (!getM.equals(msgs[i])) {
         assertTrue("getMessage() should contain ".concat(toS), getM.indexOf(toS) != -1);
       }
     }
     assertNotNull("getCause() must not return null", tE.getCause());
     assertEquals("getCause() must return ".concat(tCause.toString()), tE.getCause(), tCause);
   }
 }
예제 #10
0
  private KeyStore getKeyStore() throws CertificateException, IOException {
    KeyStore ks = null;

    try {
      ks = KeyStore.getInstance("PKCS12");
      ks.load(new FileInputStream(this.pathSignature), this.passSignature.toCharArray());
    } catch (KeyStoreException e) {
      throw new IOException("Error: " + e.getMessage());
    } catch (NoSuchAlgorithmException e) {
      throw new IOException("Error: " + e.getMessage());
    } catch (CertificateException e) {
      throw new IOException("Error: " + e.getMessage());
    } catch (IOException e) {
      throw new IOException("Error: " + e.getMessage());
    }
    return ks;
  }
예제 #11
0
  protected void execute() throws CertificateException, IOException {
    KeyStore keyStore = getKeyStore();
    if (keyStore == null) {
      throw new IOException("No se pudo obtener almacen de firma.");
    }
    String alias = getAlias(keyStore);

    X509Certificate certificate = null;
    try {
      certificate = (X509Certificate) keyStore.getCertificate(alias);
      if (certificate == null) {
        throw new IOException("No existe ningún certificado para firmar.");
      }
    } catch (KeyStoreException e1) {
      throw new IOException("Error: " + e1.getMessage());
    }

    PrivateKey privateKey = null;
    KeyStore tmpKs = keyStore;

    try {
      privateKey = (PrivateKey) tmpKs.getKey(alias, this.passSignature.toCharArray());
    } catch (UnrecoverableKeyException e) {
      throw new IOException("No existe clave privada para firmar.");
    } catch (KeyStoreException e) {
      throw new IOException("No existe clave privada para firmar.");
    } catch (NoSuchAlgorithmException e) {
      throw new IOException("No existe clave privada para firmar.");
    }

    Provider provider = keyStore.getProvider();
    DataToSign dataToSign = createDataToSign();
    FirmaXML firma = new FirmaXML();
    Document docSigned = null;

    try {
      Object[] res = firma.signFile(certificate, dataToSign, privateKey, provider);
      docSigned = (Document) res[0];
    } catch (Exception ex) {
      throw new IOException("Error realizando la firma: " + ex.getMessage());
    }
    String filePath = getPathOut() + File.separatorChar + getSignatureFileName();

    saveDocumenteDisk(docSigned, filePath);
  }
  public void onGenerateClicked(View view) {
    try {
      log.debug("Key name {}", getKeyName());
      log.debug("Key type {}", getKeyType());
      log.debug("Key bits {}", getKeyBits());

      KeyChain.getInstance(getActivity())
          .generateKeyAsync(getKeyName(), getKeyType(), getKeyBits());
      getActivity()
          .finish(); // this has to be changed if we are using single activity at some point
    } catch (InvalidInputException e) {
      log.warn("TODO: handle specific cases");
      Toast.makeText(getActivity(), R.string.pk_invalid_input, Toast.LENGTH_SHORT).show();
    } catch (ViewNotFoundException e) {
      log.error(e.getMessage(), e);
    } catch (KeyStoreException e) {
      log.error(e.getMessage(), e);
    }
  }
 /**
  * Test for <code>KeyStoreException(String)</code> constructor Assertion: constructs
  * KeyStoreException when <code>msg</code> is null
  */
 public void testKeyStoreException03() {
   String msg = null;
   KeyStoreException tE = new KeyStoreException(msg);
   assertNull("getMessage() must return null.", tE.getMessage());
   assertNull("getCause() must return null", tE.getCause());
 }
  /** Creates a new SSLSocket bound to ContextWrapper * */
  private Socket createSocket() throws IOException {

    if (_factory == null) {
      Properties attributes = getCurrentProperties();
      StoreUpdateListener listener =
          new StoreUpdateListener() {
            public void loadingNotification(
                String location, String type, Severity level, Exception cause) {
              if (level != Severity.NOTIFICATION) {
                System.out.println(
                    "Error when creating or using SSL socket. Type "
                        + type
                        + " level: "
                        + level
                        + " cause: "
                        + cause.getClass()
                        + ":"
                        + cause.getMessage());
              } else {
                // log successful (re)loading
              }
            }
          };

      ArrayList<StoreUpdateListener> listenerList = new ArrayList<StoreUpdateListener>();
      listenerList.add(listener);

      RevocationParameters revParam =
          new RevocationParameters(
              CrlCheckingMode.REQUIRE,
              new OCSPParametes(),
              false,
              RevocationCheckingOrder.CRL_OCSP);

      String crlCheckingMode = (String) attributes.get(CRL_CHEKING_MODE_STRING);
      if (crlCheckingMode != null) {
        if (crlCheckingMode.equalsIgnoreCase("ifvalid")) {
          revParam =
              new RevocationParameters(
                  CrlCheckingMode.IF_VALID,
                  new OCSPParametes(),
                  false,
                  RevocationCheckingOrder.CRL_OCSP);
        } else {
          if (crlCheckingMode.equalsIgnoreCase("ignore")) {
            revParam =
                new RevocationParameters(
                    CrlCheckingMode.IGNORE,
                    new OCSPParametes(),
                    false,
                    RevocationCheckingOrder.CRL_OCSP);
          }
        }
      }

      ProxySupport proxySupport = ProxySupport.ALLOW;
      String proxySupportString = (String) attributes.get(PROXY_SUPPORT_STRING);
      if (proxySupportString != null) {
        if (proxySupportString.equalsIgnoreCase("no")
            || proxySupportString.equalsIgnoreCase("false")) {
          proxySupport = ProxySupport.DENY;
        }
      }

      ValidatorParams validatorParams = new ValidatorParams(revParam, proxySupport, listenerList);

      String trustStoreLocation = (String) attributes.get(TRUSTSTORE_STRING);
      if (trustStoreLocation == null) {
        throw new IOException(
            "No truststore defined, unable to load CA certificates and thus create SSL socket.");
      }

      String namespaceModeString = (String) attributes.get(NAMESPACE_STRING);
      NamespaceCheckingMode namespaceMode = NamespaceCheckingMode.EUGRIDPMA_AND_GLOBUS;
      if (namespaceModeString != null) {
        if (namespaceModeString.equalsIgnoreCase("no")
            || namespaceModeString.equalsIgnoreCase("false")
            || namespaceModeString.equalsIgnoreCase("off")) {
          namespaceMode = NamespaceCheckingMode.IGNORE;
        } else {
          if (namespaceModeString.equalsIgnoreCase("require")) {
            namespaceMode = NamespaceCheckingMode.EUGRIDPMA_AND_GLOBUS_REQUIRE;
          }
        }
      }

      String intervalString = (String) attributes.get(UPDATEINTERVAL_STRING);
      long intervalMS = 3600000; // update ever hour
      if (intervalString != null) {
        intervalMS = Long.parseLong(intervalString);
      }

      OpensslCertChainValidator validator =
          new OpensslCertChainValidator(
              trustStoreLocation, namespaceMode, intervalMS, validatorParams);

      X509Credential credentials = null;

      String proxyLoc = (String) attributes.get(PROXY_STRING);
      if (proxyLoc != null) {
        try {
          credentials = new PEMCredential(proxyLoc, (char[]) null);
        } catch (KeyStoreException e) {
          throw new IOException("Error opening proxy from " + proxyLoc + ": ", e);
        } catch (CertificateException e) {
          throw new IOException("Error reading proxy from " + proxyLoc + ": ", e);
        }
      } else {

        String hostCertLoc = (String) attributes.get(CERT_STRING);
        if (hostCertLoc == null) {
          throw new IOException(
              "Variable hostcert undefined, cannot start server with SSL/TLS without host certificate.");
        }
        java.security.cert.X509Certificate[] hostCertChain =
            CertificateUtils.loadCertificateChain(new FileInputStream(hostCertLoc), Encoding.PEM);

        String password = (String) attributes.get(PASSWORD_STRING);
        String hostKeyLoc = (String) attributes.get(KEY_STRING);
        if (hostKeyLoc == null) {
          throw new IOException(
              "Variable hostkey undefined, cannot start server with SSL/TLS without host private key.");
        }
        PrivateKey hostKey =
            CertificateUtils.loadPrivateKey(
                new FileInputStream(hostKeyLoc),
                Encoding.PEM,
                password == null ? null : password.toCharArray());

        try {
          credentials = new KeyAndCertCredential(hostKey, hostCertChain);
        } catch (KeyStoreException e) {
          throw new IOException("Error while creating keystore: " + e + ": " + e.getMessage(), e);
        }
      }
      SSLSocketFactory newFactory = SocketFactoryCreator.getSocketFactory(credentials, validator);
      SSLSocket socket = (SSLSocket) newFactory.createSocket();
      return socket;
    } else {
      return _factory.createSocket();
    }
  }
예제 #15
0
  /**
   * Performs test signatures for the specified keys or for all if "all" specified.
   *
   * @param keyStore Loaded keystore to read keys from
   * @param alias Alias of key to test or "all" to test all
   * @param authCode Key password (if used, ie for JKS only)
   * @param signatureProvider Provider for creating the signature
   * @return The results for each key found
   * @throws CryptoTokenOfflineException In case the key could not be used
   */
  public static Collection<KeyTestResult> testKey(
      KeyStore keyStore, String alias, char[] authCode, String signatureProvider)
      throws CryptoTokenOfflineException {
    if (LOG.isDebugEnabled()) {
      LOG.debug("testKey for alias: " + alias);
    }

    final Collection<KeyTestResult> result = new LinkedList<KeyTestResult>();

    try {
      final Enumeration<String> e = keyStore.aliases();
      while (e.hasMoreElements()) {
        final String keyAlias = e.nextElement();
        if (alias.equalsIgnoreCase(ICryptoToken.ALL_KEYS) || alias.equals(keyAlias)) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("checking keyAlias: " + keyAlias);
          }

          if (keyStore.isKeyEntry(keyAlias)) {
            String status;
            String publicKeyHash = null;
            boolean success = false;
            try {
              final PrivateKey privateKey = (PrivateKey) keyStore.getKey(keyAlias, authCode);
              final Certificate entryCert = keyStore.getCertificate(keyAlias);
              if (entryCert != null) {
                final PublicKey publicKey = entryCert.getPublicKey();
                publicKeyHash = createKeyHash(publicKey);
                testSignAndVerify(privateKey, publicKey, signatureProvider);
                success = true;
                status = "";
              } else {
                status = "Not testing keys with alias " + keyAlias + ". No certificate exists.";
              }
            } catch (ClassCastException ce) {
              status = "Not testing keys with alias " + keyAlias + ". Not a private key.";
            } catch (InvalidKeyException ex) {
              LOG.error("Error testing key: " + keyAlias, ex);
              status = ex.getMessage();
            } catch (KeyStoreException ex) {
              LOG.error("Error testing key: " + keyAlias, ex);
              status = ex.getMessage();
            } catch (NoSuchAlgorithmException ex) {
              LOG.error("Error testing key: " + keyAlias, ex);
              status = ex.getMessage();
            } catch (NoSuchProviderException ex) {
              LOG.error("Error testing key: " + keyAlias, ex);
              status = ex.getMessage();
            } catch (SignatureException ex) {
              LOG.error("Error testing key: " + keyAlias, ex);
              status = ex.getMessage();
            } catch (UnrecoverableKeyException ex) {
              LOG.error("Error testing key: " + keyAlias, ex);
              status = ex.getMessage();
            }
            result.add(new KeyTestResult(keyAlias, success, status, publicKeyHash));
          }
        }
      }
    } catch (KeyStoreException ex) {
      throw new CryptoTokenOfflineException(ex);
    }

    if (LOG.isDebugEnabled()) {
      LOG.debug("<testKey");
    }
    return result;
  }
 public void actionPerformed(ActionEvent e) {
   final String S_ProcName = "actionPerformed";
   CFBamSwingMainJFrame mainJFrame = null;
   {
     Container cont = getParent();
     while ((cont != null) && (!(cont instanceof CFBamSwingMainJFrame))) {
       cont = cont.getParent();
     }
     if (cont != null) {
       mainJFrame = (CFBamSwingMainJFrame) cont;
     }
   }
   char pw[] = textKeystorePassword.getPassword();
   String keystorePassword;
   if (pw != null) {
     keystorePassword = new String(pw);
   } else {
     keystorePassword = null;
   }
   CFBamClientConfigurationFile configFile = swingSchema.getClientConfigurationFile();
   String keystoreFileName = configFile.getKeyStore();
   boolean exitApp = false;
   boolean exitForm = false;
   boolean creatingKeystore = false;
   KeyStore keyStore = null;
   File keystoreFile = new File(keystoreFileName);
   if (!keystoreFile.exists()) {
     int userOption = JOptionPane.NO_OPTION;
     try {
       userOption =
           JOptionPane.showOptionDialog(
               null,
               "Would you like to create the keystore \""
                   + keystoreFileName
                   + "\"?\n"
                   + "Selecting No will exit the application so you can edit the client configuration file and restart.",
               "Create Keystore?",
               JOptionPane.YES_NO_OPTION,
               JOptionPane.QUESTION_MESSAGE,
               null,
               null,
               null);
     } catch (HeadlessException x) {
       throw CFLib.getDefaultExceptionFactory()
           .newRuntimeException(
               getClass(), S_ProcName, "Caught HeadlessException -- " + x.getMessage(), x);
     }
     if (userOption == JOptionPane.YES_OPTION) {
       creatingKeystore = true;
       JInternalFrame nextForm = swingSchema.newCreateKeystoreJInternalFrame();
       getDesktopPane().add(nextForm);
       nextForm.setVisible(true);
       nextForm.show();
       Container cont = getParent();
       while ((cont != null) && (!(cont instanceof JInternalFrame))) {
         cont = cont.getParent();
       }
       if (cont != null) {
         JInternalFrame frame = (JInternalFrame) cont;
         try {
           frame.setClosed(true);
         } catch (Exception x) {
         }
       }
     } else {
       exitApp = true;
     }
   } else if (!keystoreFile.isFile()) {
     JOptionPane.showMessageDialog(
         null,
         "The referenced JCEKS keystore \"" + keystoreFileName + "\" is not a file.",
         "Error",
         JOptionPane.ERROR_MESSAGE,
         null);
     exitApp = true;
   } else if (!keystoreFile.canRead()) {
     JOptionPane.showMessageDialog(
         null,
         "Permission denied attempting to access JCEKS keystore \"" + keystoreFileName + "\".",
         "Error",
         JOptionPane.ERROR_MESSAGE,
         null);
     exitApp = true;
   }
   if ((!exitApp) && (!creatingKeystore)) {
     try {
       keyStore = KeyStore.getInstance("jceks");
       char[] caPassword = keystorePassword.toCharArray();
       FileInputStream input = new FileInputStream(keystoreFileName);
       keyStore.load(input, caPassword);
       input.close();
       swingSchema.setKeyStore(keyStore);
       exitForm = true;
     } catch (CertificateException x) {
       keyStore = null;
       JOptionPane.showMessageDialog(
           null,
           "Could not open keystore due to CertificateException -- " + x.getMessage(),
           "Error",
           JOptionPane.ERROR_MESSAGE,
           null);
       exitApp = true;
     } catch (IOException x) {
       keyStore = null;
       JOptionPane.showMessageDialog(
           null,
           "Could not open keystore due to IOException -- " + x.getMessage(),
           "Error",
           JOptionPane.ERROR_MESSAGE,
           null);
     } catch (KeyStoreException x) {
       keyStore = null;
       JOptionPane.showMessageDialog(
           null,
           "Could not open keystore due to KeyStoreException -- " + x.getMessage(),
           "Error",
           JOptionPane.ERROR_MESSAGE,
           null);
       exitApp = true;
     } catch (NoSuchAlgorithmException x) {
       keyStore = null;
       JOptionPane.showMessageDialog(
           null,
           "Could not open keystore due to NoSuchAlgorithmException -- " + x.getMessage(),
           "Error",
           JOptionPane.ERROR_MESSAGE,
           null);
       exitApp = true;
     }
   }
   if (exitApp) {
     swingSchema.setKeyStore(null);
     mainJFrame.exitApplication();
   } else if (exitForm) {
     JInternalFrame nextForm = swingSchema.newOpenDeviceKeyJInternalFrame();
     getDesktopPane().add(nextForm);
     nextForm.setVisible(true);
     nextForm.show();
     Container cont = getParent();
     while ((cont != null) && (!(cont instanceof JInternalFrame))) {
       cont = cont.getParent();
     }
     if (cont != null) {
       JInternalFrame frame = (JInternalFrame) cont;
       try {
         frame.setClosed(true);
       } catch (Exception x) {
       }
     }
   }
 }
예제 #17
0
  private AlfrescoRuntimeException signFile(
      final NodeRef nodeRefToSign,
      final DigitalSigningDTO signingDTO,
      final File alfTempDir,
      final String alias,
      final KeyStore ks,
      final PrivateKey key,
      final Certificate[] chain) {
    final String fileNameToSign = fileFolderService.getFileInfo(nodeRefToSign).getName();

    File fileConverted = null;
    File tempDir = null;
    try {
      ContentReader fileToSignContentReader = getReader(nodeRefToSign);

      if (fileToSignContentReader != null) {
        String newName = null;

        // Check if document is PDF or transform it
        if (!MimetypeMap.MIMETYPE_PDF.equals(fileToSignContentReader.getMimetype())) {
          // Transform document in PDF document
          final ContentTransformer tranformer =
              contentTransformerRegistry.getTransformer(
                  fileToSignContentReader.getMimetype(),
                  fileToSignContentReader.getSize(),
                  MimetypeMap.MIMETYPE_PDF,
                  new TransformationOptions());

          if (tranformer != null) {

            tempDir = new File(alfTempDir.getPath() + File.separatorChar + nodeRefToSign.getId());
            if (tempDir != null) {
              tempDir.mkdir();
              fileConverted =
                  new File(tempDir, fileNameToSign + "_" + System.currentTimeMillis() + ".pdf");
              if (fileConverted != null) {
                final ContentWriter newDoc = new FileContentWriter(fileConverted);
                if (newDoc != null) {
                  newDoc.setMimetype(MimetypeMap.MIMETYPE_PDF);
                  tranformer.transform(fileToSignContentReader, newDoc);
                  fileToSignContentReader = new FileContentReader(fileConverted);

                  final String originalName =
                      (String) nodeService.getProperty(nodeRefToSign, ContentModel.PROP_NAME);

                  newName = originalName.substring(0, originalName.lastIndexOf(".")) + ".pdf";
                }
              }
            }
          } else {
            log.error(
                "["
                    + fileNameToSign
                    + "] No suitable converter found to convert the document in PDF.");
            return new AlfrescoRuntimeException(
                "["
                    + fileNameToSign
                    + "] No suitable converter found to convert the document in PDF.");
          }
        }

        // Convert PDF in PDF/A format
        final File pdfAFile = convertPdfToPdfA(fileToSignContentReader.getContentInputStream());

        final PdfReader reader = new PdfReader(new FileInputStream(pdfAFile));

        if (nodeRefToSign != null) {
          tempDir = new File(alfTempDir.getPath() + File.separatorChar + nodeRefToSign.getId());
          if (tempDir != null) {
            tempDir.mkdir();
            final File file = new File(tempDir, fileNameToSign);

            if (file != null) {
              final FileOutputStream fout = new FileOutputStream(file);
              final PdfStamper stp = PdfStamper.createSignature(reader, fout, '\0');

              if (stp != null) {
                final PdfSignatureAppearance sap = stp.getSignatureAppearance();
                if (sap != null) {
                  sap.setCrypto(key, chain, null, PdfSignatureAppearance.WINCER_SIGNED);
                  sap.setReason(signingDTO.getSignReason());
                  sap.setLocation(signingDTO.getSignLocation());
                  sap.setContact(signingDTO.getSignContact());
                  sap.setCertificationLevel(PdfSignatureAppearance.CERTIFIED_NO_CHANGES_ALLOWED);
                  sap.setImageScale(1);

                  // digital signature
                  if (signingDTO.getSigningField() != null
                      && !signingDTO.getSigningField().trim().equalsIgnoreCase("")) {
                    Image img = null;
                    if (signingDTO.getImage() != null) {
                      final ContentReader imageContentReader = getReader(signingDTO.getImage());
                      final AcroFields af = reader.getAcroFields();
                      if (af != null) {
                        final List<FieldPosition> positions =
                            af.getFieldPositions(signingDTO.getSigningField());
                        if (positions != null
                            && positions.size() > 0
                            && positions.get(0) != null
                            && positions.get(0).position != null) {
                          final BufferedImage newImg =
                              scaleImage(
                                  ImageIO.read(imageContentReader.getContentInputStream()),
                                  BufferedImage.TYPE_INT_RGB,
                                  Float.valueOf(positions.get(0).position.getWidth()).intValue(),
                                  Float.valueOf(positions.get(0).position.getHeight()).intValue());
                          img = Image.getInstance(newImg, null);
                        } else {
                          log.error(
                              "["
                                  + fileNameToSign
                                  + "] The field '"
                                  + signingDTO.getSigningField()
                                  + "' doesn't exist in the document.");
                          return new AlfrescoRuntimeException(
                              "["
                                  + fileNameToSign
                                  + "] The field '"
                                  + signingDTO.getSigningField()
                                  + "' doesn't exist in the document.");
                        }
                      }
                      if (img == null) {
                        img =
                            Image.getInstance(
                                ImageIO.read(imageContentReader.getContentInputStream()), null);
                      }
                      sap.setImage(img);
                    }
                    sap.setVisibleSignature(signingDTO.getSigningField());
                  } else {
                    int pageToSign = 1;
                    if (DigitalSigningDTO.PAGE_LAST.equalsIgnoreCase(
                        signingDTO.getPages().trim())) {
                      pageToSign = reader.getNumberOfPages();
                    } else if (DigitalSigningDTO.PAGE_SPECIFIC.equalsIgnoreCase(
                        signingDTO.getPages().trim())) {
                      if (signingDTO.getPageNumber() > 0
                          && signingDTO.getPageNumber() <= reader.getNumberOfPages()) {
                        pageToSign = signingDTO.getPageNumber();
                      } else {
                        throw new AlfrescoRuntimeException("Page number is out of bound.");
                      }
                    }
                    if (signingDTO.getImage() != null) {
                      final ContentReader imageContentReader = getReader(signingDTO.getImage());
                      // Resize image
                      final BufferedImage newImg =
                          scaleImage(
                              ImageIO.read(imageContentReader.getContentInputStream()),
                              BufferedImage.TYPE_INT_RGB,
                              signingDTO.getSignWidth(),
                              signingDTO.getSignHeight());
                      final Image img = Image.getInstance(newImg, null);
                      sap.setImage(img);
                    }
                    if (signingDTO.getPosition() != null
                        && !DigitalSigningDTO.POSITION_CUSTOM.equalsIgnoreCase(
                            signingDTO.getPosition().trim())) {
                      final Rectangle pageRect = reader.getPageSizeWithRotation(1);
                      sap.setVisibleSignature(
                          positionSignature(
                              signingDTO.getPosition(),
                              pageRect,
                              signingDTO.getSignWidth(),
                              signingDTO.getSignHeight(),
                              signingDTO.getxMargin(),
                              signingDTO.getyMargin()),
                          pageToSign,
                          null);
                    } else {
                      sap.setVisibleSignature(
                          new Rectangle(
                              signingDTO.getLocationX(),
                              signingDTO.getLocationY(),
                              signingDTO.getLocationX() + signingDTO.getSignWidth(),
                              signingDTO.getLocationY() - signingDTO.getSignHeight()),
                          pageToSign,
                          null);
                    }
                  }
                  stp.close();

                  NodeRef destinationNode = null;
                  NodeRef originalDoc = null;
                  boolean addAsNewVersion = false;
                  if (signingDTO.getDestinationFolder() == null) {
                    destinationNode = nodeRefToSign;
                    nodeService.addAspect(destinationNode, ContentModel.ASPECT_VERSIONABLE, null);
                    addAsNewVersion = true;
                  } else {
                    originalDoc = nodeRefToSign;
                    destinationNode =
                        createDestinationNode(
                            file.getName(), signingDTO.getDestinationFolder(), nodeRefToSign);
                  }

                  if (destinationNode != null) {

                    final ContentWriter writer =
                        contentService.getWriter(destinationNode, ContentModel.PROP_CONTENT, true);
                    if (writer != null) {
                      writer.setEncoding(fileToSignContentReader.getEncoding());
                      writer.setMimetype("application/pdf");
                      writer.putContent(file);
                      file.delete();

                      if (fileConverted != null) {
                        fileConverted.delete();
                      }

                      nodeService.addAspect(
                          destinationNode,
                          SigningModel.ASPECT_SIGNED,
                          new HashMap<QName, Serializable>());
                      nodeService.setProperty(
                          destinationNode, SigningModel.PROP_REASON, signingDTO.getSignReason());
                      nodeService.setProperty(
                          destinationNode,
                          SigningModel.PROP_LOCATION,
                          signingDTO.getSignLocation());
                      nodeService.setProperty(
                          destinationNode, SigningModel.PROP_SIGNATUREDATE, new java.util.Date());
                      nodeService.setProperty(
                          destinationNode,
                          SigningModel.PROP_SIGNEDBY,
                          AuthenticationUtil.getRunAsUser());

                      if (newName != null) {
                        nodeService.setProperty(destinationNode, ContentModel.PROP_NAME, newName);
                      }

                      final X509Certificate c = (X509Certificate) ks.getCertificate(alias);
                      nodeService.setProperty(
                          destinationNode, SigningModel.PROP_VALIDITY, c.getNotAfter());
                      nodeService.setProperty(
                          destinationNode, SigningModel.PROP_ORIGINAL_DOC, originalDoc);

                      if (!addAsNewVersion) {
                        if (!nodeService.hasAspect(originalDoc, SigningModel.ASPECT_ORIGINAL_DOC)) {
                          nodeService.addAspect(
                              originalDoc,
                              SigningModel.ASPECT_ORIGINAL_DOC,
                              new HashMap<QName, Serializable>());
                        }
                        nodeService.createAssociation(
                            originalDoc, destinationNode, SigningModel.PROP_RELATED_DOC);
                      }
                    }
                  } else {
                    log.error("[" + fileNameToSign + "] Destination node is not a valid NodeRef.");
                    return new AlfrescoRuntimeException(
                        "[" + fileNameToSign + "] Destination node is not a valid NodeRef.");
                  }
                } else {
                  log.error("[" + fileNameToSign + "] Unable to get PDF appearance signature.");
                  return new AlfrescoRuntimeException(
                      "[" + fileNameToSign + "] Unable to get PDF appearance signature.");
                }
              } else {
                log.error("[" + fileNameToSign + "] Unable to create PDF signature.");
                return new AlfrescoRuntimeException(
                    "[" + fileNameToSign + "] Unable to create PDF signature.");
              }
            }
          }
        } else {
          log.error("[" + fileNameToSign + "] Unable to get document to sign content.");
          return new AlfrescoRuntimeException(
              "[" + fileNameToSign + "] Unable to get document to sign content.");
        }

        if (pdfAFile != null) {
          pdfAFile.delete();
        }

        return null;

      } else {
        log.error("[" + fileNameToSign + "] The document has no content.");
        return new AlfrescoRuntimeException(
            "[" + fileNameToSign + "] The document has no content.");
      }
    } catch (KeyStoreException e) {
      log.error("[" + fileNameToSign + "] " + e);
      return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + e.getMessage(), e);
    } catch (ContentIOException e) {
      log.error("[" + fileNameToSign + "] " + e);
      return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + e.getMessage(), e);
    } catch (IOException e) {
      log.error("[" + fileNameToSign + "] " + e);
      return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + e.getMessage(), e);
    } catch (DocumentException e) {
      log.error("[" + fileNameToSign + "] " + e);
      return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + e.getMessage(), e);
    } finally {
      if (tempDir != null) {
        try {
          tempDir.delete();
        } catch (Exception ex) {
          log.error("[" + fileNameToSign + "] " + ex);
          return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + ex.getMessage(), ex);
        }
      }
    }
  }
예제 #18
0
  /**
   * Sign file.
   *
   * @param signingDTO sign informations
   * @param pdfSignedFile signed pdf returned
   */
  public void sign(final DigitalSigningDTO signingDTO) {
    if (signingDTO != null) {

      try {
        Security.addProvider(new BouncyCastleProvider());
        final File alfTempDir = TempFileProvider.getTempDir();

        if (alfTempDir != null) {
          final String keyType =
              (String) nodeService.getProperty(signingDTO.getKeyFile(), SigningModel.PROP_KEYTYPE);

          if (SigningConstants.KEY_TYPE_X509.equals(keyType)) {
            // Sign the file
            final KeyStore ks = KeyStore.getInstance("pkcs12");
            final ContentReader keyContentReader = getReader(signingDTO.getKeyFile());

            if (keyContentReader != null && ks != null && signingDTO.getKeyPassword() != null) {

              final List<AlfrescoRuntimeException> errors =
                  new ArrayList<AlfrescoRuntimeException>();

              // Get crypted secret key and decrypt it
              final Serializable encryptedPropertyValue =
                  nodeService.getProperty(
                      signingDTO.getKeyFile(), SigningModel.PROP_KEYCRYPTSECRET);
              final Serializable decryptedPropertyValue =
                  metadataEncryptor.decrypt(
                      SigningModel.PROP_KEYCRYPTSECRET, encryptedPropertyValue);

              // Decrypt key content
              InputStream decryptedKeyContent;
              try {
                decryptedKeyContent =
                    CryptUtils.decrypt(
                        decryptedPropertyValue.toString(),
                        keyContentReader.getContentInputStream());
              } catch (Throwable e) {
                log.error(e);
                throw new AlfrescoRuntimeException(e.getMessage(), e);
              }

              ks.load(
                  new ByteArrayInputStream(IOUtils.toByteArray(decryptedKeyContent)),
                  signingDTO.getKeyPassword().toCharArray());

              final String alias =
                  (String)
                      nodeService.getProperty(signingDTO.getKeyFile(), SigningModel.PROP_KEYALIAS);

              final PrivateKey key =
                  (PrivateKey) ks.getKey(alias, signingDTO.getKeyPassword().toCharArray());
              final Certificate[] chain = ks.getCertificateChain(alias);

              final Iterator<NodeRef> itFilesToSign = signingDTO.getFilesToSign().iterator();
              while (itFilesToSign.hasNext()) {
                final NodeRef nodeRefToSign = itFilesToSign.next();
                final AlfrescoRuntimeException exception =
                    signFile(nodeRefToSign, signingDTO, alfTempDir, alias, ks, key, chain);
                if (exception != null) {
                  // Error on the file process
                  errors.add(exception);
                }
              }

              if (errors != null && errors.size() > 0) {
                final StringBuffer allErrors = new StringBuffer();
                final Iterator<AlfrescoRuntimeException> itErrors = errors.iterator();
                if (errors.size() > 1) {
                  allErrors.append("\n");
                }
                while (itErrors.hasNext()) {
                  final AlfrescoRuntimeException alfrescoRuntimeException = itErrors.next();
                  allErrors.append(alfrescoRuntimeException.getMessage());
                  if (itErrors.hasNext()) {
                    allErrors.append("\n");
                  }
                }
                throw new RuntimeException(allErrors.toString());
              }

            } else {
              log.error("Unable to get key content, key type or key password.");
              throw new AlfrescoRuntimeException(
                  "Unable to get key content, key type or key password.");
            }
          }
        } else {
          log.error("Unable to get temporary directory.");
          throw new AlfrescoRuntimeException("Unable to get temporary directory.");
        }
      } catch (KeyStoreException e) {
        log.error(e);
        throw new AlfrescoRuntimeException(e.getMessage(), e);
      } catch (NoSuchAlgorithmException e) {
        log.error(e);
        throw new AlfrescoRuntimeException(e.getMessage(), e);
      } catch (CertificateException e) {
        log.error(e);
        throw new AlfrescoRuntimeException(e.getMessage(), e);
      } catch (IOException e) {
        log.error(e);
        throw new AlfrescoRuntimeException(e.getMessage(), e);
      } catch (UnrecoverableKeyException e) {
        log.error(e);
        throw new AlfrescoRuntimeException(e.getMessage(), e);
      }
    } else {
      log.error("No object with signing informations.");
      throw new AlfrescoRuntimeException("No object with signing informations.");
    }
  }
예제 #19
0
  public List<VerifyResultDTO> verifySign(final VerifyingDTO verifyingDTO) {
    final List<VerifyResultDTO> result = new ArrayList<VerifyResultDTO>();
    try {
      if (verifyingDTO != null) {
        final String keyType =
            (String) nodeService.getProperty(verifyingDTO.getKeyFile(), SigningModel.PROP_KEYTYPE);

        final KeyStore ks = KeyStore.getInstance(keyType);
        final ContentReader keyContentReader = getReader(verifyingDTO.getKeyFile());
        if (keyContentReader != null && ks != null && verifyingDTO.getKeyPassword() != null) {

          // Get crypted secret key and decrypt it
          final Serializable encryptedPropertyValue =
              nodeService.getProperty(verifyingDTO.getKeyFile(), SigningModel.PROP_KEYCRYPTSECRET);
          final Serializable decryptedPropertyValue =
              metadataEncryptor.decrypt(SigningModel.PROP_KEYCRYPTSECRET, encryptedPropertyValue);

          // Decrypt key content
          final InputStream decryptedKeyContent =
              CryptUtils.decrypt(
                  decryptedPropertyValue.toString(), keyContentReader.getContentInputStream());

          ks.load(
              new ByteArrayInputStream(IOUtils.toByteArray(decryptedKeyContent)),
              verifyingDTO.getKeyPassword().toCharArray());

          final ContentReader fileToVerifyContentReader = getReader(verifyingDTO.getFileToVerify());
          if (fileToVerifyContentReader != null) {
            final PdfReader reader =
                new PdfReader(fileToVerifyContentReader.getContentInputStream());
            if (reader != null) {
              final AcroFields af = reader.getAcroFields();
              if (af != null) {
                final ArrayList<String> names = af.getSignatureNames();
                if (names != null) {
                  for (int k = 0; k < names.size(); ++k) {
                    final VerifyResultDTO verifyResultDTO = new VerifyResultDTO();
                    final String name = (String) names.get(k);
                    verifyResultDTO.setName(name);
                    verifyResultDTO.setSignatureCoversWholeDocument(
                        af.signatureCoversWholeDocument(name));
                    verifyResultDTO.setRevision(af.getRevision(name));
                    verifyResultDTO.setTotalRevision(af.getTotalRevisions());

                    final PdfPKCS7 pk = af.verifySignature(name);
                    if (pk != null) {
                      final Calendar cal = pk.getSignDate();
                      final Certificate[] pkc = pk.getCertificates();
                      Object fails[] = PdfPKCS7.verifyCertificates(pkc, ks, null, cal);
                      if (fails == null) {
                        verifyResultDTO.setIsSignValid(true);
                      } else {
                        verifyResultDTO.setIsSignValid(false);
                        verifyResultDTO.setFailReason(fails[1]);
                      }
                      verifyResultDTO.setSignSubject(
                          PdfPKCS7.getSubjectFields(pk.getSigningCertificate()).toString());
                      verifyResultDTO.setIsDocumentModified(!pk.verify());
                      verifyResultDTO.setSignDate(pk.getSignDate());
                      verifyResultDTO.setSignLocation(pk.getLocation());
                      verifyResultDTO.setSignInformationVersion(pk.getSigningInfoVersion());
                      verifyResultDTO.setSignReason(pk.getReason());
                      verifyResultDTO.setSignVersion(pk.getVersion());
                      verifyResultDTO.setSignName(pk.getSignName());

                      result.add(verifyResultDTO);
                    } else {
                      log.error("Unable to verify signature.");
                      throw new AlfrescoRuntimeException("Unable to verify signature.");
                    }
                  }
                } else {
                  log.error("Unable to get signature names.");
                  throw new AlfrescoRuntimeException("Unable to get signature names.");
                }
              } else {
                log.error("Unable to get PDF fields.");
                throw new AlfrescoRuntimeException("Unable to get PDF fields.");
              }
            }
          } else {
            log.error("Unable to get document to verify content.");
            throw new AlfrescoRuntimeException("Unable to get document to verify content.");
          }
        } else {
          log.error("Unable to get key content, key type or key password.");
          throw new AlfrescoRuntimeException(
              "Unable to get key content, key type or key password.");
        }
      } else {
        log.error("No object with verification informations.");
        throw new AlfrescoRuntimeException("No object with verification informations.");
      }
    } catch (KeyStoreException e) {
      log.error(e);
      throw new AlfrescoRuntimeException(e.getMessage(), e);
    } catch (ContentIOException e) {
      log.error(e);
      throw new AlfrescoRuntimeException(e.getMessage(), e);
    } catch (NoSuchAlgorithmException e) {
      log.error(e);
      throw new AlfrescoRuntimeException(e.getMessage(), e);
    } catch (CertificateException e) {
      log.error(e);
      throw new AlfrescoRuntimeException(e.getMessage(), e);
    } catch (IOException e) {
      log.error(e);
      throw new AlfrescoRuntimeException(e.getMessage(), e);
    } catch (GeneralSecurityException e) {
      log.error(e);
      throw new AlfrescoRuntimeException(e.getMessage(), e);
    } catch (Throwable e) {
      log.error(e);
      throw new AlfrescoRuntimeException(e.getMessage(), e);
    }

    return result;
  }
  @Override
  public void contextInitialized(ServletContextEvent arg0) {
    final String S_ProcName = "contextInitialized";

    Properties props = System.getProperties();
    if (null == CFBamSchemaPool.getSchemaPool()) {
      try {
        Context ctx = new InitialContext();
        String poolClassName = (String) ctx.lookup("java:comp/env/CFBam24PoolClass");
        if ((poolClassName == null) || (poolClassName.length() <= 0)) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(), S_ProcName, 0, "JNDI lookup for CFBam24PoolClass");
        }

        Class poolClass = Class.forName(poolClassName);
        if (poolClass == null) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(),
                  S_ProcName,
                  0,
                  "CFBam24PoolClass \"" + poolClassName + "\" not found.");
        }

        Object obj = poolClass.newInstance();
        if (obj instanceof CFBamSchemaPool) {
          CFBamSchemaPool newPool = (CFBamSchemaPool) obj;
          newPool.setConfigurationFile(null);
          newPool.setJndiName("java:comp/env/CFBam24Connection");
          CFBamSchemaPool.setSchemaPool(newPool);
        } else {
          throw CFLib.getDefaultExceptionFactory()
              .newRuntimeException(
                  getClass(), S_ProcName, "Problems constructing an instance of " + poolClassName);
        }

        String smtpHost = (String) ctx.lookup("java:comp/env/CFBam24SmtpHost");
        if ((smtpHost == null) || (smtpHost.length() <= 0)) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(), S_ProcName, 0, "JNDI lookup for CFBam24SmtpHost");
        }
        props.setProperty("mail.smtp.host", smtpHost);

        String smtpStartTLS = (String) ctx.lookup("java:comp/env/CFBam24SmtpStartTLS");
        if ((smtpHost == null) || (smtpHost.length() <= 0)) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(), S_ProcName, 0, "JNDI lookup for CFBam24SmtpStartTLS");
        }
        props.setProperty("mail.smtp.starttls.enable", smtpStartTLS);

        String smtpSocketFactoryClass =
            (String) ctx.lookup("java:comp/env/CFBam24SmtpSocketFactoryClass");
        if ((smtpSocketFactoryClass == null) || (smtpSocketFactoryClass.length() <= 0)) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(), S_ProcName, 0, "JNDI lookup for CFBam24SmtpSocketFactoryClass");
        }
        props.setProperty("mail.smtp.socketFactory.class", smtpSocketFactoryClass);

        props.setProperty("mail.smtp.socketFactory.fallback", "false");

        String smtpPort = (String) ctx.lookup("java:comp/env/CFBam24SmtpPort");
        if ((smtpPort == null) || (smtpPort.length() <= 0)) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(), S_ProcName, 0, "JNDI lookup for CFBam24SmtpPort");
        }
        props.setProperty("mail.smtp.port", smtpPort);
        props.setProperty("mail.smtp.socketFactory.port", smtpPort);

        props.setProperty("mail.smtps.auth", "true");

        props.put("mail.smtps.quitwait", "false");

        String smtpEmailFrom = (String) ctx.lookup("java:comp/env/CFBam24SmtpEmailFrom");
        if ((smtpEmailFrom == null) || (smtpEmailFrom.length() <= 0)) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(), S_ProcName, 0, "JNDI lookup for CFBam24SmtpEmailFrom");
        }

        smtpUsername = (String) ctx.lookup("java:comp/env/CFBam24SmtpUsername");
        if ((smtpUsername == null) || (smtpUsername.length() <= 0)) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(), S_ProcName, 0, "JNDI lookup for CFBam24SmtpUsername");
        }

        smtpPassword = (String) ctx.lookup("java:comp/env/CFBam24SmtpPassword");
        if ((smtpPassword == null) || (smtpPassword.length() <= 0)) {
          throw CFLib.getDefaultExceptionFactory()
              .newNullArgumentException(
                  getClass(), S_ProcName, 0, "JNDI lookup for CFBam24SmtpPassword");
        }

        String serverKeyStore;
        try {
          serverKeyStore = (String) ctx.lookup("java:comp/env/CFBam24ServerKeyStore");
        } catch (NamingException e) {
          serverKeyStore = null;
        }

        String keyStorePassword;
        try {
          keyStorePassword = (String) ctx.lookup("java:comp/env/CFBam24KeyStorePassword");
        } catch (NamingException e) {
          keyStorePassword = null;
        }

        String keyName;
        try {
          keyName = (String) ctx.lookup("java:comp/env/CFBam24KeyName");
        } catch (NamingException e) {
          keyName = null;
        }

        String keyPassword;
        try {
          keyPassword = (String) ctx.lookup("java:comp/env/CFBam24KeyPassword");
        } catch (NamingException e) {
          keyPassword = null;
        }

        if (((serverKeyStore != null) && (serverKeyStore.length() > 0))
            && (keyStorePassword != null)
            && ((keyName != null) && (keyName.length() > 0))
            && (keyPassword != null)) {
          KeyStore keyStore = null;
          File keystoreFile = new File(serverKeyStore);
          if (!keystoreFile.exists()) {
            throw CFLib.getDefaultExceptionFactory()
                .newUsageException(
                    getClass(),
                    S_ProcName,
                    "CFBam24ServerKeyStore file \"" + serverKeyStore + "\" does not exist.");
          } else if (!keystoreFile.isFile()) {
            throw CFLib.getDefaultExceptionFactory()
                .newUsageException(
                    getClass(),
                    S_ProcName,
                    "CFBam24ServerKeyStore file \"" + serverKeyStore + "\" is not a file.");
          } else if (!keystoreFile.canRead()) {
            throw CFLib.getDefaultExceptionFactory()
                .newUsageException(
                    getClass(),
                    S_ProcName,
                    "Permission denied attempting to read CFBam24ServerKeyStore file \""
                        + serverKeyStore
                        + "\".");
          }

          try {
            keyStore = KeyStore.getInstance("jceks");
            char[] caPassword = keyStorePassword.toCharArray();
            FileInputStream input = new FileInputStream(serverKeyStore);
            keyStore.load(input, caPassword);
            input.close();
            Certificate publicKeyCertificate = keyStore.getCertificate(keyName);
            if (publicKeyCertificate == null) {
              throw CFLib.getDefaultExceptionFactory()
                  .newUsageException(
                      getClass(),
                      S_ProcName,
                      "Could not read CFBam24KeyName \""
                          + keyName
                          + "\" from CFBam24ServerKeyStore file \""
                          + serverKeyStore
                          + "\".");
            }
            publicKey = publicKeyCertificate.getPublicKey();
            char[] caKeyPassword = keyPassword.toCharArray();
            Key key = keyStore.getKey(keyName, caKeyPassword);
            if (key instanceof PrivateKey) {
              privateKey = (PrivateKey) key;
            } else {
              throw CFLib.getDefaultExceptionFactory()
                  .newUnsupportedClassException(getClass(), S_ProcName, "key", key, "PrivateKey");
            }

            getServerInfo();
          } catch (CertificateException x) {
            publicKey = null;
            privateKey = null;
            throw CFLib.getDefaultExceptionFactory()
                .newRuntimeException(
                    getClass(),
                    S_ProcName,
                    "Could not open keystore due to CertificateException -- " + x.getMessage(),
                    x);
          } catch (IOException x) {
            publicKey = null;
            privateKey = null;
            throw CFLib.getDefaultExceptionFactory()
                .newRuntimeException(
                    getClass(),
                    S_ProcName,
                    "Could not open keystore due to IOException -- " + x.getMessage(),
                    x);
          } catch (KeyStoreException x) {
            publicKey = null;
            privateKey = null;
            throw CFLib.getDefaultExceptionFactory()
                .newRuntimeException(
                    getClass(),
                    S_ProcName,
                    "Could not open keystore due to KeyStoreException -- " + x.getMessage(),
                    x);
          } catch (NoSuchAlgorithmException x) {
            publicKey = null;
            privateKey = null;
            throw CFLib.getDefaultExceptionFactory()
                .newRuntimeException(
                    getClass(),
                    S_ProcName,
                    "Could not open keystore due to NoSuchAlgorithmException -- " + x.getMessage(),
                    x);
          } catch (UnrecoverableKeyException x) {
            publicKey = null;
            privateKey = null;
            throw CFLib.getDefaultExceptionFactory()
                .newRuntimeException(
                    getClass(),
                    S_ProcName,
                    "Could not access key due to UnrecoverableKeyException -- " + x.getMessage(),
                    x);
          } catch (RuntimeException x) {
            publicKey = null;
            privateKey = null;
            throw x;
          }
        } else if ((serverKeyStore != null)
            || (keyStorePassword != null)
            || (keyName != null)
            || (keyPassword != null)) {
          publicKey = null;
          privateKey = null;
          throw CFLib.getDefaultExceptionFactory()
              .newUsageException(
                  getClass(),
                  S_ProcName,
                  "All or none of CFBam24ServerKeyStore, "
                      + "CFBam24KeyStorePassword, "
                      + "CFBam24KeyName, and "
                      + "CFBam24KeyPassword must be configured");
        } else {
          getServerInfo();
          try {
            serverInfo.initServerKeys();
          } catch (Exception x) {
            throw CFLib.getDefaultExceptionFactory()
                .newRuntimeException(
                    getClass(),
                    S_ProcName,
                    "Caught "
                        + x.getClass().getName()
                        + " during initServerKeys() -- "
                        + x.getMessage(),
                    x);
          }
        }
      } catch (ClassNotFoundException e) {
        publicKey = null;
        privateKey = null;
        throw CFLib.getDefaultExceptionFactory()
            .newRuntimeException(
                getClass(), S_ProcName, "Caught ClassNotFoundException -- " + e.getMessage(), e);
      } catch (IllegalAccessException e) {
        publicKey = null;
        privateKey = null;
        throw CFLib.getDefaultExceptionFactory()
            .newRuntimeException(
                getClass(),
                S_ProcName,
                "Caught IllegalAccessException trying to construct newInstance() -- "
                    + e.getMessage(),
                e);
      } catch (InstantiationException e) {
        publicKey = null;
        privateKey = null;
        throw CFLib.getDefaultExceptionFactory()
            .newRuntimeException(
                getClass(),
                S_ProcName,
                "Caught InstantiationException trying to construct newInstance() -- "
                    + e.getMessage(),
                e);
      } catch (NamingException e) {
        publicKey = null;
        privateKey = null;
        throw CFLib.getDefaultExceptionFactory()
            .newRuntimeException(
                getClass(), S_ProcName, "Caught NamingException -- " + e.getMessage(), e);
      }
    }
  }
 /**
  * Test for <code>KeyStoreException()</code> constructor Assertion: constructs KeyStoreException
  * with no detail message
  */
 public void testKeyStoreException01() {
   KeyStoreException tE = new KeyStoreException();
   assertNull("getMessage() must return null.", tE.getMessage());
   assertNull("getCause() must return null", tE.getCause());
 }
예제 #22
0
  /**
   * parse arguments
   *
   * @param args arguments
   */
  private void parseArguments(String[] args) {
    // parse arguments
    int z = 0;
    while (z < args.length) {
      if (args[z].startsWith("-h") || args[z].startsWith("--help")) {
        printUsage();
        System.exit(0);
      } else if (args[z].startsWith("-p=") || args[z].startsWith("--port=")) {
        String value = args[z].substring(args[z].indexOf('=') + 1);
        try {
          serverPort = Integer.parseInt(value);
        } catch (NumberFormatException exception) {
          throw new Error(
              "Invalid value '"
                  + value
                  + "' for option --port (error: "
                  + exception.getMessage()
                  + ")!");
        }
        z += 1;
      } else if (args[z].equals("-p") || args[z].equals("--port")) {
        if ((z + 1) >= args.length) {
          throw new Error("Expected value for option --port!");
        }
        try {
          serverPort = Integer.parseInt(args[z + 1]);
        } catch (NumberFormatException exception) {
          throw new Error(
              "Invalid value '"
                  + args[z + 1]
                  + "' for option --port (error: "
                  + exception.getMessage()
                  + ")!");
        }
        z += 2;
      } else if (args[z].startsWith("--tls-port=")) {
        String value = args[z].substring(args[z].indexOf('=') + 1);
        try {
          serverTLSPort = Integer.parseInt(value);
        } catch (NumberFormatException exception) {
          throw new Error(
              "Invalid value '"
                  + value
                  + "' for option --tls-port (error: "
                  + exception.getMessage()
                  + ")!");
        }
        z += 1;
      } else if (args[z].equals("--tls-port")) {
        if ((z + 1) >= args.length) {
          throw new Error("Expected value for option --tls-port!");
        }
        try {
          serverTLSPort = Integer.parseInt(args[z + 1]);
        } catch (NumberFormatException exception) {
          throw new Error(
              "Invalid value '"
                  + args[z + 1]
                  + "' for option --tls-port (error: "
                  + exception.getMessage()
                  + ")!");
        }
        z += 2;
      } else if (args[z].startsWith("--login-dialog=")) {
        String value = args[z].substring(args[z].indexOf('=') + 1).toLowerCase();
        if (value.equals("yes") || value.equals("on") || value.equals("1")) {
          loginDialogFlag = true;
        } else if (value.equals("no") || value.equals("off") || value.equals("0")) {
          loginDialogFlag = false;
        } else {
          throw new Error(
              "Invalid value '"
                  + value
                  + "' for option --login-dialog (error: expected yes,on,1 or no,off,0)!");
        }
        z += 1;
      } else if (args[z].equals("--login-dialog")) {
        loginDialogFlag = true;
        z += 1;
      } else if (args[z].startsWith("--key-file=")) {
        serverKeyFileName = args[z].substring(args[z].indexOf('=') + 1);
        z += 1;
      } else if (args[z].equals("--key-file")) {
        if ((z + 1) >= args.length) {
          throw new Error("Expected value for option --key-file!");
        }
        serverKeyFileName = args[z + 1];
        z += 2;
      } else if (args[z].equals("--debug")) {
        debug = true;
        z += 1;
      } else if (args[z].equals("--bar-server-debug")) {
        BARServer.debug = true;
        z += 1;
      } else if (args[z].equals("--")) {
        z += 1;
        break;
      } else if (args[z].startsWith("--")) {
        throw new Error("Unknown option '" + args[z] + "'!");
      } else {
        serverName = args[z];
        z += 1;
      }
    }

    // check arguments
    if (serverKeyFileName != null) {
      // check if JKS file readable
      try {
        KeyStore keyStore = java.security.KeyStore.getInstance("JKS");
        keyStore.load(new java.io.FileInputStream(serverKeyFileName), null);
      } catch (java.security.NoSuchAlgorithmException exception) {
        throw new Error(exception.getMessage());
      } catch (java.security.cert.CertificateException exception) {
        throw new Error(exception.getMessage());
      } catch (java.security.KeyStoreException exception) {
        throw new Error(exception.getMessage());
      } catch (IOException exception) {
        throw new Error("not a JKS file '" + serverKeyFileName + "'");
      }
    }
  }
 /**
  * Test for <code>KeyStoreException(Throwable)</code> constructor Assertion: constructs
  * KeyStoreException when <code>cause</code> is null
  */
 public void testKeyStoreException04() {
   Throwable cause = null;
   KeyStoreException tE = new KeyStoreException(cause);
   assertNull("getMessage() must return null.", tE.getMessage());
   assertNull("getCause() must return null", tE.getCause());
 }
예제 #24
0
  public PushManager get(Product product) {

    if (StringUtils.isBlank(product.getDevCertPath())
        || StringUtils.isBlank(product.getDevCertPass())
        || StringUtils.isBlank(product.getCertPath())
        || StringUtils.isBlank(product.getCertPass())) {
      logger.error("Product iOS Push Service Miss Cert Path and Password. {}", product);
      return null;
    }

    PushManager service = mapping.get(product.getId());
    if (service == null) {

      ApnsEnvironment apnsEnvironment = null;
      SSLContext sslContext = null;

      try {
        if (sandBox) {
          apnsEnvironment = ApnsEnvironment.getSandboxEnvironment();
          sslContext =
              SSLContextUtil.createDefaultSSLContext(
                  product.getDevCertPath(), product.getDevCertPass());
        } else {
          apnsEnvironment = ApnsEnvironment.getProductionEnvironment();
          sslContext =
              SSLContextUtil.createDefaultSSLContext(product.getCertPath(), product.getCertPass());
        }
      } catch (KeyStoreException e) {
        logger.error(e.getMessage(), e);
      } catch (NoSuchAlgorithmException e) {
        logger.error(e.getMessage(), e);
      } catch (CertificateException e) {
        logger.error(e.getMessage(), e);
      } catch (UnrecoverableKeyException e) {
        logger.error(e.getMessage(), e);
      } catch (KeyManagementException e) {
        logger.error(e.getMessage(), e);
      } catch (IOException e) {
        logger.error(e.getMessage(), e);
      }

      PushManagerConfiguration configuration = new PushManagerConfiguration();
      configuration.setConcurrentConnectionCount(1);

      final PushManager<SimpleApnsPushNotification> pushManager =
          new PushManager<SimpleApnsPushNotification>(
              apnsEnvironment,
              sslContext,
              null, // Optional: custom event loop group
              null, // Optional: custom ExecutorService for calling listeners
              null, // Optional: custom BlockingQueue implementation
              configuration,
              "ApnsPushManager-" + product.getId());

      pushManager.registerRejectedNotificationListener(new PushRejectedNotificationListener());
      pushManager.registerFailedConnectionListener(new PushFailedConnectionListener());

      pushManager.start();

      //             ApnsServiceBuilder builder =  APNS.newService();
      //            if (sandBox){
      //                builder.withCert(product.getDevCertPath(), product.getDevCertPass());
      //                builder.withSandboxDestination();
      //            }else{
      //                builder.withCert(product.getCertPath(), product.getCertPass());
      //                builder.withProductionDestination();
      //            }
      //            service =
      // builder.asPool(10).withCacheLength(Integer.MAX_VALUE).withDelegate(delegateAdapter).asQueued().build();

      mapping.put(product.getId(), pushManager);
      service = pushManager;
    }

    return service;
  }