org.bouncycastle.openssl.PEMException Java Examples

@Provides
@PemFile
static PrivateKey providePemPrivateKey(@PemFile ImmutableList<Object> pemObjects) {
  JcaPEMKeyConverter converter = new JcaPEMKeyConverter().setProvider("BC");
  Function<PEMKeyPair, PrivateKey> privateKeyConverter =
      pemKeyPair -> {
        try {
          return converter.getKeyPair(pemKeyPair).getPrivate();
        } catch (PEMException e) {
          throw new RuntimeException(
              String.format("Error converting private key: %s", pemKeyPair), e);
        }
      };
  ImmutableList<PrivateKey> privateKeys =
      filterAndConvert(pemObjects, PEMKeyPair.class, privateKeyConverter);
  checkState(
      privateKeys.size() == 1,
      "The pem file must contain exactly one private key, but %s keys are found",
      privateKeys.size());
  return privateKeys.get(0);
}
 

private static PrivateKey generatePrivateKey(PrivateKeyInfo info)
    throws InvalidKeySpecException, GeneralSecurityException, NoSuchAlgorithmException, IOException, PEMException
{
    JcaPEMKeyConverter converter = new JcaPEMKeyConverter().setProvider("BC");
    PEMParser pr = new PEMParser(new StringReader(new String(info.keyBytes, StandardCharsets.UTF_8)));
    Object o = pr.readObject();

    if (o == null || !((o instanceof PEMKeyPair) || (o instanceof PEMEncryptedKeyPair))) {
        throw new IllegalStateException("Didn't find OpenSSL key");
    }
    KeyPair kp;
    if (o instanceof PEMEncryptedKeyPair) {
        JcePEMDecryptorProviderBuilder bcDecProvider = new JcePEMDecryptorProviderBuilder().setProvider("BC");
        char[] charArray = info.password.toCharArray();
        PEMDecryptorProvider decProv = bcDecProvider.build(charArray);
        kp = converter.getKeyPair(((PEMEncryptedKeyPair)o).decryptKeyPair(decProv));
    }
    else {
        kp = converter.getKeyPair((PEMKeyPair)o);
    }

    PrivateKey privKey = kp.getPrivate();
    return privKey;
}
 

public static String extractX509CSRPublicKey(PKCS10CertificationRequest certReq) {

        JcaPEMKeyConverter pemConverter = new JcaPEMKeyConverter();
        PublicKey publicKey;
        try {
            publicKey = pemConverter.getPublicKey(certReq.getSubjectPublicKeyInfo());
            ///CLOVER:OFF
        } catch (PEMException ex) {
            LOG.error("extractX509CSRPublicKey: unable to get public key: {}", ex.getMessage());
            return null;
        }
        ///CLOVER:ON
        return convertToPEMFormat(publicKey);
    }
 

public CsrImpl(final PKCS10CertificationRequest request) {
  dn = new BcX500NameDnImpl(request.getSubject());
  try {
    publicKey = new JcaPEMKeyConverter().getPublicKey(request.getSubjectPublicKeyInfo());
  } catch (final PEMException e) {
    throw new CaException(e);
  }
}
 

protected static byte[] parseDERFromPEM(byte[] pem, String beginDelimiter, String endDelimiter)
        throws PEMException {
    String data = new String(pem);
    if(!data.contains(beginDelimiter) || !data.contains(endDelimiter)){
        throw new PEMException("File doesn't contains begin delimeter: " +beginDelimiter + "or end delimeter: " +endDelimiter );
    }
    String[] tokens = data.split(beginDelimiter);
    tokens = tokens[1].split(endDelimiter);
    return DatatypeConverter.parseBase64Binary(tokens[0]);        
}
 

/**
 * 
 * @param pem it's byte array representation of pem file
 * @param type
 * @return
 * @throws PEMException 
 * @throws Exception 
 */
protected static String knowDelimeter(byte[] pem, typeOfDelimeter type) throws PEMException {
    if(type instanceof typeOfDelimeter == false){
        throw new IllegalArgumentException();
    }
    String header = new String(pem);
    String knownDelimeter = null;
    String[] deliArray = null;
    if(type.equals(typeOfDelimeter.KEY_BEGIN)){
        deliArray = keyBeginDelimeters;
    }
    if(type.equals(typeOfDelimeter.KEY_END)){
        deliArray = keyEndDelimeters;
    }
    if(type.equals(typeOfDelimeter.CERT_BEGIN)){
        deliArray = certBeginDelimeters;
    }
    if(type.equals(typeOfDelimeter.CERT_END)){
        deliArray = certEndDelimeters;
    }
    for (String delimeter : deliArray) {
        if (header.contains(delimeter)) {
            knownDelimeter = delimeter;
        }
    }
    if(knownDelimeter == null){
        throw new PEMException("Pem file doesn't include: "+ type.toString() + " kind of delimeter");
    }
    return knownDelimeter;
    
}
 

public PrivateKey parseKey(byte[] certAndKey) throws PEMException, InvalidKeySpecException, NoSuchAlgorithmException {
    byte[] keyBytes = PemHelper.parseDERFromPEM(certAndKey, PemHelper.knowDelimeter(certAndKey, PemHelper.typeOfDelimeter.KEY_BEGIN),
            PemHelper.knowDelimeter(certAndKey, PemHelper.typeOfDelimeter.KEY_END));

    return PemHelper.generatePrivateKeyFromDER(keyBytes);
}
 

public X509Certificate parseCertificate(byte[] certAndKey) throws PEMException, CertificateException {
    byte[] certBytes = PemHelper.parseDERFromPEM(certAndKey, PemHelper.knowDelimeter(certAndKey, PemHelper.typeOfDelimeter.CERT_BEGIN),
            PemHelper.knowDelimeter(certAndKey, PemHelper.typeOfDelimeter.CERT_END));

    return PemHelper.generateCertificateFromDER(certBytes);
}
 

/**
 * Returns a {@link KeyPair} instance containing the {@link X509Certificate} public key and the {@link java.security.spec.PKCS8EncodedKeySpec} private key from the PEM-encoded {@link PEMKeyPair}.
 *
 * @param keyPair the key pair in PEM format
 * @return the key pair in a format which provides for direct access to the keys
 * @throws PEMException if there is an error converting the key pair
 */
private static KeyPair getKeyPair(PEMKeyPair keyPair) throws PEMException {
    return new JcaPEMKeyConverter().setProvider(BouncyCastleProvider.PROVIDER_NAME).getKeyPair(keyPair);
}