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
Understanding PKI components including Certificate Authorities, digital certificates, certificate lifecycle, revocation, and how PKI enables trust on the internet.
What is PKI?
Public Key Infrastructure (PKI) is a framework of roles, policies, hardware, software, and procedures needed to create, manage, distribute, use, store, and revoke digital certificates. PKI binds public keys to identities, enabling trusted communication between parties who have never met.
| Registration | Certificate | Revocation | ||
|---|---|---|---|---|
| Authority (RA) | Repository | Service | ||
| - Verifies | - LDAP/HTTP | - CRL | ||
| applicant | - Distributes | - OCSP | ||
| identity | certificates |
PKI Ecosystem
v v v
v v
X.509 Certificate Structure
| | Version | v3 | |
| | Serial Number | 0x01A2B3C4... | |
| | Signature Algorithm | SHA256withRSA | |
| | Issuer | CN=DigiCert, O=DigiCert Inc, C=US | |
| | Validity | | |
| | Not Before | Jan 1, 2024 00:00:00 UTC | |
| | Not After | Jan 1, 2025 23:59:59 UTC | |
| | Subject | CN=www.example.com, O=Example Inc | |
| | Subject Public Key Info | | |
| | Algorithm | RSA (2048 bits) | |
| | Public Key | 30820122300d06092a86... | |
| | Extensions | | |
| | Subject Alt Names | example.com, *.example.com| |
| | Key Usage | Digital Signature, Key Encipherment| |
| | Extended Key Usage | TLS Web Server Auth | |
| | CRL Distribution Points | http://crl.digicert.com| |
| | Authority Info Access (OCSP) | http://ocsp...| |
| | CA Signature | RSA-SHA256 signature over above | |
Certificate Types
| Type | Validation Level | What's Verified | Visual Indicator |
|---|---|---|---|
| DV (Domain Validation) | Low | Domain ownership only | Padlock |
| OV (Organization Validation) | Medium | Domain + organization identity | Padlock + org name |
| EV (Extended Validation) | High | Domain + legal identity + physical address | Green bar (legacy) |
| Self-signed | None | Nothing (self-issued) | Browser warning |
Certificate Lifecycle
Certificate Lifecycle
========================
1. KEY GENERATION
Applicant generates key pair (private + public)
2. CERTIFICATE SIGNING REQUEST (CSR)
Applicant creates CSR containing
- Public key
- Subject information (domain, org)
- Signature (proves possession of private key)
3. IDENTITY VERIFICATION
CA/RA verifies applicant's identity
- DV: Domain control check (DNS/HTTP)
- OV: Business registration documents
- EV: Legal documents, physical verification
4. CERTIFICATE ISSUANCE
CA signs the certificate with CA's private key
Certificate published to repository
5. CERTIFICATE USE
Server presents certificate to clients
Clients verify signature chain to trusted root
6. CERTIFICATE RENEWAL
Before expiration, request new certificate
Re-verification may be required
7. CERTIFICATE REVOCATION (if compromised)
CA adds to CRL or OCSP responds "revoked"
Must happen immediately upon key compromise
Python: Working with Certificates
Example
from cryptography import x509
from cryptography.x509.oid import NameOID, ExtensionOID
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from datetime import datetime, timedelta
class PKIDemo:
"""Demonstrate PKI operations."""
def generate_self_signed_cert(self, common_name: str, days_valid: int = 365):
"""Generate a self-signed certificate (for testing only)."""
# Generate key pair
key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
# Build certificate
subject = issuer = x509.Name([
x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Example Corp"),
x509.NameAttribute(NameOID.COMMON_NAME, common_name),
])
cert = (
x509.CertificateBuilder()
.subject_name(subject)
.issuer_name(issuer)
.public_key(key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(datetime.utcnow())
.not_valid_after(datetime.utcnow() + timedelta(days=days_valid))
.add_extension(
x509.SubjectAlternativeName([
x509.DNSName(common_name),
x509.DNSName(f"*.{common_name}"),
]),
critical=False,
)
.add_extension(
x509.BasicConstraints(ca=False, path_length=None),
critical=True,
)
.sign(key, hashes.SHA256())
)
return cert, key
def generate_csr(self, common_name: str, organization: str):
"""Generate a Certificate Signing Request."""
key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
csr = (
x509.CertificateSigningRequestBuilder()
.subject_name(x509.Name([
x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
x509.NameAttribute(NameOID.ORGANIZATION_NAME, organization),
x509.NameAttribute(NameOID.COMMON_NAME, common_name),
]))
.add_extension(
x509.SubjectAlternativeName([
x509.DNSName(common_name),
]),
critical=False,
)
.sign(key, hashes.SHA256())
)
return csr, key
def display_cert_info(self, cert):
"""Display certificate information."""
print(f"Subject: {cert.subject.rfc4514_string()}")
print(f"Issuer: {cert.issuer.rfc4514_string()}")
print(f"Serial: {cert.serial_number}")
print(f"Valid from: {cert.not_valid_before_utc}")
print(f"Valid until: {cert.not_valid_after_utc}")
print(f"Signature algorithm: {cert.signature_algorithm_oid._name}")
# Demo
pki = PKIDemo()
cert, key = pki.generate_self_signed_cert("www.example.com")
print("Generated Self-Signed Certificate:")
pki.display_cert_info(cert)
Certificate Revocation
CRL (Certificate Revocation List)
- CA publishes a signed list of revoked serial numbers
- Clients download periodically and check against it
- Drawback: Can be large and stale between updates
OCSP (Online Certificate Status Protocol)
- Real-time query to CA: "Is certificate #X still valid?"
- Response: Good / Revoked / Unknown
- OCSP Stapling: Server includes fresh OCSP response in TLS handshake
Example
OCSP Flow:
============
Client Server OCSP Responder
| | |
|-- TLS ClientHello ---->| |
| |-- OCSP Request ------>|
| |<-- OCSP Response -----|
|<- Certificate + OCSP --| (signed, timestamped)|
| | |
| Verify: cert valid + not revoked |
Interview Questions
- What is the difference between a CA, RA, and end entity in PKI?
- CA (Certificate Authority) issues and signs certificates. RA (Registration Authority) verifies the identity of certificate applicants before the CA issues the cert. End entities are users or servers that use certificates for authentication and encryption.
- What happens if a Certificate Authority is compromised?
- All certificates issued by that CA become untrustworthy. The CA's certificate is added to browsers' distrust lists, all issued certificates must be revoked and reissued by another CA. Historical example: DigiNotar (2011) was completely shut down after compromise.
- Explain the difference between CRL and OCSP for certificate revocation.
- CRL is a periodically published list of all revoked certificates (can be large, may be stale). OCSP provides real-time per-certificate status queries (fresher but requires connectivity). OCSP Stapling solves OCSP privacy and performance concerns by having the server fetch and cache the response.
- Why do browsers trust certificates from CAs they've never interacted with?
- Browsers ship with a pre-installed list of trusted root CA certificates (trust store). When a server presents a certificate signed by one of these roots (or its intermediates), the browser trusts it. This is called the "Web PKI trust model."
- What is Certificate Transparency and why was it introduced?
- CT requires CAs to publicly log all issued certificates to append-only logs. This allows domain owners to detect unauthorized certificates for their domains and provides public accountability for CAs. Introduced after incidents where CAs issued fraudulent certificates.
Summary
PKI is the trust infrastructure that makes secure internet communication possible. It binds public keys to verified identities through digital certificates, enabling TLS, code signing, email encryption, and document signing. Understanding PKI components, certificate lifecycle, and revocation mechanisms is essential for any security professional.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Public Key Infrastructure (PKI).
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, cryptography, public, key, infrastructure
Related Information Security Topics
Continue learning this concept
CryptographyAsymmetric Key CryptographyDeep dive into public key cryptography covering RSA, ECC, Diffie-Hellman key exchange, digital signatures, and how asymmetric algorithms solve the key distribution problem.CryptographySymmetric Key CryptographyComplete guide to symmetric key cryptography covering block ciphers, stream ciphers, modes of operation, key management, and practical implementations with AES and ChaCha20.CryptographyAES - Advanced Encryption StandardComplete guide to the AES algorithm covering its structure, rounds, key expansion, modes of operation, implementation in Python, and why AES replaced DES as the global encryption standard.CryptographyDES - Data Encryption StandardUnderstanding the Data Encryption Standard (DES), its Feistel structure, historical significance, vulnerabilities, evolution to 3DES, and why it was replaced by AES.CryptographyDigital SignaturesComplete guide to digital signatures covering RSA and ECDSA signing, verification process, certificate chains, applications in code signing and documents, with Python implementations.CryptographyEncryption vs DecryptionUnderstanding the fundamental processes of encryption and decryption, their differences, step-by-step operations, and practical applications in modern information security.