InfoSec Notes
HubCybersecurity vs Information SecurityHistory of Information SecurityImportance of Information SecuritySecurity Principles and the CIA TriadWhat is Information Security?Accountability in Information SecurityAuthentication in Information SecurityAuthorization in Information SecurityAvailability in Information SecurityConfidentiality in Information SecurityIntegrity in Information SecurityNon-Repudiation in Information SecurityAES - Advanced Encryption StandardAsymmetric Key CryptographyDES - Data Encryption StandardDigital SignaturesEncryption vs DecryptionCryptographic Hash FunctionsIntroduction to CryptographyPublic Key Infrastructure (PKI)RSA AlgorithmSymmetric Key CryptographyIntroduction to Access ControlAttribute-Based Access Control (ABAC)Discretionary Access Control (DAC)Mandatory Access Control (MAC)Role-Based Access Control (RBAC) — Information SecurityZero Trust Security ArchitectureFirewalls in Network SecurityIntrusion Detection Systems (IDS)Intrusion Prevention Systems (IPS)Network Monitoring and AnalysisNetwork Security BasicsSecure Network DesignVirtual Private Networks (VPN)Wireless Network SecurityAPI SecurityIntroduction to Application SecuritySecurity Code ReviewDependency and Supply Chain SecurityDynamic Application Security Testing (DAST)Secure Software Development LifecycleStatic Application Security Testing (SAST)Web Authentication MechanismsCross-Site Scripting (XSS)Cross-Site Request Forgery (CSRF)File Upload SecurityHTTPS and SSL/TLSSecure Coding Practices — Information SecuritySession Management SecuritySQL Injection Attacks and PreventionIntroduction to Web SecurityOS Access Control ModelsEndpoint SecurityFile System Permissions and SecurityLinux SecurityIntroduction to OS SecurityUser Account ManagementWindows SecurityCloud Security FundamentalsCloud Security Best PracticesContainer Security — Information SecurityData Security in the CloudCloud Identity and Access ManagementKubernetes SecurityShared Responsibility Model — Information SecurityIntroduction to Digital ForensicsDisk ForensicsDigital Evidence CollectionDigital Forensic ToolsIncident Investigation ProceduresMemory ForensicsNetwork ForensicsContainment StrategiesDetection and Analysis PhaseEradication and RecoveryIntroduction to Incident ResponseIncident Response LifecycleIncident Response PlaybooksPost-Incident Review and Lessons LearnedBusiness Continuity PlanningDisaster Recovery PlanningRisk Assessment MethodologyIntroduction to Risk ManagementSecurity ControlsThreat ModelingVulnerability AssessmentCompliance ManagementGDPR Data Protection OverviewISO 27001 Information Security ManagementNIST Cybersecurity FrameworkSecurity Audits and AssessmentsSecurity GovernanceSecurity Policies and StandardsCloud Security Interview QuestionsCryptography Interview QuestionsInformation Security CheatsheetInformation Security Interview QuestionsNetwork Security Interview QuestionsGlossary of Information Security TermsImportant Security Concepts ReferenceRecommended Books and Learning ResourcesSecurity Tools OverviewIncident Response LabLog Analysis ProjectNetwork Monitoring ProjectPassword Manager ProjectSecure Login System ProjectVulnerability Scanner ProjectInsider ThreatsMalware Types and AnalysisPhishing Attacks and PreventionRansomware AttacksSecurity Threats OverviewSocial Engineering AttacksSpyware and Surveillance SoftwareTrojan Horse MalwareComputer VirusesNetwork Worms
Deep dive into HTTPS, SSL/TLS protocol handshake, certificate verification, cipher suites, and secure transport layer communication.
What is HTTPS?
HTTPS (HTTP Secure) is HTTP over TLS (Transport Layer Security). It provides encrypted communication between a client (browser) and server, preventing eavesdropping, tampering, and impersonation.
TLS 1.3 Handshake
Example
TLS 1.3 Handshake (1-RTT):
==============================
Client Server
| |
| 1. ClientHello |
| - Supported cipher suites |
| - Key share (ECDHE public key) |
| - Supported versions (TLS 1.3) |
|---------------------------------------->|
| |
| 2. ServerHello |
| - Chosen cipher suite |
| - Server key share |
| - {EncryptedExtensions} |
| - {Certificate} |
| - {CertificateVerify} |
| - {Finished} |
|<----------------------------------------|
| |
| 3. {Finished} |
|---------------------------------------->|
| |
|<======= Application Data (encrypted) =======>|
| |
Key features of TLS 1.3:
- Only 1 round trip (vs 2 in TLS 1.2)
- 0-RTT resumption available (with replay risk)
- Only secure cipher suites (no RSA key exchange)
- Forward secrecy mandatory (ECDHE only)
- Removed: RSA key exchange, CBC mode, RC4, SHA-1, etc.
TLS 1.3 Cipher Suites
| Cipher Suite | Key Exchange | Authentication | Encryption | Hash |
|---|---|---|---|---|
| TLS_AES_256_GCM_SHA384 | ECDHE | Certificate | AES-256-GCM | SHA-384 |
| TLS_AES_128_GCM_SHA256 | ECDHE | Certificate | AES-128-GCM | SHA-256 |
| TLS_CHACHA20_POLY1305_SHA256 | ECDHE | Certificate | ChaCha20-Poly1305 | SHA-256 |
Certificate Verification Process
Example
import ssl
import socket
from datetime import datetime
def check_tls_connection(hostname: str, port: int = 443) -> dict:
"""Analyze TLS connection and certificate."""
context = ssl.create_default_context()
with socket.create_connection((hostname, port)) as sock:
with context.wrap_socket(sock, server_hostname=hostname) as ssock:
cert = ssock.getpeercert()
cipher = ssock.cipher()
version = ssock.version()
# Parse certificate
subject = dict(x[0] for x in cert['subject'])
issuer = dict(x[0] for x in cert['issuer'])
return {
"hostname": hostname,
"tls_version": version,
"cipher_suite": cipher[0],
"key_size": cipher[2],
"subject": subject.get('commonName'),
"issuer": issuer.get('organizationName'),
"valid_from": cert['notBefore'],
"valid_until": cert['notAfter'],
"san": [entry[1] for entry in cert.get('subjectAltName', [])],
}
# Example usage
info = check_tls_connection("www.google.com")
for key, value in info.items():
print(f" {key}: {value}")
Common TLS Vulnerabilities
| Vulnerability | Year | Impact | Prevention |
|---|---|---|---|
| BEAST | 2011 | CBC mode attack in TLS 1.0 | Use TLS 1.2+ |
| CRIME | 2012 | Compression reveals secrets | Disable TLS compression |
| Heartbleed | 2014 | OpenSSL memory leak | Patch OpenSSL, revoke certs |
| POODLE | 2014 | SSLv3 padding oracle | Disable SSLv3 |
| DROWN | 2016 | SSLv2 cross-protocol attack | Disable SSLv2 everywhere |
| ROBOT | 2017 | RSA key exchange vulnerability | Use ECDHE only (TLS 1.3) |
HSTS (HTTP Strict Transport Security)
HSTS Header
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
Effect
- Browser remembers to always use HTTPS for this domain
- Prevents SSL stripping attacks
- Converts any HTTP links to HTTPS before requesting
- preload: Added to browser's built-in HSTS list
Interview Questions
- Explain the TLS 1.3 handshake and how it differs from TLS 1.2.
- TLS 1.3 completes in 1 round trip (vs 2 for TLS 1.2). The client sends key shares in ClientHello (speculating which algorithm server will choose). TLS 1.3 removed insecure options (RSA key exchange, CBC), requires forward secrecy, and encrypts more of the handshake.
- What is forward secrecy and why does TLS 1.3 mandate it?
- Forward secrecy (via ephemeral ECDHE) means each session uses unique temporary keys that are discarded after use. If the server's long-term private key is later compromised, past recorded sessions cannot be decrypted. TLS 1.3 mandates it by removing RSA key exchange.
- What was the Heartbleed vulnerability and why was it so severe?
- A bug in OpenSSL's heartbeat extension allowed attackers to read up to 64KB of server memory per request, potentially exposing private keys, session tokens, and user data. Severity: no authentication needed, no logs generated, widespread (17% of TLS servers affected).
- How does HSTS prevent SSL stripping attacks?
- Without HSTS, an attacker can intercept the initial HTTP request and prevent the redirect to HTTPS (Moxie Marlinspike's sslstrip tool). HSTS tells the browser to always use HTTPS, even for the first request. With preloading, the browser knows to use HTTPS before ever contacting the server.
- Why was RSA key exchange removed from TLS 1.3?
- RSA key exchange doesn't provide forward secrecy: the session key is encrypted with the server's RSA key and sent. If that RSA key is ever compromised, all past sessions can be decrypted. ECDHE creates ephemeral keys per session, discarded immediately after.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for HTTPS and SSL/TLS.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Information Security topic.
Search Terms
information-security, information security, information, security, web, https, and, ssl
Related Information Security Topics
Continue learning this concept
Web SecurityWeb Authentication MechanismsComprehensive guide to web authentication including sessions, JWT, OAuth 2.0, and passwordless authentication methods.Web SecurityCross-Site Scripting (XSS)Complete guide to XSS vulnerabilities including reflected, stored, and DOM-based XSS attacks with prevention techniques, CSP headers, and practical exploitation examples.Web SecurityCross-Site Request Forgery (CSRF)Understanding CSRF attacks, how they exploit authenticated sessions, prevention with tokens and SameSite cookies, and implementing anti-CSRF protection.Web SecurityFile Upload SecuritySecuring file upload features against malicious uploads including shell injection, path traversal, MIME type attacks, and implementing proper server-side validation.Web SecuritySecure Coding Practices — Information SecurityEssential secure coding practices for web developers covering input validation, output encoding, error handling, and OWASP guidelines for building resilient applications.Web SecuritySession Management SecurityBest practices for secure session management including token generation, cookie attributes, fixation prevention, and timeout strategies.