@@ -83,6 +83,8 @@ Date: 2026, TBD
 - TLS: A TLS 1.3 client aborted the handshake with an illegal_parameter alert when the server sent the cached_info or record_size_limit extension in EncryptedExtensions, or the server_name extension in a CertificateRequest, since these were missing from the table of extensions permitted in each TLS 1.3 message.
 - TLS: The extensions of the CertificateEntry list in a TLS 1.3 Certificate message were not checked against what the receiving endpoint had asked for, although RFC 8446 sec. 4.4.2 requires those in a server's Certificate to correspond to extensions in the ClientHello and those in a client's Certificate to extensions in the CertificateRequest: a client ignored an OCSP response the server stapled without being asked, and a server accepted whatever a client attached. An unrequested extension in any entry now aborts the handshake with an unsupported_extension alert, as RFC 8446 sec. 4.2 requires. A TLS 1.3 server also now rejects a client Certificate whose certificate_request_context differs from that of its CertificateRequest, with an illegal_parameter alert.
 
+- CRL.isRevoked() on the provider's CRLs threw ClassCastException for a certificate whose type is "X.509" but which is not a java.security.cert.X509Certificate, although the method checks only the type and goes on to handle exactly that case: it cast the certificate to X509Certificate for its serial number before looking at any entry, so the branch that reads the issuer from the certificate's encoding could never be reached. Such a certificate now has both its serial number and its issuer read from its encoding, in the provider's X509CRL and in the legacy org.bouncycastle.jce.provider.X509CRLObject alike.
+
 ### 2.1.3 Additional Features and Functionality
 
 - The CRMF certificate request message controls now include the RFC 4211 sec. 6.6 protocolEncrKey control, which names the key a CA is to encrypt its response with: org.bouncycastle.cert.crmf.ProtocolEncrKeyControl carries the SubjectPublicKeyInfo the control is defined to take, and CertificateRequestMessage.getControl() recognises id-regCtrl-protocolEncrKey alongside the regToken, authenticator and pkiArchiveOptions controls it already returned (github PR #2443).
 
@@ -13,6 +13,8 @@
 import java.security.cert.CertPathValidator;
 import java.security.cert.CertPathValidatorException;
 import java.security.cert.CertStore;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateEncodingException;
 import java.security.cert.CertificateFactory;
 import java.security.cert.CollectionCertStoreParameters;
 import java.security.cert.PKIXParameters;
@@ -30,6 +32,7 @@
 import org.bouncycastle.asn1.x500.X500Name;
 import org.bouncycastle.asn1.x509.BasicConstraints;
 import org.bouncycastle.asn1.x509.CRLReason;
+import org.bouncycastle.asn1.x509.CertificateList;
 import org.bouncycastle.asn1.x509.Extension;
 import org.bouncycastle.asn1.x509.ExtensionsGenerator;
 import org.bouncycastle.asn1.x509.GeneralName;
@@ -121,14 +124,82 @@ public void performTest()
 
     /**
      * CRL.isRevoked() stopped at the first entry carrying the serial number, and reported the
-     * certificate as not revoked when that entry was another issuer's.
+     * certificate as not revoked when that entry was another issuer's. The same checks run with the
+     * certificates presented as a Certificate of type "X.509" that is not an X509Certificate, which
+     * isRevoked() cast to one for its serial number, and against the legacy provider CRL class.
      */
     private void isRevoked(X509Certificate ee, X509Certificate other, X509CRL caFirst, X509CRL otherFirst, X509CRL otherOnly)
+        throws Exception
+    {
+        Certificate opaqueEe = new OpaqueCertificate(ee);
+        Certificate opaqueOther = new OpaqueCertificate(other);
+
+        isRevoked("", ee, other, caFirst, otherFirst, otherOnly);
+        isRevoked(" [not an X509Certificate]", opaqueEe, opaqueOther, caFirst, otherFirst, otherOnly);
+
+        X509CRL legacyCaFirst = legacyCrl(caFirst);
+        X509CRL legacyOtherFirst = legacyCrl(otherFirst);
+        X509CRL legacyOtherOnly = legacyCrl(otherOnly);
+
+        isRevoked(" [legacy CRL]", ee, other, legacyCaFirst, legacyOtherFirst, legacyOtherOnly);
+        isRevoked(" [legacy CRL, not an X509Certificate]", opaqueEe, opaqueOther, legacyCaFirst, legacyOtherFirst, legacyOtherOnly);
+    }
+
+    private void isRevoked(String label, Certificate ee, Certificate other, X509CRL caFirst, X509CRL otherFirst, X509CRL otherOnly)
+    {
+        isTrue("revoked certificate not reported by isRevoked() (own entry first)" + label, caFirst.isRevoked(ee));
+        isTrue("revoked certificate not reported by isRevoked() (other issuer's entry first)" + label, otherFirst.isRevoked(ee));
+        isTrue("other issuer's revoked certificate not reported by isRevoked()" + label, otherFirst.isRevoked(other));
+        isTrue("another issuer's entry reported by isRevoked()" + label, !otherOnly.isRevoked(ee));
+    }
+
+    private static X509CRL legacyCrl(X509CRL crl)
+        throws Exception
     {
-        isTrue("revoked certificate not reported by isRevoked() (own entry first)", caFirst.isRevoked(ee));
-        isTrue("revoked certificate not reported by isRevoked() (other issuer's entry first)", otherFirst.isRevoked(ee));
-        isTrue("other issuer's revoked certificate not reported by isRevoked()", otherFirst.isRevoked(other));
-        isTrue("another issuer's entry reported by isRevoked()", !otherOnly.isRevoked(ee));
+        return new org.bouncycastle.jce.provider.X509CRLObject(CertificateList.getInstance(crl.getEncoded()));
+    }
+
+    /**
+     * A certificate of type "X.509" that is not a java.security.cert.X509Certificate, as another
+     * provider's CertificateFactory may return.
+     */
+    private static class OpaqueCertificate
+        extends Certificate
+    {
+        private final X509Certificate cert;
+
+        OpaqueCertificate(X509Certificate cert)
+        {
+            super("X.509");
+
+            this.cert = cert;
+        }
+
+        public byte[] getEncoded()
+            throws CertificateEncodingException
+        {
+            return cert.getEncoded();
+        }
+
+        public void verify(PublicKey key)
+        {
+            throw new UnsupportedOperationException();
+        }
+
+        public void verify(PublicKey key, String sigProvider)
+        {
+            throw new UnsupportedOperationException();
+        }
+
+        public String toString()
+        {
+            return "OpaqueCertificate: " + cert.getSubjectX500Principal();
+        }
+
+        public PublicKey getPublicKey()
+        {
+            return cert.getPublicKey();
+        }
     }
 
     private static X509CRL jdkCrl(X509CRL crl)
 
@@ -49,29 +49,21 @@ protected X509CRLEntryObject(TBSCertList.CRLEntry c)
     }
 
     /**
-     * Constructor for CRLEntries of indirect CRLs. If <code>isIndirect</code>
-     * is <code>false</code> {@link #getCertificateIssuer()} will always
-     * return <code>null</code>, <code>previousCertificateIssuer</code> is
-     * ignored. If this <code>isIndirect</code> is specified and this CRLEntry
-     * has no certificate issuer CRL entry extension
-     * <code>previousCertificateIssuer</code> is returned by
-     * {@link #getCertificateIssuer()}.
-     * 
+     * Constructor for a CRLEntry whose certificate issuer the caller has already worked out with
+     * {@link #loadCertificateIssuer}, which it has to do anyway to track the issuer from one entry
+     * to the next.
+     *
      * @param c
      *            TBSCertList.CRLEntry object.
-     * @param isIndirect
-     *            <code>true</code> if the corresponding CRL is a indirect
-     *            CRL.
-     * @param previousCertificateIssuer
-     *            Certificate issuer of the previous CRLEntry.
+     * @param certificateIssuer
+     *            the certificate issuer of this CRLEntry, <code>null</code> for the CRL issuer.
      */
     protected X509CRLEntryObject(
         TBSCertList.CRLEntry c,
-        boolean isIndirect,
-        X500Name previousCertificateIssuer)
+        X500Name certificateIssuer)
     {
         this.c = c;
-        this.certificateIssuer = loadCertificateIssuer(c, isIndirect, previousCertificateIssuer);
+        this.certificateIssuer = certificateIssuer;
     }
 
     /**
 
@@ -419,39 +419,21 @@ public Date getNextUpdate()
         return null == nextUpdate ? null : nextUpdate.getDate();
     }
 
-    private Set loadCRLEntries()
-    {
-        Set entrySet = new HashSet();
-        Enumeration certs = c.getRevokedCertificateEnumeration();
-
-        X500Name previousCertificateIssuer = null; // the issuer
-        while (certs.hasMoreElements())
-        {
-            TBSCertList.CRLEntry entry = (TBSCertList.CRLEntry)certs.nextElement();
-            X509CRLEntryObject crlEntry = new X509CRLEntryObject(entry, isIndirect, previousCertificateIssuer);
-            entrySet.add(crlEntry);
-            previousCertificateIssuer = X509CRLEntryObject.loadCertificateIssuer(entry, isIndirect, previousCertificateIssuer);
-        }
-
-        return entrySet;
-    }
-
     // returns the first entry with the serial number whatever its issuer - the cert path validators rely on that.
     public X509CRLEntry getRevokedCertificate(BigInteger serialNumber)
     {
         Enumeration certs = c.getRevokedCertificateEnumeration();
 
-        X500Name previousCertificateIssuer = null; // the issuer
+        X500Name certificateIssuer = null; // null means the CRL issuer
         while (certs.hasMoreElements())
         {
             TBSCertList.CRLEntry entry = (TBSCertList.CRLEntry)certs.nextElement();
+            certificateIssuer = X509CRLEntryObject.loadCertificateIssuer(entry, isIndirect, certificateIssuer);
 
             if (entry.getUserCertificate().hasValue(serialNumber))
             {
-                return new X509CRLEntryObject(entry, isIndirect, previousCertificateIssuer);
+                return new X509CRLEntryObject(entry, certificateIssuer);
             }
-
-            previousCertificateIssuer = X509CRLEntryObject.loadCertificateIssuer(entry, isIndirect, previousCertificateIssuer);
         }
 
         return null;
@@ -475,34 +457,42 @@ public X509CRLEntry getRevokedCertificate(X509Certificate certificate)
 
         Enumeration certs = c.getRevokedCertificateEnumeration();
 
-        X500Name previousCertificateIssuer = null; // the issuer
+        X500Name certificateIssuer = null; // null means the CRL issuer
         while (certs.hasMoreElements())
         {
             TBSCertList.CRLEntry entry = (TBSCertList.CRLEntry)certs.nextElement();
-            X500Name certificateIssuer = X509CRLEntryObject.loadCertificateIssuer(entry, isIndirect, previousCertificateIssuer);
+            certificateIssuer = X509CRLEntryObject.loadCertificateIssuer(entry, isIndirect, certificateIssuer);
 
-            if (entry.getUserCertificate().hasValue(serialNumber)
-                && issuer.equals(certificateIssuer == null ? c.getIssuer() : certificateIssuer))
+            // a serial number is only unique within its issuer, so another issuer's entry is not this one.
+            if (entry.getUserCertificate().hasValue(serialNumber) &&
+                issuer.equals(certificateIssuer == null ? c.getIssuer() : certificateIssuer))
             {
-                return new X509CRLEntryObject(entry, isIndirect, previousCertificateIssuer);
+                return new X509CRLEntryObject(entry, certificateIssuer);
             }
-
-            previousCertificateIssuer = certificateIssuer;
         }
 
         return null;
     }
 
     public Set getRevokedCertificates()
     {
-        Set entrySet = loadCRLEntries();
+        Enumeration certs = c.getRevokedCertificateEnumeration();
+        if (!certs.hasMoreElements())
+        {
+            return null;
+        }
 
-        if (!entrySet.isEmpty())
+        Set entrySet = new HashSet();
+        X500Name certificateIssuer = null; // null means the CRL issuer
+        do
         {
-            return Collections.unmodifiableSet(entrySet);
+            TBSCertList.CRLEntry entry = (TBSCertList.CRLEntry)certs.nextElement();
+            certificateIssuer = X509CRLEntryObject.loadCertificateIssuer(entry, isIndirect, certificateIssuer);
+            entrySet.add(new X509CRLEntryObject(entry, certificateIssuer));
         }
+        while (certs.hasMoreElements());
 
-        return null;
+        return Collections.unmodifiableSet(entrySet);
     }
 
     public byte[] getTBSCertList()
@@ -664,51 +654,59 @@ public boolean isRevoked(Certificate cert)
             throw new IllegalArgumentException("X.509 CRL used with non X.509 Cert");
         }
 
-        Enumeration certs = c.getRevokedCertificateEnumeration();
-
-        X500Name caName = c.getIssuer();
+        Enumeration revokedCerts = c.getRevokedCertificateEnumeration();
 
-        if (certs.hasMoreElements())
+        if (revokedCerts.hasMoreElements())
         {
-            BigInteger serial = ((X509Certificate)cert).getSerialNumber();
+            BigInteger serial;
+            X500Name issuer;
 
-            while (certs.hasMoreElements())
+            if (cert instanceof X509Certificate)
             {
-                TBSCertList.CRLEntry entry = TBSCertList.CRLEntry.getInstance(certs.nextElement());
+                X509Certificate x509Cert = (X509Certificate)cert;
 
-                caName = X509CRLEntryObject.loadCertificateIssuer(entry, isIndirect, caName);
-                if (caName == null)
+                serial = x509Cert.getSerialNumber();
+                issuer = X500Name.getInstance(x509Cert.getIssuerX500Principal().getEncoded());
+            }
+            else
+            {
+                // an "X.509" type does not make it an X509Certificate, so both come from the encoding.
+                org.bouncycastle.asn1.x509.Certificate certStruct;
+                try
                 {
-                    caName = c.getIssuer(); // an entry with no certificate issuer of its own is the CRL issuer's
+                    certStruct = org.bouncycastle.asn1.x509.Certificate.getInstance(cert.getEncoded());
                 }
-
-                if (entry.getUserCertificate().hasValue(serial))
+                catch (CertificateEncodingException e)
                 {
-                    X500Name issuer;
+                    throw Exceptions.illegalArgumentException("Cannot process certificate", e);
+                }
 
-                    if (cert instanceof X509Certificate)
-                    {
-                        issuer = X500Name.getInstance(((X509Certificate)cert).getIssuerX500Principal().getEncoded());
-                    }
-                    else
-                    {
-                        try
-                        {
-                            issuer = org.bouncycastle.asn1.x509.Certificate.getInstance(cert.getEncoded()).getIssuer();
-                        }
-                        catch (CertificateEncodingException e)
-                        {
-                            throw Exceptions.illegalArgumentException("Cannot process certificate", e);
-                        }
-                    }
+                serial = certStruct.getSerialNumber().getValue();
+                issuer = certStruct.getIssuer();
+            }
 
-                    // a serial number is only unique within its issuer, so another issuer's entry is not this one.
-                    if (caName.equals(issuer))
-                    {
-                        return true;
-                    }
+            boolean issuedByCRLIssuer = issuer.equals(c.getIssuer());
+            if (!isIndirect && !issuedByCRLIssuer)
+            {
+                return false;
+            }
+
+            X500Name certificateIssuer = null; // null means the CRL issuer
+
+            do
+            {
+                TBSCertList.CRLEntry entry = TBSCertList.CRLEntry.getInstance(revokedCerts.nextElement());
+
+                certificateIssuer = X509CRLEntryObject.loadCertificateIssuer(entry, isIndirect, certificateIssuer);
+
+                // a serial number is only unique within its issuer, so another issuer's entry is not this one.
+                if (entry.getUserCertificate().hasValue(serial) &&
+                    (certificateIssuer == null ? issuedByCRLIssuer : issuer.equals(certificateIssuer)))
+                {
+                    return true;
                 }
             }
+            while (revokedCerts.hasMoreElements());
         }
 
         return false;
 
@@ -67,9 +67,26 @@ public X509CRLEntryObject(
         TBSCertList.CRLEntry c,
         boolean isIndirect,
         X500Name previousCertificateIssuer)
+    {
+        this(c, loadCertificateIssuer(c, isIndirect, previousCertificateIssuer));
+    }
+
+    /**
+     * Constructor for a CRLEntry whose certificate issuer the caller has already worked out with
+     * {@link #loadCertificateIssuer}, which it has to do anyway to track the issuer from one entry
+     * to the next.
+     *
+     * @param c
+     *            TBSCertList.CRLEntry object.
+     * @param certificateIssuer
+     *            the certificate issuer of this CRLEntry, <code>null</code> for the CRL issuer.
+     */
+    X509CRLEntryObject(
+        TBSCertList.CRLEntry c,
+        X500Name certificateIssuer)
     {
         this.c = c;
-        this.certificateIssuer = loadCertificateIssuer(c, isIndirect, previousCertificateIssuer);
+        this.certificateIssuer = certificateIssuer;
     }
 
     /**