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

package org.bouncycastle.jcajce.provider.asymmetric.x509;

import org.bouncycastle.internal.asn1.oiw.OIWObjectIdentifiers;
import org.bouncycastle.internal.asn1.edec.EdECObjectIdentifiers;
import java.util.HashMap;
import org.bouncycastle.util.encoders.Hex;
import java.security.Provider;
import java.security.Security;
import org.bouncycastle.jcajce.util.MessageDigestUtils;
import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;
import org.bouncycastle.asn1.pkcs.RSASSAPSSparams;
import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.GeneralSecurityException;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.PSSParameterSpec;
import java.io.IOException;
import java.security.SignatureException;
import java.security.AlgorithmParameters;
import java.security.Signature;
import org.bouncycastle.internal.asn1.misc.MiscObjectIdentifiers;
import org.bouncycastle.asn1.DERNull;
import org.bouncycastle.asn1.ASN1Encodable;
import org.bouncycastle.asn1.ASN1OctetString;
import org.bouncycastle.util.Exceptions;
import org.bouncycastle.asn1.x509.Extensions;
import org.bouncycastle.util.Objects;
import org.bouncycastle.util.Properties;
import org.bouncycastle.asn1.ASN1Primitive;
import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import java.util.Map;

class X509SignatureUtil
{
    private static final Map<ASN1ObjectIdentifier, String> algNames;
    
    static boolean areEquivalentAlgorithms(final AlgorithmIdentifier algorithmIdentifier, final AlgorithmIdentifier algorithmIdentifier2) {
        return algorithmIdentifier.getAlgorithm().equals(algorithmIdentifier2.getAlgorithm()) && ((Properties.isOverrideSet("org.bouncycastle.x509.allow_absent_equiv_NULL") && isAbsentOrEmptyParameters(algorithmIdentifier.getParameters()) && isAbsentOrEmptyParameters(algorithmIdentifier2.getParameters())) || Objects.areEqual(algorithmIdentifier.getParameters(), algorithmIdentifier2.getParameters()));
    }
    
    static byte[] getExtensionValue(final Extensions extensions, final String s) {
        if (s != null) {
            final ASN1ObjectIdentifier tryFromID = ASN1ObjectIdentifier.tryFromID(s);
            if (tryFromID != null) {
                final ASN1OctetString extensionValue = Extensions.getExtensionValue(extensions, tryFromID);
                if (null != extensionValue) {
                    try {
                        return extensionValue.getEncoded();
                    }
                    catch (final Exception ex) {
                        throw Exceptions.illegalStateException("error parsing " + ex.getMessage(), ex);
                    }
                }
            }
        }
        return null;
    }
    
    private static boolean isAbsentOrEmptyParameters(final ASN1Encodable asn1Encodable) {
        return asn1Encodable == null || DERNull.INSTANCE.equals(asn1Encodable);
    }
    
    static boolean isCompositeAlgorithm(final AlgorithmIdentifier algorithmIdentifier) {
        return MiscObjectIdentifiers.id_alg_composite.equals(algorithmIdentifier.getAlgorithm());
    }
    
    static void setSignatureParameters(final Signature signature, final ASN1Encodable asn1Encodable) throws NoSuchAlgorithmException, SignatureException, InvalidKeyException {
        if (!isAbsentOrEmptyParameters(asn1Encodable)) {
            final String algorithm = signature.getAlgorithm();
            final AlgorithmParameters instance = AlgorithmParameters.getInstance(algorithm, signature.getProvider());
            try {
                instance.init(asn1Encodable.toASN1Primitive().getEncoded());
            }
            catch (final IOException ex) {
                throw new SignatureException("IOException decoding parameters: " + ex.getMessage());
            }
            if (algorithm.endsWith("MGF1")) {
                try {
                    signature.setParameter(instance.getParameterSpec(PSSParameterSpec.class));
                }
                catch (final GeneralSecurityException ex2) {
                    throw new SignatureException("Exception extracting parameters: " + ex2.getMessage());
                }
            }
        }
    }
    
