import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
 
public class MainActivity extends AppCompatActivity {
 
    private TextView textView;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        textView = findViewById(R.id.text_view);
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                String result = null;
                try {
                    URL url = new URL("https://example.com"); // replace with your URL
                    HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
 
                    SSLContext sslContext = SSLContext.getInstance("SSL");
                    sslContext.init(null, new TrustManager[]{new X509TrustManager() {
                        @Override
                        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {}
 
                        @Override
                        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                            // Perform certificate validation here
                            // For example, check the certificate chain for a specific issuer or common name
                            // You can throw a CertificateException if the validation fails
                        }
 
                        @Override
                        public X509Certificate[] getAcceptedIssuers() {
                            return new X509Certificate[0];
                        }
                    }}, null);
 
                    SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
                    urlConnection.setSSLSocketFactory(sslSocketFactory);
 
                    InputStream inputStream = urlConnection.getInputStream();
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                    StringBuilder stringBuilder = new StringBuilder();
                    String line;
                    while ((line = bufferedReader.readLine()) != null) {
                        stringBuilder.append(line);
                    }
                    result = stringBuilder.toString();
                    bufferedReader.close();
                    inputStream.close();
                    urlConnection.disconnect();
                } catch (IOException | NoSuchAlgorithmException | KeyManagementException e) {
                    e.printStackTrace();
                } catch (CertificateException e) {
                    e.printStackTrace();
                }
 
                final String finalResult = result;
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        textView.setText(finalResult);
                    }
                });
            }
        }).start();
    }
}




@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    String expectedIssuer = "CN=Expected Issuer";
    String expectedSubject = "CN=Expected Subject";
    String expectedPublicKey = "Expected Public Key"; // replace with the expected public key
 
    boolean isChainValid = false;
    boolean isIssuerValid = false;
    boolean isSubjectValid = false;
    boolean isPublicKeyValid = false;
 
    // Check certificate chain
    try {
        TrustAnchor trustAnchor = new TrustAnchor(chain[chain.length - 1], null);
        Set<TrustAnchor> trustAnchors = new HashSet<>();
        trustAnchors.add(trustAnchor);
 
        PKIXParameters params = new PKIXParameters(trustAnchors);
        params.setRevocationEnabled(false); // disable CRL and OCSP checking
 
        CertPathValidator validator = CertPathValidator.getInstance("PKIX");
        CertPath certPath = CertificateFactory.getInstance("X.509").generateCertPath(Arrays.asList(chain));
        PKIXCertPathValidatorResult result = (PKIXCertPathValidatorResult) validator.validate(certPath, params);
 
        isChainValid = true;
    } catch (GeneralSecurityException e) {
        // Validation failed
        throw new CertificateException(e);
    }
 
    // Check certificate issuer
    for (X509Certificate certificate : chain) {
        String issuerDN = certificate.getIssuerDN().getName();
        if (issuerDN.contains(expectedIssuer)) {
            isIssuerValid = true;
            break;
        }
    }
 
    // Check certificate subject
    String subjectDN = chain[0].getSubjectDN().getName();
    if (subjectDN.contains(expectedSubject)) {
        isSubjectValid = true;
    }
 
    // Check public key
    String publicKey = Base64.encodeToString(chain[0].getPublicKey().getEncoded(), Base64.DEFAULT);
    if (publicKey.contains(expectedPublicKey)) {
        isPublicKeyValid = true;
    }
 
    if (!isChainValid || !isIssuerValid || !isSubjectValid || !isPublicKeyValid) {
        // Validation failed
        throw new CertificateException("Certificate validation failed");
    }
}


// Load the SSL certificate from a file
FileInputStream fis = new FileInputStream("ssl-certificate.pem");
CertificateFactory cf = CertificateFactory.getInstance("X.509");
X509Certificate cert = (X509Certificate) cf.generateCertificate(fis);

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