// 
// Decompiled by Procyon v0.6.0
// 

package com.nimbusds.jose.jwk;

import java.security.spec.InvalidKeySpecException;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.spec.KeySpec;
import java.security.KeyFactory;
import java.security.spec.RSAPublicKeySpec;
import java.security.interfaces.RSAPrivateCrtKey;
import org.bouncycastle.openssl.PEMException;
import java.security.PrivateKey;
import java.io.Reader;
import com.nimbusds.jose.JOSEException;
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.openssl.PEMKeyPair;
import org.bouncycastle.cert.X509CertificateHolder;
import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
import java.util.ArrayList;
import org.bouncycastle.openssl.PEMParser;
import java.io.StringReader;
import java.security.KeyPair;
import java.util.List;
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;

class PEMEncodedKeyParser
{
    private static final JcaPEMKeyConverter pemConverter;
    
    private PEMEncodedKeyParser() {
    }
    
    static List<KeyPair> parseKeys(final String pemEncodedKeys) throws JOSEException {
        final Reader pemReader = new StringReader(pemEncodedKeys);
        final PEMParser parser = new PEMParser(pemReader);
        final List<KeyPair> keys = new ArrayList<KeyPair>();
        try {
            Object pemObj;
            do {
                pemObj = parser.readObject();
                if (pemObj instanceof SubjectPublicKeyInfo) {
                    keys.add(toKeyPair((SubjectPublicKeyInfo)pemObj));
                }
                else if (pemObj instanceof X509CertificateHolder) {
                    keys.add(toKeyPair((X509CertificateHolder)pemObj));
                }
                else if (pemObj instanceof PEMKeyPair) {
                    keys.add(toKeyPair((PEMKeyPair)pemObj));
                }
                else {
                    if (!(pemObj instanceof PrivateKeyInfo)) {
                        continue;
                    }
                    keys.add(toKeyPair((PrivateKeyInfo)pemObj));
                }
            } while (pemObj != null);
            return keys;
        }
        catch (final Exception e) {
            throw new JOSEException(e.getMessage(), e);
        }
    }
    
    private static KeyPair toKeyPair(final SubjectPublicKeyInfo spki) throws PEMException {
        return new KeyPair(PEMEncodedKeyParser.pemConverter.getPublicKey(spki), null);
    }
    
    private static KeyPair toKeyPair(final X509CertificateHolder pemObj) throws PEMException {
        final SubjectPublicKeyInfo spki = pemObj.getSubjectPublicKeyInfo();
        return new KeyPair(PEMEncodedKeyParser.pemConverter.getPublicKey(spki), null);
    }
    
    private static KeyPair toKeyPair(final PEMKeyPair pair) throws PEMException {
        return PEMEncodedKeyParser.pemConverter.getKeyPair(pair);
    }
    
    private static KeyPair toKeyPair(final PrivateKeyInfo pki) throws PEMException, NoSuchAlgorithmException, InvalidKeySpecException {
        final PrivateKey privateKey = PEMEncodedKeyParser.pemConverter.getPrivateKey(pki);
        if (privateKey instanceof RSAPrivateCrtKey) {
            final RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec(((RSAPrivateCrtKey)privateKey).getModulus(), ((RSAPrivateCrtKey)privateKey).getPublicExponent());
            final KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            final PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
            return new KeyPair(publicKey, privateKey);
        }
        return new KeyPair(null, privateKey);
    }
    
    static {
        pemConverter = new JcaPEMKeyConverter();
    }
}