    static String getSignatureName(final AlgorithmIdentifier algorithmIdentifier) {
        final ASN1ObjectIdentifier algorithm = algorithmIdentifier.getAlgorithm();
        final ASN1Encodable parameters = algorithmIdentifier.getParameters();
        if (!isAbsentOrEmptyParameters(parameters)) {
            if (PKCSObjectIdentifiers.id_RSASSA_PSS.equals(algorithm)) {
                return getDigestAlgName(RSASSAPSSparams.getInstance(parameters).getHashAlgorithm().getAlgorithm()) + "withRSAandMGF1";
            }
            if (X9ObjectIdentifiers.ecdsa_with_SHA2.equals(algorithm)) {
                return getDigestAlgName(AlgorithmIdentifier.getInstance(parameters).getAlgorithm()) + "withECDSA";
            }
        }
        final String s = X509SignatureUtil.algNames.get(algorithm);
        if (s != null) {
            return s;
        }
        return findAlgName(algorithm);
    }
    
    private static String getDigestAlgName(final ASN1ObjectIdentifier asn1ObjectIdentifier) {
        final String digestName = MessageDigestUtils.getDigestName(asn1ObjectIdentifier);
        final int index = digestName.indexOf(45);
        if (index > 0 && !digestName.startsWith("SHA3")) {
            return digestName.substring(0, index) + digestName.substring(index + 1);
        }
        return digestName;
    }
    
    private static String findAlgName(final ASN1ObjectIdentifier asn1ObjectIdentifier) {
        final Provider provider = Security.getProvider("BC");
        if (provider != null) {
            final String lookupAlg = lookupAlg(provider, asn1ObjectIdentifier);
            if (lookupAlg != null) {
                return lookupAlg;
            }
        }
        final Provider[] providers = Security.getProviders();
        for (int i = 0; i != providers.length; ++i) {
            if (provider != providers[i]) {
                final String lookupAlg2 = lookupAlg(providers[i], asn1ObjectIdentifier);
                if (lookupAlg2 != null) {
                    return lookupAlg2;
                }
            }
        }
        return asn1ObjectIdentifier.getId();
    }
    
    private static String lookupAlg(final Provider provider, final ASN1ObjectIdentifier asn1ObjectIdentifier) {
        final String property = provider.getProperty("Alg.Alias.Signature." + asn1ObjectIdentifier);
        if (property != null) {
            return property;
        }
        final String property2 = provider.getProperty("Alg.Alias.Signature.OID." + asn1ObjectIdentifier);
        if (property2 != null) {
            return property2;
        }
        return null;
    }
    
    static void prettyPrintSignature(final byte[] array, final StringBuilder sb, final String s) {
        if (array.length > 20) {
            sb.append("            Signature: ").append(Hex.toHexString(array, 0, 20)).append(s);
            for (int i = 20; i < array.length; i += 20) {
                if (i < array.length - 20) {
                    sb.append("                       ").append(Hex.toHexString(array, i, 20)).append(s);
                }
                else {
                    sb.append("                       ").append(Hex.toHexString(array, i, array.length - i)).append(s);
                }
            }
        }
        else {
            sb.append("            Signature: ").append(Hex.toHexString(array)).append(s);
        }
    }
    
    static {
        (algNames = new HashMap<ASN1ObjectIdentifier, String>()).put(EdECObjectIdentifiers.id_Ed25519, "Ed25519");
        X509SignatureUtil.algNames.put(EdECObjectIdentifiers.id_Ed448, "Ed448");
        X509SignatureUtil.algNames.put(OIWObjectIdentifiers.dsaWithSHA1, "SHA1withDSA");
        X509SignatureUtil.algNames.put(X9ObjectIdentifiers.id_dsa_with_sha1, "SHA1withDSA");
    }
}