offensive-tls-attacks
Comprehensive methodology for auditing and exploiting TLS/SSL implementations and misconfigurations across network services and mobile applications.
Install / Use
npx skills add SnailSploit/Claude-Red --skill offensive-tls-attacksInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
SecuritySupported Platforms
Tags
Our assessment of offensive-tls-attacks
offensive-tls-attacks scores 96/100 on our quality scale, 183rd of 1,108 Security skills we index (top 17%).
Its SKILL.md is 25 KB long, well organised into 99 sections with 22 code examples: a thorough specification that gives an agent plenty to work with.
With 6,850 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so offensive-tls-attacks is actively maintained.
- Our last check on 2026-11-15 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-09-29. Automated pattern scan on 2026-09-28. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
offensive-tls-attacks compared with similar skills
All 4 of these similar skills score higher than offensive-tls-attacks; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| offensive-tls-attacks (this skill)by SnailSploit | 96 | 6.8k | 58d ago | SKILL.md |
| x402by browser-use | 100 | 121.0k | 3d ago | SKILL.md |
| algorithmic-artby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
| pptxby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
| designby nextlevelbuilder | 100 | 149.0k | 6d ago | SKILL.md |
Frequently asked questions
- How do I install offensive-tls-attacks?
- Run
npx skills add SnailSploit/Claude-Red --skill offensive-tls-attacks. The install tabs above show the steps for each supported agent. - Which AI agents does offensive-tls-attacks work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is offensive-tls-attacks safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is offensive-tls-attacks still maintained?
- The repository was last updated about 2 months ago, so offensive-tls-attacks is actively maintained.
Skill content
View source on GitHubname: offensive-tls-attacks description: "Comprehensive methodology for auditing and exploiting TLS/SSL implementations and misconfigurations across network services and mobile applications. Covers protocol downgrade attacks including POODLE (CVE-2014-3566) against SSLv3 CBC padding, DROWN (CVE-2016-0800) cross-protocol attack leveraging SSLv2 export ciphers to decrypt TLS sessions, and FREAK (CVE-2015-0204) forcing RSA export-grade key exchange. Addresses BEAST (CVE-2011-3389) exploiting CBC IV predictability in TLS 1.0, CRIME (CVE-2012-4929) and BREACH targeting TLS-level and HTTP-level compression oracles respectively, and Heartbleed (CVE-2014-0160) for OpenSSL memory disclosure. Covers certificate validation bypass techniques for applications with improper hostname verification or chain validation, certificate pinning bypass using Frida and Objection for mobile application interception, HSTS bypass via NTP manipulation and subdomain exploitation, TLS 1.3 0-RTT replay attacks against non-idempotent endpoints, mutual TLS (mTLS) authentication attacks including client certificate theft and relay, and Certificate Transparency log monitoring for reconnaissance. Primary tooling includes testssl.sh for comprehensive TLS auditing, sslyze for Python-integrated scanning, sslscan for quick cipher enumeration, and tlsx for high-speed TLS probing at scale. Maps to CWE-295 (Improper Certificate Validation), CWE-319 (Cleartext Transmission of Sensitive Information), and CWE-757 (Selection of Less-Secure Algorithm During Negotiation)."
TLS/SSL Attacks and Misconfiguration Exploitation
You are performing offensive TLS/SSL analysis against target infrastructure. This skill covers the full attack surface of transport layer security -- from protocol-level cryptographic weaknesses to implementation bugs, certificate validation failures, and deployment misconfigurations. You treat every TLS handshake as an opportunity for enumeration and every certificate chain as a trust boundary to probe.
Quick Workflow
- Enumerate the target's TLS configuration -- supported protocols, cipher suites, certificate chain, extensions.
- Identify deprecated protocols (SSLv2, SSLv3, TLS 1.0, TLS 1.1) and weak cipher suites (export, NULL, RC4, DES, 3DES).
- Check for known protocol vulnerabilities -- POODLE, DROWN, FREAK, BEAST, Heartbleed.
- Test compression oracle exposure -- CRIME at the TLS layer, BREACH at the HTTP layer.
- Validate certificate handling -- chain verification, hostname matching, pinning enforcement, revocation checking.
- Assess TLS 1.3 features -- 0-RTT replay, downgrade sentinel presence, supported groups.
- For mobile targets, bypass certificate pinning and intercept traffic.
- Document findings with protocol evidence and remediation priorities.
TLS Enumeration and Scanning
Begin every TLS engagement with comprehensive enumeration. Use testssl.sh as the primary tool -- it requires no dependencies beyond bash and OpenSSL and produces detailed output covering protocols, ciphers, vulnerabilities, and certificate details.
# Full scan with all checks, output to JSON and HTML
testssl.sh --jsonfile results.json --htmlfile results.html \
--ip one --sneaky --warnings batch \
target.com:443
# Quick protocol and cipher check
testssl.sh --protocols --ciphers target.com:443
# Check only for specific vulnerabilities
testssl.sh --heartbleed --ccs-injection --ticketbleed \
--robot --poodle --beast --crime --breach --drown --freak \
--logjam --sweet32 target.com:443
# Scan multiple targets from a file
testssl.sh --file targets.txt --parallel 10 --jsonfile bulk_results.json
Use sslyze for Python-integrated scanning and CI/CD pipeline integration:
# Standard scan with all plugins
sslyze --regular target.com
# JSON output for programmatic processing
sslyze --json_out results.json target.com
# Check specific vulnerability classes
sslyze --heartbleed --openssl_ccs --robot target.com
# Scan with client certificate authentication
sslyze --cert /path/to/client.pem --key /path/to/client.key target.com
Use sslscan for rapid cipher enumeration and tlsx for high-speed probing at scale:
# sslscan quick enumeration
sslscan --no-fallback target.com:443
# tlsx high-speed probing across many hosts
cat hosts.txt | tlsx -p 443,8443,9443 -json -o tls_results.json
# tlsx specific checks
cat hosts.txt | tlsx -san -cn -so -json # Extract SANs, CNs, server orgs
cat hosts.txt | tlsx -tls-version tls10 # Find hosts still accepting TLS 1.0
cat hosts.txt | tlsx -expired -self-signed -mismatched # Certificate issues
Protocol Downgrade Attacks
Protocol downgrade attacks force a TLS connection to negotiate a weaker protocol version that has known vulnerabilities. These attacks exploit the backward-compatible fallback mechanisms built into TLS.
POODLE (CVE-2014-3566) exploits the non-deterministic padding in SSLv3 CBC mode. Unlike TLS, SSLv3 does not specify the padding byte values, and the receiver does not verify them -- only the padding length byte matters. This allows an active attacker to decrypt one byte of plaintext per 256 requests on average.
# Check if the target supports SSLv3
testssl.sh --poodle target.com:443
openssl s_client -ssl3 -connect target.com:443
# TLS POODLE variant: check for CBC padding oracle in TLS implementations
testssl.sh --poodle target.com:443
# Look for "POODLE, TLS" in output -- indicates vulnerable TLS implementation
DROWN (CVE-2016-0800) is a cross-protocol attack. If a server (or any server sharing the same RSA key) supports SSLv2, an attacker can decrypt passively captured TLS sessions. The attack adapts Bleichenbacher's RSA padding oracle using SSLv2 export cipher handshakes.
# Check for SSLv2 support (direct DROWN)
testssl.sh --drown target.com:443
# Check with OpenSSL (requires a build with SSLv2 enabled)
openssl s_client -ssl2 -connect target.com:443
# General DROWN also applies when another server shares the same RSA key
# Extract the certificate and search for key reuse across infrastructure
openssl s_client -connect target.com:443 </dev/null 2>/dev/null | \
openssl x509 -noout -modulus | md5sum
# Compare this modulus hash across all servers in scope
FREAK (CVE-2015-0204) forces a downgrade to RSA_EXPORT cipher suites with 512-bit RSA keys, which are factorable in hours on commodity hardware:
# Check for export cipher support
testssl.sh --freak target.com:443
sslyze --openssl_ccs target.com
# Enumerate export ciphers directly
openssl s_client -cipher EXPORT -connect target.com:443
nmap --script ssl-enum-ciphers -p 443 target.com | grep -i export
BEAST Attack
BEAST (CVE-2011-3389) exploits the predictable IV in TLS 1.0 CBC mode. In TLS 1.0, the IV for each record is the last ciphertext block of the previous record, making it known to an attacker who can observe the ciphertext. Combined with a chosen-plaintext capability (via JavaScript in a browser), this enables blockwise decryption of targeted bytes.
# Check for BEAST vulnerability
testssl.sh --beast target.com:443
# Verify TLS 1.0 with CBC ciphers is available
openssl s_client -tls1 -cipher 'AES128-SHA' -connect target.com:443
BEAST requires the attacker to inject chosen plaintext into the same TLS connection (typically via JavaScript in adjacent browser contexts). Modern mitigations include 1/n-1 record splitting (implemented in all current browsers) and upgrading to TLS 1.2+ where explicit IVs are used.
Confirm the condition: if openssl s_client -tls1 -cipher 'ALL:!eNULL' negotiates any CBC cipher, the connection is BEAST-eligible. Cross-reference the server's JA3S fingerprint to verify TLS 1.0 negotiation.
CRIME and BREACH
CRIME (CVE-2012-4929) exploits TLS-level compression. When TLS compression is enabled, an attacker who can inject chosen plaintext into a request and observe the compressed ciphertext length can recover secret values (such as session cookies) one byte at a time.
# Check for TLS compression
testssl.sh --crime target.com:443
openssl s_client -connect target.com:443 | grep -i compression
# "Compression: NONE" means not vulnerable to CRIME
BREACH exploits HTTP-level compression (gzip/deflate) and is far more prevalent than CRIME because HTTP compression is almost universally enabled. The attack recovers secrets that appear in HTTP response bodies alongside attacker-reflected input.
# Check for BREACH preconditions
testssl.sh --breach target.com:443
# Manual check: verify HTTP compression is enabled
curl -sI -H "Accept-Encoding: gzip, deflate" https://target.com/ | \
grep -i content-encoding
# "Content-Encoding: gzip" combined with reflected input + secrets in body = vulnerable
import requests
import string
def breach_probe(url, known_prefix, charset=string.ascii_letters + string.digits):
"""
BREACH oracle: measure compressed response length to recover secrets.
Requires: HTTP compression enabled, secret in response body,
attacker can inject chosen text that is reflected in the same response.
"""
results = {}
for c in charset:
candidate = known_prefix + c
# Inject candidate via a reflected parameter
resp = requests.get(url, params={"search": candidate},
headers={"Accept-Encoding": "gzip"})
# The response object's content is decompressed; use raw socket
# or measure the actual wire bytes for a real attack.
# Here we demonstrate the concept:
results[c] = len(resp.content)
# The correct byte compresses better (shorter response)
best = min(results, key=results.get)
return known_prefix + best
# BREACH mitigations: disable HTTP compression for pages containing secrets,
# add random padding to responses, use per-request CSRF tokens,
# separate secret-bearing responses from reflected-input responses
Heartbleed (CVE-2014-0160)
Heartbleed is a buffer over-read in OpenSSL's TLS heartbeat extension (OpenSSL 1.0.1 through 1.0.1f). A malformed heartbeat request causes the server to return up to 64KB of process memory per request, potentially exposing private keys, session cookies, credentials, and other sensitive data.
# Test for Heartbleed
testssl.sh --heartbleed target.com:443
sslyze --heartbleed target.com
# Nmap script
nmap -p 443 --script ssl-heartbleed target.com
# Manual test with OpenSSL
# This requires a version of OpenSSL that supports the heartbeat extension
openssl s_client -connect target.com:443 -tlsextdebug 2>&1 | \
grep -i heartbeat
The attack sends a TLS heartbeat request declaring a large payload length (up to 16384 bytes) but including only a single byte of actual payload. Vulnerable OpenSSL versions return the declared length from process memory. Each request leaks up to 64KB; repeated requests may expose private keys, session tokens, and credentials from different memory regions. Use the Nmap script or testssl.sh for reliable detection; for manual exploitation, existing PoC scripts (heartbleed.py variants) handle the raw TLS handshake and heartbeat framing.
Certificate Validation Bypass
Applications that fail to properly validate TLS certificates create interception opportunities. Common flaws include disabled verification, missing hostname checks, accepting self-signed certificates, and incomplete chain validation.
# Detect applications with disabled certificate verification
# These patterns indicate vulnerable implementations:
# Python requests - disabled verification
# requests.get(url, verify=False)
# Python urllib3 - disabled warnings indicate suppressed verification
# urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
# Node.js - disabled TLS rejection
# process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0"
# Java - TrustAllCerts pattern
# TrustManager[] trustAllCerts = new
Truncated for display — read the full file on GitHub.
Related Skills
x402
121.0kSet up Browser Use Cloud payments with x402 — pay per request from a crypto wallet (USDC on Base mainnet), no signup or API key.
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
pptx
177.9kUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an em…
design
149.0kComprehensive design skill: brand identity, design tokens, UI styling, logo generation (55 styles, Gemini, Atlas Cloud, or MuAPI AI), corporate identity program (50 deliverables, CIP mockups), HTML presentations (Chart.js), banner design (22 styles, social/ads/web/print), icon design (15 styles, SVG…
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
