pyopenssl 26.4.0

Source: https://github.com/pyca/pyopenssl
Tag scanned: 26.4.0
Compared with: 26.3.0 (0 signals introduced since)
Files: 33 scanned, 13 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 29 info
Scan time: 19.5 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 29 of 29 warn and critical signals; 29 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-14 18:42

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:129:1

base64-like blob (2360 bytes over 37 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
root_key_pem = b"""-----BEGIN RSA PRIVATE KEY-----
MIIG5AIBAAKCAYEAuljmNv5LsBRvH2DM3TrCSpR5v540tOMI4qh+IxOfxjROoIDZ
nJjdcxw0ExohLuF0VOCaaq18We1ihvEsCX+3B9vP0CdFpUOHYfJS8e8wHEqfUdIM
sAsu2p0XSlxciM/ThLs0o9BSaCS/YfQrBxSliWCNMW1dGI/7vANKJB4/VhVKuISg
```
dismissed LLM, confidence 0.92 Embedded RSA private key PEM test fixture in a crypto test file.
Reasoning
The blob is a PEM-encoded RSA private key inside a byte-string literal in a crypto test module, and the raw pass flags base64 by shape alone. Test fixtures like this are expected, so it is not obfuscation.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:171:1

base64-like blob (2360 bytes over 37 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
    """
MIIG5AIBAAKCAYEAuljmNv5LsBRvH2DM3TrCSpR5v540tOMI4qh+IxOfxjROoIDZ
nJjdcxw0ExohLuF0VOCaaq18We1ihvEsCX+3B9vP0CdFpUOHYfJS8e8wHEqfUdIM
sAsu2p0XSlxciM/ThLs0o9BSaCS/YfQrBxSliWCNMW1dGI/7vANKJB4/VhVKuISg
```
dismissed LLM, confidence 0.92 Continuation of the RSA private key PEM test fixture.
Reasoning
This is the continuation of the same PEM RSA key fixture (lines 129 onward) inside a test file. The base64 flag reflects the expected format of key material, not hidden code.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:214:1

base64-like blob (1496 bytes over 24 lines, compression ratio 0.74) (raw pass, confidence 0.60)
```
intermediate_cert_pem = b"""-----BEGIN CERTIFICATE-----
MIIEXDCCAsSgAwIBAgIRAMPzhm6//0Y/g2pmnHR2C4cwDQYJKoZIhvcNAQELBQAw
WDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAklMMRAwDgYDVQQHEwdDaGljYWdvMRAw
DgYDVQQKEwdUZXN0aW5nMRgwFgYDVQQDEw9UZXN0aW5nIFJvb3QgQ0EwHhcNMjAw
```
dismissed LLM, confidence 0.92 Embedded X.509 certificate PEM fixture named as an intermediate cert in tests.
Reasoning
A PEM certificate with a Testing Root CA issuer embedded as a bytes literal in a test module. Certificate chains are routinely fixtured this way for testing TLS or signing code.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:242:1

base64-like blob (2356 bytes over 37 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
intermediate_key_pem = b"""-----BEGIN RSA PRIVATE KEY-----
MIIG4gIBAAKCAYEAo3rOxOVrdLdRsR1o0+JG7MRpCtMoafA63TM/DczLQ4jURv5M
zyTE7FFdXq4xNJRYgD16vUavZluQGj30+5Lkt07CuO/BK3itl8UW+dsHp95gzBvg
nj5AVZGkNOQ0Y4CbXO087Ywep7tpBfZ5fzURLeH+OHQGseEFZ5e0w8AzAarWu+Ez
```
dismissed LLM, confidence 0.92 Embedded intermediate RSA private key PEM test fixture.
Reasoning
Another RSA private key PEM literal in the crypto test file, consistent with the test-fixture PKI setup. Base64 shape alone does not indicate malice.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:283:1

base64-like blob (1428 bytes over 23 lines, compression ratio 0.76) (raw pass, confidence 0.60)
```
server_cert_pem = b"""-----BEGIN CERTIFICATE-----
MIIEKTCCApGgAwIBAgIJAJn/HpR21r/8MA0GCSqGSIb3DQEBCwUAMFgxCzAJBgNV
BAYTAlVTMQswCQYDVQQIDAJJTDEQMA4GA1UEBwwHQ2hpY2FnbzEQMA4GA1UECgwH
VGVzdGluZzEYMBYGA1UEAwwPVGVzdGluZyBSb290IENBMB4XDTIwMDgwMjE3MTEy
```
dismissed LLM, confidence 0.92 Embedded server certificate PEM test fixture.
Reasoning
A server certificate PEM in a test module, with the same Testing Root CA issuer as the other fixtures. This is a standard test PKI artifact.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:311:1

base64-like blob (2360 bytes over 37 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
    b"""-----BEGIN RSA PRIVATE KEY-----
MIIG5AIBAAKCAYEApT23GEqDo1zR1Ur1W/gxi5g/oeyhHjzf7ALndXxrGR/LZPKe
sFK6Dwdql5IVbmPB3ByyNoPAQgC6Bl9GjPQ3W9H9DpM4UBifaFHCUCBRdWTc1ekM
1X9BGWIa/GEsBWm+7VrgTF9Vmg5DI9rymiAOCtR0Hd61iaYUc1rT0u/WfIxlaLq3
```
dismissed LLM, confidence 0.92 RSA private key PEM test fixture body.
Reasoning
A continuation of an RSA private key PEM bytes literal in the crypto test file. The raw base64 signal is a known false positive for key fixtures.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:353:1

base64-like blob (1496 bytes over 24 lines, compression ratio 0.72) (raw pass, confidence 0.60)
```
intermediate_server_cert_pem = b"""-----BEGIN CERTIFICATE-----
MIIEXTCCAsWgAwIBAgIRAPQFY9jfskSihdiNSNdt6GswDQYJKoZIhvcNAQELBQAw
ZjEVMBMGA1UEAxMMaW50ZXJtZWRpYXRlMQwwCgYDVQQKEwNvcmcxETAPBgNVBAsT
CG9yZy11bml0MQswCQYDVQQGEwJVUzELMAkGA1UECBMCQ0ExEjAQBgNVBAcTCVNh
```
dismissed LLM, confidence 0.92 Embedded intermediate server certificate PEM test fixture.
Reasoning
A PEM intermediate server certificate in a test file, built from a test CA hierarchy. Nothing in the snippet executes or decodes anything beyond fixture data.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:381:1

base64-like blob (2360 bytes over 37 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
intermediate_server_key_pem = b"""-----BEGIN RSA PRIVATE KEY-----
MIIG5AIBAAKCAYEAvdRxPHAKwxmogT7uWiWby3qVPQhhmQTgvu7aojrib0K/O252
qophlyumtmhtnGo+Gpzwg7cIVHadXPBlbGscJybqcDMmNVdQWtzhMuxVhgkvVC8p
fGv3tUiLJJTvHrFatBCyoO2WtvSMfn0RgVszZ4yTZ8FPZfiHpgxeWrKsONkXpqkK
```
dismissed LLM, confidence 0.92 Embedded intermediate server RSA private key PEM test fixture.
Reasoning
An RSA private key PEM literal for an intermediate server key in a test module. This is ordinary PKI test data, not an encoded payload.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:422:1

base64-like blob (1424 bytes over 23 lines, compression ratio 0.75) (raw pass, confidence 0.60)
```
client_cert_pem = b"""-----BEGIN CERTIFICATE-----
MIIEJzCCAo+gAwIBAgIJAKxpFI5lODkjMA0GCSqGSIb3DQEBCwUAMFgxCzAJBgNV
BAYTAlVTMQswCQYDVQQIDAJJTDEQMA4GA1UEBwwHQ2hpY2FnbzEQMA4GA1UECgwH
VGVzdGluZzEYMBYGA1UEAwwPVGVzdGluZyBSb290IENBMB4XDTIwMDgwMjE3MTEy
```
dismissed LLM, confidence 0.92 Embedded client certificate PEM test fixture.
Reasoning
A client certificate PEM in the crypto test file, using the same test root CA as the other fixtures. Consistent with mutual-TLS test setup.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:450:1

base64-like blob (2360 bytes over 37 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
    b"""-----BEGIN RSA PRIVATE KEY-----
MIIG5AIBAAKCAYEAxgoXTjGNeuBUnCan4ieSxLY2DihIOJ5jADBrhyE/MGWRH82m
h4QW8qcyqtnDz9arch4L7VDDOijhRI+MvQKJ6s83ZVcWzIuvgL2C1pT6Aea/xtRn
bJVL123OxdNgf+rAf/ohV5nHYzowEHC1sVYFC/tQqHqGNWsDWJs0Lniv0/Nmv+gG
```
dismissed LLM, confidence 0.92 RSA private key PEM test fixture body.
Reasoning
Continuation of a PEM RSA private key bytes literal in the test file. The high-entropy base64 is expected for key material used in tests.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:495:1

base64-like blob (824 bytes over 13 lines, compression ratio 0.80) (raw pass, confidence 0.60)
```
SHOho56WxDkT0ht10UTeKc0F5u8cqIa01kzFAmETw0MAs8ezYtK15NPdCXUm3X/2
a17G7LSF5bkxOgZ7vpXyMzun/owrj7CzvLxyncyEFZWvtvzaAhPhvTJtTIB3kf8B
8+qRcpTGK7NgXEgYBW5bj1y4qZkD4zCL9o9NQzsKI3Ie8i0239jsDOWR38AxjXBH
```
likely benign LLM, confidence 0.93 Base64-looking blob in a crypto test file, likely key or cipher test data.
Reasoning
The snippet is a long base64-like run in a test module that is clearly a fixture for crypto testing. Raw-pass base64 detection has a high false-positive rate on key material, and nothing here suggests a payload or hidden code.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:514:1

base64-like blob (848 bytes over 14 lines, compression ratio 0.80) (raw pass, confidence 0.60)
```
cleartextPrivateKeyPEM = """-----BEGIN PRIVATE KEY-----
MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMcRMugJ4kvkOEuT
AvMFr9+3A6+HAB6nKYcXXZz93ube8rJpBZQEfWn73H10dQiQR/a+rhxYEeLy8dPc
UkFcGR9miVkukJ59zex7iySJY76bdBD8gyx1LTKrkCstP2XHKEYqgbj+tm7VzJnY
```
likely benign LLM, confidence 0.95 Embedded PEM private key used as test data in a crypto test.
Reasoning
The snippet is a PEM-armored private key assigned to a variable named cleartextPrivateKeyPEM in a test file. This is standard test fixture material for exercising key handling, not an obfuscated payload.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:532:1

base64-like blob (392 bytes over 7 lines, compression ratio 0.84) (raw pass, confidence 0.60)
```
cleartextPublicKeyPEM = b"""-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxszlc+b71LvlLS0ypt/l
gT/JzSVJtnEqw9WUNGeiChywX2mmQLHEt7KP0JikqUFZOtPclNY823Q4pErMTSWC
90qlUxI47vNJbXGRfmO2q6Zfw6SE+E9iUb74xezbOJLjBuUIkQzEKEFV+8taiRV+
```
likely benign LLM, confidence 0.95 Embedded PEM public key used as test data.
Reasoning
The blob is a PEM public key block with a cleartext variable name in a test module. Public key fixtures like this are routine in crypto test suites.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:545:1

base64-like blob (428 bytes over 7 lines, compression ratio 0.84) (raw pass, confidence 0.60)
```
inconsistentPrivateKeyPEM = b"""-----BEGIN RSA PRIVATE KEY-----
MIIBPAIBAAJBAKy+e3dulvXzV7zoTZWc5TzgApr8DmeQHTYC8ydfzH7EECe4R1Xh
5kwIzOuuFfn178FBiS84gngaNcrFi0Z5fAkCAwEaAQJBAIqm/bz4NA1H++Vx5Ewx
OcKp3w19QSaZAwlGRtsUxrP7436QjnREM3Bm8ygU11BjkPVmtrKm6AayQfCHqJoT
```
likely benign LLM, confidence 0.95 Intentionally inconsistent RSA private key fixture for negative testing.
Reasoning
The variable name inconsistentPrivateKeyPEM and the RSA PRIVATE KEY header indicate a deliberately malformed or mismatched key fixture for negative tests in a crypto test file.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:587:1

base64-like blob (3208 bytes over 51 lines, compression ratio 0.76) (raw pass, confidence 0.60)
```
large_key_pem = b"""-----BEGIN RSA PRIVATE KEY-----
MIIJYgIBAAKCAg4AtRua8eIeevRfsj+fkcHr1vmse7Kgb+oX1ssJAvCb1R7JQMnH
hNDjDP6b3vEkZuPUzlDHymP+cNkXvvi4wJ4miVbO3+SeU4Sh+jmsHeHzGIXat9xW
9PFtuPM5FQq8zvkY8aDeRYmYwN9JKu4/neMBCBqostYlTEWg+bSytO/qWnyHTHKh
```
likely benign LLM, confidence 0.95 Large RSA private key PEM fixture in a crypto test.
Reasoning
A large PEM RSA private key bound to large_key_pem in a test file. Its size only reflects a big key fixture used for testing key parsing or size handling.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:641:1

base64-like blob (184 bytes over 3 lines, compression ratio 0.92) (raw pass, confidence 0.60)
```
ec_private_key_pem = b"""-----BEGIN PRIVATE KEY-----
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgYirTZSx+5O8Y6tlG
cka6W6btJiocdrdolfcukSoTEk+hRANCAAQkvPNu7Pa1GcsWU4v7ptNfqCJVq8Cx
zo0MUVPQgwJ3aJtNM1QMOQUayCrRwfklg+D/rFSUwEUqtZh7fJDiFqz3
```
likely benign LLM, confidence 0.95 EC private key PEM fixture for crypto tests.
Reasoning
An EC private key PEM bound to ec_private_key_pem in a test module. This is ordinary test fixture material for elliptic-curve tests.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:647:1

base64-like blob (124 bytes over 2 lines, compression ratio 1.02) (raw pass, confidence 0.60)
```
ec_public_key_pem = b"""-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJLzzbuz2tRnLFlOL+6bTX6giVavA
sc6NDFFT0IMCd2ibTTNUDDkFGsgq0cH5JYPg/6xUlMBFKrWYe3yQ4has9w==
-----END PUBLIC KEY-----
```
likely benign LLM, confidence 0.95 EC public key PEM fixture for crypto tests.
Reasoning
A short EC public key PEM bound to a test variable. Public key fixtures in test files are expected and carry no execution or hiding behavior.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:653:1

base64-like blob (224 bytes over 4 lines, compression ratio 0.90) (raw pass, confidence 0.60)
```
ec_root_key_pem = b"""-----BEGIN EC PRIVATE KEY-----
MIGlAgEBBDEAz/HOBFPYLB0jLWeTpJn4Yc4m/C4mdWymVHBjOmnwiPHKT326iYN/
ZhmSs+RM94RsoAcGBSuBBAAioWQDYgAEwE5vDdla/nLpWAPAQ0yFGqwLuw4BcN2r
U+sKab5EAEHzLeceRa8ffncYdCXNoVsBcdob1y66CFZMEWLetPTmGapyWkBAs6/L
```
likely benign LLM, confidence 0.95 EC root private key PEM fixture in a crypto test.
Reasoning
An EC private key PEM with a root-key variable name, used in a test file. This is standard fixture data for certificate or key-chain tests.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:661:1

base64-like blob (748 bytes over 12 lines, compression ratio 0.74) (raw pass, confidence 0.60)
```
ec_root_cert_pem = b"""-----BEGIN CERTIFICATE-----
MIICLTCCAbKgAwIBAgIMWW/hwTl6ufz6/WkCMAoGCCqGSM49BAMDMFgxGDAWBgNV
BAMTD1Rlc3RpbmcgUm9vdCBDQTEQMA4GA1UEChMHVGVzdGluZzEQMA4GA1UEBxMH
Q2hpY2FnbzELMAkGA1UECBMCSUwxCzAJBgNVBAYTAlVTMCAXDTE3MDcxOTIyNDgz
```
likely benign LLM, confidence 0.95 Root certificate PEM fixture for crypto tests.
Reasoning
A certificate PEM bound to ec_root_cert_pem in a test module. Certificate fixtures are normal in crypto test suites and do not indicate obfuscation.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:682:1

base64-like blob (824 bytes over 13 lines, compression ratio 0.79) (raw pass, confidence 0.60)
```
dsa_private_key_pem = b"""-----BEGIN PRIVATE KEY-----
MIICZAIBADCCAjkGByqGSM44BAEwggIsAoIBAQD7UzdlshSCIIuntch43VmfCX1+
WQDTvGw83sRZcN+B7nwFn4dm2PU8cby17oCjX7buBvalVqofnUokrSIDA6Rozm/f
2wpGR9oVpd0xh9cI50pw1G3RZ4lcNWTP8C8O20eIzJoCH1KElcWLCHLAa3XoGOMv
```
likely benign LLM, confidence 0.95 DSA private key PEM fixture for crypto tests.
Reasoning
A DSA private key PEM bound to dsa_private_key_pem in a test file. This is ordinary key fixture data for testing DSA support.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:698:1

base64-like blob (1124 bytes over 18 lines, compression ratio 0.78) (raw pass, confidence 0.60)
```
dsa_public_key_pem = b"""-----BEGIN PUBLIC KEY-----
MIIDRjCCAjkGByqGSM44BAEwggIsAoIBAQD7UzdlshSCIIuntch43VmfCX1+WQDT
vGw83sRZcN+B7nwFn4dm2PU8cby17oCjX7buBvalVqofnUokrSIDA6Rozm/f2wpG
R9oVpd0xh9cI50pw1G3RZ4lcNWTP8C8O20eIzJoCH1KElcWLCHLAa3XoGOMvp4Xn
```
dismissed LLM, confidence 0.93 DSA public key PEM fixture in a crypto test file.
Reasoning
A PEM-encoded DSA public key assigned to a test variable in a crypto library's test suite. The base64 body is the expected structure of a real PEM key, not an encoded payload. Raw-pass base64 signals on key material are a known false-positive pattern.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:720:1

base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)
```
ed25519_private_key_pem = b"""-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIKlxBbhVsSURoLTmsu9uTqYH6oF7zpxmp1ZQCAPhDmI2
-----END PRIVATE KEY-----
"""
```
dismissed LLM, confidence 0.93 Ed25519 private key PEM fixture in a crypto test file.
Reasoning
A short PKCS#8 Ed25519 private key PEM stored as a test constant. This is standard test-vector material in a cryptography test module, and the blob is consistent with a real key encoding.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:724:1

base64-like blob (60 bytes, compression ratio 1.18) (raw pass, confidence 0.60)
```
ed25519_public_key_pem = b"""-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAq+FrpdwI1oTPytx8kGzuLVc+78zJE7hjYG4E9hwXoKI=
-----END PUBLIC KEY-----
"""
```
dismissed LLM, confidence 0.93 Ed25519 public key PEM fixture in a crypto test file.
Reasoning
An Ed25519 SubjectPublicKeyInfo PEM used as a test fixture. It is ordinary key-format data in a test file, with no decoding or execution around it.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:729:1

base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)
```
ed448_private_key_pem = b"""-----BEGIN PRIVATE KEY-----
MEcCAQAwBQYDK2VxBDsEOcqZ7a3k6JwrJbYO8CNTPT/d7dlWCo5vCf0EYDj79ZvA\nhD8u9EPHlYJw5Y8ZQdH4WmVEfpKA23xkdQ==
-----END PRIVATE KEY-----
"""
```
dismissed LLM, confidence 0.92 Ed448 private key PEM fixture in a crypto test file.
Reasoning
An Ed448 private key PEM fixture. The literal \n escape inside the body is a little odd but is typical of hand-written or copied test vectors, not obfuscation of a payload.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:733:1

base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)
```
ed448_public_key_pem = b"""-----BEGIN PUBLIC KEY-----
MEMwBQYDK2VxAzoAKFfWGCuqIaxgR9GmEXLRciYDyEjTnF56kr0sOVfwHEj+bHSU\neMJTZJR8qFSg8hNsHY1iZh9PIXcA
-----END PUBLIC KEY-----
"""
```
dismissed LLM, confidence 0.92 Ed448 public key PEM fixture in a crypto test file.
Reasoning
An Ed448 public key PEM fixture in a crypto test file. Same pattern as the other key fixtures: expected key-format data in a test, not a dropper or hidden payload.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:738:1

base64-like blob (1620 bytes over 26 lines, compression ratio 0.77) (raw pass, confidence 0.60)
```
rsa_private_key_pem = b"""-----BEGIN PRIVATE KEY-----
MIIEuwIBADANBgkqhkiG9w0BAQEFAASCBKUwggShAgEAAoIBAQDZ5FaSaXKn/RTF
xyNr+GRvYnMvLz5XxSDD4JzVRKXxKGFzKKXMJAeXJkvPlho7Ta/HgMNXhMPAe8TT
wcIRnHJqAfmSOnka1ks3Kl6EGQBTevKzyJy8MaUhzZsL4FUUgWUETFQQT8Dwcghf
```
dismissed LLM, confidence 0.93 RSA private key PEM fixture in a crypto test file.
Reasoning
A larger RSA private key PEM in a crypto test module. Key material in test fixtures is expected, and the raw base64 signal fires on the normal structure of the key.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:767:1

base64-like blob (392 bytes over 7 lines, compression ratio 0.84) (raw pass, confidence 0.60)
```
rsa_public_key_pem = b"""-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2eRWkmlyp/0Uxccja/hk
b2JzLy8+V8Ugw+Cc1USl8ShhcyilzCQHlyZLz5YaO02vx4DDV4TDwHvE08HCEZxy
agH5kjp5GtZLNypehBkAU3rys8icvDGlIc2bC+BVFIFlBExUEE/A8HIIXyaG1dJP
```
dismissed LLM, confidence 0.93 RSA public key PEM fixture in a crypto test file.
Reasoning
An RSA public key PEM used as a test constant, consistent with the other crypto test vectors in the file. No execution or decoding logic is present.
info ~~warn~~ → info by review encoding-base64 tests/test_crypto.py:778:1

base64-like blob (64 bytes, compression ratio 1.17) (raw pass, confidence 0.60)
```
x25519_private_key_pem = b"""-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VuBCIEIPAjVfPNTm25VxtBRg+JjjFx9tA3M8aaBdVhjb92iBts
-----END PRIVATE KEY-----
"""
```
dismissed LLM, confidence 0.93 X25519 private key PEM fixture in a crypto test file.
Reasoning
An X25519 private key PEM fixture in a crypto test suite. Standard test-vector data, flagged only by the raw base64 heuristic.
info ~~warn~~ → info by review encoding-base64 tests/test_ssl.py:148:1

base64-like blob (360 bytes over 6 lines, compression ratio 0.85) (raw pass, confidence 0.60)
```
-----BEGIN DH PARAMETERS-----
MIIBCAKCAQEA2F5e976d/GjsaCdKv5RMWL/YV7fq1UUWpPAer5fDXflLMVUuYXxE
3m3ayZob9lbpgEU0jlPAsXHfQPGxpKmvhv+xV26V/DEoukED8JeZUY/z4pigoptl
+8+TYdNNE/rFSZQFXIp+v2D91IEgmHBnZlKFSbKR+p8i0KjExXGjU6ji3S5jkOku
```
dismissed LLM, confidence 0.90 DH parameters PEM fixture in an SSL test file.
Reasoning
A DH PARAMETERS PEM block in an SSL test file. Diffie-Hellman parameters are commonly embedded as fixtures for TLS tests, and the content is a plain base64 encoding of DH parameter data with no decoding step.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/pyca/pyopenssl pyopenssl && cd pyopenssl
git checkout 26.4.0
disclude scan --severity info --diff 26.3.0 .