SSL Sertifikası Süre Takibi ve Uyarı Sistemi Kurulumu

yazar

Bir sabah işe geldiğinizde müşterilerinizden “siteniz güvenli değil” diye mesaj almak, sysadmin kariyerinin en kötü anlarından biridir. SSL sertifikası süresi dolmuş, tarayıcılar büyük kırmızı uyarılar gösteriyor ve panik başlamıştır. Oysa bu tamamen önlenebilir bir durumdur. Bu yazıda, SSL sertifikalarınızı izlemek ve süreleri dolmadan önce uyarı almak için sağlam bir sistem kuracağız.

Neden SSL Sertifika Takibi Kritik?

Let’s Encrypt’in yaygınlaşmasıyla birlikte 90 günlük sertifikalar hayatımıza girdi. Eskiden yılda bir yenilediğimiz sertifikaları artık çok daha sık takip etmemiz gerekiyor. Üstelik birden fazla domain yönetiyorsanız, hangi sertifikanın ne zaman dolacağını aklınızda tutmak neredeyse imkansız.

Gerçek dünyadan bir örnek verelim: 50 farklı müşteriye ait 120 domain yönettiğinizi düşünün. Her birinin farklı CA’lardan alınmış, farklı tarihlerde dolan sertifikaları var. Bu tabloyu manuel takip etmeye çalışmak hem yorucu hem de hata yapmaya açık bir süreç.

Doğru bir izleme sistemi şunları yapmalıdır:

  • Sertifika son kullanma tarihini düzenli kontrol etmeli
  • Belirli gün eşiklerinde (30, 14, 7 gün gibi) uyarı göndermeli
  • Hem web üzerinden erişilen hem de yerel dosya sistemindeki sertifikaları takip etmeli
  • E-posta, Slack veya Teams gibi kanallara bildirim gönderebilmeli
  • Cron job ile otomatik çalışmalı

Temel Araç: OpenSSL ile Sertifika Bilgisi Çekme

Her şeyden önce, bir sertifikanın ne zaman dolacağını nasıl öğreneceğimizi anlamamız gerekiyor.

# Uzak bir sunucunun SSL sertifika bilgisini çek
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | openssl x509 -noout -dates

# Sadece son kullanma tarihini göster
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | openssl x509 -noout -enddate

# Yerel sertifika dosyasını kontrol et
openssl x509 -noout -enddate -in /etc/ssl/certs/mycert.pem

# Sertifikanın kaç gün kaldığını hesapla
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | 
  openssl x509 -noout -checkend $((30*86400)) && echo "30 gün yeterli" || echo "30 günden az kaldı"

-checkend parametresi son derece kullanışlıdır. Verilen saniye cinsinden süre içinde sertifikanın dolup dolmayacağını kontrol eder, 0 döndürürse geçerli, 1 döndürürse süre dolmuş demektir.

Basit Bash Script ile Başlangıç

Küçük ortamlar için basit ama etkili bir script yazalım.

#!/bin/bash
# ssl_check.sh - SSL Sertifika Süre Kontrol Scripti
# Konum: /usr/local/bin/ssl_check.sh

DOMAINS=(
    "example.com:443"
    "mail.example.com:443"
    "api.example.com:8443"
    "shop.example.com:443"
)

WARN_DAYS=30
CRITICAL_DAYS=7
EMAIL="[email protected]"
LOG_FILE="/var/log/ssl_check.log"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

check_cert() {
    local host=$1
    local port=$2
    
    # Sertifika son tarihini al
    local end_date
    end_date=$(echo | openssl s_client -servername "$host" -connect "$host:$port" 2>/dev/null | 
        openssl x509 -noout -enddate 2>/dev/null | cut -d= -f2)
    
    if [ -z "$end_date" ]; then
        log "HATA: $host:$port - Sertifika bilgisi alınamadı"
        return 2
    fi
    
    # Kalan gün sayısını hesapla
    local end_epoch
    end_epoch=$(date -d "$end_date" +%s 2>/dev/null || date -j -f "%b %d %T %Y %Z" "$end_date" +%s)
    local now_epoch
    now_epoch=$(date +%s)
    local days_left=$(( (end_epoch - now_epoch) / 86400 ))
    
    if [ "$days_left" -le "$CRITICAL_DAYS" ]; then
        log "KRİTİK: $host:$port - $days_left gün kaldı! (Son tarih: $end_date)"
        send_alert "KRİTİK" "$host" "$port" "$days_left" "$end_date"
        return 1
    elif [ "$days_left" -le "$WARN_DAYS" ]; then
        log "UYARI: $host:$port - $days_left gün kaldı (Son tarih: $end_date)"
        send_alert "UYARI" "$host" "$port" "$days_left" "$end_date"
        return 1
    else
        log "OK: $host:$port - $days_left gün geçerli"
        return 0
    fi
}

send_alert() {
    local severity=$1
    local host=$2
    local port=$3
    local days=$4
    local end_date=$5
    
    local subject="[$severity] SSL Sertifikası Uyarısı: $host"
    local body="Sunucu: $host:$portnKalan Gün: $daysnSon Kullanma: $end_datennLütfen sertifikayı yenileyin."
    
    echo -e "$body" | mail -s "$subject" "$EMAIL"
}

# Ana döngü
log "=== SSL Kontrol Başladı ==="
for domain_port in "${DOMAINS[@]}"; do
    host=$(echo "$domain_port" | cut -d: -f1)
    port=$(echo "$domain_port" | cut -d: -f2)
    check_cert "$host" "$port"
    sleep 1  # Rate limiting
done
log "=== SSL Kontrol Tamamlandı ==="

Bu script’i çalıştırılabilir hale getirip cron’a ekleyelim:

chmod +x /usr/local/bin/ssl_check.sh

# Her gün sabah 08:00'de çalıştır
crontab -e
# Şu satırı ekle:
# 0 8 * * * /usr/local/bin/ssl_check.sh

Gelişmiş Script: Çoklu Bildirim Kanalları

Büyük ortamlarda sadece e-posta yeterli olmayabilir. Slack entegrasyonlu, daha kapsamlı bir versiyona geçelim.

#!/bin/bash
# ssl_monitor_advanced.sh - Gelişmiş SSL İzleme Sistemi

# Konfigürasyon
CONFIG_FILE="/etc/ssl_monitor/config.conf"
DOMAINS_FILE="/etc/ssl_monitor/domains.txt"
LOG_FILE="/var/log/ssl_monitor/ssl_monitor.log"
STATE_FILE="/var/lib/ssl_monitor/last_alerts.db"

# Slack webhook URL (config'den okunacak)
SLACK_WEBHOOK=""
EMAIL_TO=""
WARN_DAYS=30
CRITICAL_DAYS=7

# Config dosyasını yükle
load_config() {
    if [ -f "$CONFIG_FILE" ]; then
        source "$CONFIG_FILE"
    else
        echo "Config dosyası bulunamadı: $CONFIG_FILE"
        exit 1
    fi
}

send_slack() {
    local severity=$1
    local message=$2
    local color
    
    [ "$severity" = "KRİTİK" ] && color="#FF0000" || color="#FFA500"
    
    if [ -n "$SLACK_WEBHOOK" ]; then
        curl -s -X POST "$SLACK_WEBHOOK" 
            -H 'Content-type: application/json' 
            --data "{
                "attachments": [{
                    "color": "$color",
                    "title": "SSL Sertifika Uyarısı - $severity",
                    "text": "$message",
                    "footer": "SSL Monitor | $(hostname)",
                    "ts": $(date +%s)
                }]
            }" > /dev/null
    fi
}

# Daha önce uyarı gönderilip gönderilmediğini kontrol et (spam önleme)
should_alert() {
    local domain=$1
    local days=$2
    local today
    today=$(date +%Y-%m-%d)
    
    mkdir -p "$(dirname "$STATE_FILE")"
    touch "$STATE_FILE"
    
    local last_alert
    last_alert=$(grep "^$domain:" "$STATE_FILE" 2>/dev/null | cut -d: -f2)
    
    if [ "$last_alert" != "$today" ]; then
        sed -i "/^$domain:/d" "$STATE_FILE"
        echo "$domain:$today:$days" >> "$STATE_FILE"
        return 0  # Uyarı gönder
    fi
    return 1  # Bugün zaten uyarı gönderildi
}

load_config

Bu yapıyı kullanmak için konfig dosyasını da oluşturalım:

# /etc/ssl_monitor/config.conf örneği
mkdir -p /etc/ssl_monitor /var/log/ssl_monitor /var/lib/ssl_monitor

cat > /etc/ssl_monitor/config.conf << 'EOF'
SLACK_WEBHOOK="https://hooks.slack.com/services/TXXXXXXXX/BXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXXX"
EMAIL_TO="[email protected],[email protected]"
WARN_DAYS=30
CRITICAL_DAYS=7
TIMEOUT=10
EOF

# domains.txt formatı: host:port:etiket
cat > /etc/ssl_monitor/domains.txt << 'EOF'
example.com:443:Production Web
api.example.com:443:API Gateway
mail.example.com:465:Mail Sunucu
vpn.example.com:443:VPN Portal
staging.example.com:443:Staging
EOF

Python ile Daha Güçlü Bir Çözüm

Bash scriptleri hızlı ve hafif olsa da, Python daha iyi hata yönetimi ve paralel kontrol imkanı sunar.

#!/usr/bin/env python3
# ssl_checker.py - Python tabanlı SSL izleme aracı

import ssl
import socket
import datetime
import smtplib
import json
import sys
import concurrent.futures
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from pathlib import Path

class SSLChecker:
    def __init__(self, config_file="/etc/ssl_monitor/config.json"):
        with open(config_file) as f:
            self.config = json.load(f)
        
        self.warn_days = self.config.get("warn_days", 30)
        self.critical_days = self.config.get("critical_days", 7)
        self.results = []

    def get_cert_expiry(self, hostname, port=443):
        """Sertifika son kullanma tarihini döndür"""
        context = ssl.create_default_context()
        timeout = self.config.get("timeout", 10)
        
        try:
            conn = context.wrap_socket(
                socket.create_connection((hostname, port), timeout=timeout),
                server_hostname=hostname
            )
            cert = conn.getpeercert()
            conn.close()
            
            expire_date = datetime.datetime.strptime(
                cert['notAfter'], 
                "%b %d %H:%M:%S %Y %Z"
            )
            days_left = (expire_date - datetime.datetime.utcnow()).days
            
            return {
                "hostname": hostname,
                "port": port,
                "expire_date": expire_date.strftime("%Y-%m-%d"),
                "days_left": days_left,
                "status": self._get_status(days_left),
                "error": None
            }
        except Exception as e:
            return {
                "hostname": hostname,
                "port": port,
                "expire_date": None,
                "days_left": None,
                "status": "ERROR",
                "error": str(e)
            }

    def _get_status(self, days_left):
        if days_left <= self.critical_days:
            return "CRITICAL"
        elif days_left <= self.warn_days:
            return "WARNING"
        return "OK"

    def check_all(self):
        """Tüm domainleri paralel olarak kontrol et"""
        domains = self.config.get("domains", [])
        
        with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
            futures = {
                executor.submit(
                    self.get_cert_expiry, 
                    d["host"], 
                    d.get("port", 443)
                ): d for d in domains
            }
            
            for future in concurrent.futures.as_completed(futures):
                result = future.result()
                self.results.append(result)
                
                if result["status"] in ["CRITICAL", "WARNING"]:
                    self.send_notification(result)
        
        return self.results

    def send_notification(self, result):
        """E-posta bildirimi gönder"""
        smtp_config = self.config.get("smtp", {})
        if not smtp_config:
            return
            
        subject = f"[{result['status']}] SSL: {result['hostname']} - {result['days_left']} gün kaldı"
        body = f"""
SSL Sertifika Uyarısı

Sunucu  : {result['hostname']}:{result['port']}
Durum   : {result['status']}
Son Tarih: {result['expire_date']}
Kalan   : {result['days_left']} gün

Lütfen sertifikayı en kısa sürede yenileyin.
        """
        
        msg = MIMEMultipart()
        msg['Subject'] = subject
        msg['From'] = smtp_config.get("from")
        msg['To'] = ", ".join(self.config.get("alert_emails", []))
        msg.attach(MIMEText(body, 'plain', 'utf-8'))
        
        try:
            with smtplib.SMTP(smtp_config["host"], smtp_config.get("port", 587)) as server:
                server.starttls()
                server.login(smtp_config["user"], smtp_config["password"])
                server.send_message(msg)
        except Exception as e:
            print(f"E-posta gönderilemedi: {e}", file=sys.stderr)

if __name__ == "__main__":
    checker = SSLChecker()
    results = checker.check_all()
    
    # Özet rapor
    critical = [r for r in results if r["status"] == "CRITICAL"]
    warning = [r for r in results if r["status"] == "WARNING"]
    ok = [r for r in results if r["status"] == "OK"]
    errors = [r for r in results if r["status"] == "ERROR"]
    
    print(f"n=== SSL Kontrol Özeti ===")
    print(f"Toplam: {len(results)} | OK: {len(ok)} | Uyarı: {len(warning)} | Kritik: {len(critical)} | Hata: {len(errors)}")
    
    if critical or warning:
        print("nDikkat Gerektiren Sertifikalar:")
        for r in sorted(critical + warning, key=lambda x: x.get("days_left", 999)):
            print(f"  [{r['status']}] {r['hostname']}:{r['port']} - {r['days_left']} gün")
    
    sys.exit(1 if critical else 0)

Nagios/Zabbix Entegrasyonu

Zaten bir izleme altyapınız varsa, bu sistemi ona entegre etmek mantıklıdır.

#!/bin/bash
# check_ssl_cert.sh - Nagios/Icinga uyumlu SSL kontrol plugin'i
# Konum: /usr/lib/nagios/plugins/check_ssl_cert.sh

PROGNAME=$(basename "$0")
WARN_DAYS=30
CRITICAL_DAYS=14

usage() {
    echo "Kullanım: $PROGNAME -H hostname [-p port] [-w warn_days] [-c critical_days]"
    exit 3
}

# Parametreleri parse et
while getopts "H:p:w:c:" opt; do
    case $opt in
        H) HOST="$OPTARG" ;;
        p) PORT="$OPTARG" ;;
        w) WARN_DAYS="$OPTARG" ;;
        c) CRITICAL_DAYS="$OPTARG" ;;
        *) usage ;;
    esac
done

[ -z "$HOST" ] && usage
PORT=${PORT:-443}

# Sertifika kontrolü
END_DATE=$(echo | timeout 10 openssl s_client -servername "$HOST" 
    -connect "$HOST:$PORT" 2>/dev/null | 
    openssl x509 -noout -enddate 2>/dev/null | cut -d= -f2)

if [ -z "$END_DATE" ]; then
    echo "UNKNOWN: $HOST:$PORT sertifikası okunamadı"
    exit 3
fi

END_EPOCH=$(date -d "$END_DATE" +%s)
NOW_EPOCH=$(date +%s)
DAYS_LEFT=$(( (END_EPOCH - NOW_EPOCH) / 86400 ))

# Nagios çıkış kodları: 0=OK, 1=WARNING, 2=CRITICAL, 3=UNKNOWN
if [ "$DAYS_LEFT" -le "$CRITICAL_DAYS" ]; then
    echo "CRITICAL: $HOST sertifikası $DAYS_LEFT gün sonra doluyor (${END_DATE})|days_left=$DAYS_LEFT;$WARN_DAYS;$CRITICAL_DAYS;0"
    exit 2
elif [ "$DAYS_LEFT" -le "$WARN_DAYS" ]; then
    echo "WARNING: $HOST sertifikası $DAYS_LEFT gün sonra doluyor (${END_DATE})|days_left=$DAYS_LEFT;$WARN_DAYS;$CRITICAL_DAYS;0"
    exit 1
else
    echo "OK: $HOST sertifikası geçerli, $DAYS_LEFT gün kaldı|days_left=$DAYS_LEFT;$WARN_DAYS;$CRITICAL_DAYS;0"
    exit 0
fi

Sistemin Kurulumu ve Otomasyonu

Tüm bu parçaları bir araya getirelim.

# Dizin yapısını oluştur
mkdir -p /etc/ssl_monitor
mkdir -p /var/log/ssl_monitor
mkdir -p /var/lib/ssl_monitor

# Script'leri kopyala ve izinleri ayarla
cp ssl_check.sh /usr/local/bin/
chmod 750 /usr/local/bin/ssl_check.sh
chown root:sysadmin /usr/local/bin/ssl_check.sh

# Python script için virtual environment
python3 -m venv /opt/ssl_monitor
source /opt/ssl_monitor/bin/activate
pip install requests cryptography

# Log rotasyonu ayarla
cat > /etc/logrotate.d/ssl_monitor << 'EOF'
/var/log/ssl_monitor/*.log {
    daily
    rotate 30
    compress
    delaycompress
    missingok
    notifempty
    create 640 root sysadmin
}
EOF

# Systemd timer ile çalıştır (cron'a göre daha güvenilir)
cat > /etc/systemd/system/ssl-monitor.service << 'EOF'
[Unit]
Description=SSL Sertifika İzleme
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
User=root
ExecStart=/usr/local/bin/ssl_check.sh
StandardOutput=append:/var/log/ssl_monitor/ssl_monitor.log
StandardError=append:/var/log/ssl_monitor/ssl_monitor_error.log
EOF

cat > /etc/systemd/system/ssl-monitor.timer << 'EOF'
[Unit]
Description=SSL Sertifika İzleme Timer
Requires=ssl-monitor.service

[Timer]
OnCalendar=*-*-* 08:00:00
Persistent=true

[Install]
WantedBy=timers.target
EOF

systemctl daemon-reload
systemctl enable ssl-monitor.timer
systemctl start ssl-monitor.timer

# Timer durumunu kontrol et
systemctl list-timers ssl-monitor.timer

Wildcard ve SAN Sertifikaları

Tek bir sertifika birden fazla domaini kapsıyorsa (SAN), hangi domainlerin kapsandığını kontrol etmek de önemlidir.

# SAN (Subject Alternative Names) listesini göster
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | 
    openssl x509 -noout -text | grep -A1 "Subject Alternative Name"

# Sertifikanın tüm detaylarını tek komutla özetle
check_cert_details() {
    local HOST=$1
    local PORT=${2:-443}
    
    local CERT_INFO
    CERT_INFO=$(echo | openssl s_client -servername "$HOST" -connect "$HOST:$PORT" 2>/dev/null)
    
    echo "=== $HOST:$PORT ==="
    echo "$CERT_INFO" | openssl x509 -noout -subject -issuer -dates
    echo "SAN Listesi:"
    echo "$CERT_INFO" | openssl x509 -noout -text 2>/dev/null | 
        grep -A1 "Subject Alternative" | tail -1 | 
        tr ',' 'n' | sed 's/DNS://g' | sed 's/ //g'
    echo ""
}

# Kullanım
check_cert_details "example.com" 443

Gerçek Dünya Senaryosu: Çok Katmanlı Alarm Sistemi

Üretim ortamında farklı ekiplerin farklı konular hakkında bilgilendirilmesi gerekebilir.

#!/bin/bash
# Çok katmanlı bildirim sistemi

DAYS_LEFT=$1
HOST=$2

notify_by_severity() {
    local days=$1
    local host=$2
    
    if [ "$days" -le 3 ]; then
        # Kritik: Tüm kanallar + SMS (örn. via Twilio/SNS)
        send_email "ACIL" "$host" "$days" "[email protected],[email protected]"
        send_slack "#incidents" "ACIL" "$host" "$days"
        send_pagerduty "$host" "$days"
        
    elif [ "$days" -le 7 ]; then
        # Ciddi: E-posta + Slack
        send_email "KRİTİK" "$host" "$days" "[email protected]"
        send_slack "#ssl-alerts" "KRİTİK" "$host" "$days"
        
    elif [ "$days" -le 14 ]; then
        # Uyarı: Sadece Slack
        send_slack "#ssl-alerts" "UYARI" "$host" "$days"
        
    elif [ "$days" -le 30 ]; then
        # Bilgi: Haftalık özet rapor için log'a ekle
        echo "$host:$days" >> /var/lib/ssl_monitor/upcoming_renewals.txt
    fi
}

send_pagerduty() {
    local host=$1
    local days=$2
    local PD_KEY=$(grep PAGERDUTY_KEY /etc/ssl_monitor/config.conf | cut -d= -f2)
    
    curl -s -X POST https://events.pagerduty.com/v2/enqueue 
        -H "Content-Type: application/json" 
        -d "{
            "routing_key": "$PD_KEY",
            "event_action": "trigger",
            "payload": {
                "summary": "SSL Sertifikası $days gün içinde doluyor: $host",
                "severity": "critical",
                "source": "$(hostname)"
            }
        }" > /dev/null
}

Haftalık Özet Raporu

Günlük uyarıların yanı sıra, her Pazartesi gönderilen bir haftalık durum raporu da son derece işe yarar.

#!/bin/bash
# weekly_ssl_report.sh - Haftalık SSL durum raporu

DOMAINS_FILE="/etc/ssl_monitor/domains.txt"
REPORT_EMAIL="[email protected],[email protected]"

generate_report() {
    local report=""
    local critical_list=""
    local warning_list=""
    local ok_list=""
    
    while IFS=: read -r host port label; do
        [ -z "$host" ] && continue
        [ "${host:0:1}" = "#" ] && continue
        
        port=${port:-443}
        
        local end_date
        end_date=$(echo | openssl s_client -servername "$host" 
            -connect "$host:$port" 2>/dev/null | 
            openssl x509 -noout -enddate 2>/dev/null | cut -d= -f2)
        
        if [ -z "$end_date" ]; then
            critical_list+="HATA - $label ($host:$port) - Bağlantı kurulamadın"
            continue
        fi
        
        local end_epoch now_epoch days_left
        end_epoch=$(date -d "$end_date" +%s)
        now_epoch=$(date +%s)
        days_left=$(( (end_epoch - now_epoch) / 86400 ))
        
        if [ "$days_left" -le 7 ]; then
            critical_list+="KRİTİK - $label ($host:$port) - $days_left gün - $end_daten"
        elif [ "$days_left" -le 30 ]; then
            warning_list+="UYARI  - $label ($host:$port) - $days_left gün - $end_daten"
        else
            ok_list+="OK     - $label ($host:$port) - $days_left gün - $end_daten"
        fi
        
        sleep 0.5
    done < "$DOMAINS_FILE"
    
    report="SSL Sertifika Haftalık Durum Raporun"
    report+="Tarih: $(date '+%d.%m.%Y %H:%M')n"
    report+="Sunucu: $(hostname)n"
    report+="==========================================nn"
    
    [ -n "$critical_list" ] && report+="KRİTİK DURUMLAR:n$critical_listn"
    [ -n "$warning_list" ] && report+="UYARILAR:n$warning_listn"
    [ -n "$ok_list" ] && report+="NORMAL DURUMLAR:n$ok_listn"
    
    echo -e "$report" | mail -s "[SSL Rapor] Haftalık Sertifika Durum Özeti - $(date '+%d.%m.%Y')" "$REPORT_EMAIL"
}

generate_report

Cron’a haftalık raporu eklemek için:

# Her Pazartesi sabah 07:30'da haftalık rapor gönder
30 7 * * 1 /usr/local/bin/weekly_ssl_report.sh

İzleme Sistemini Test Etme

Kurduğunuz sistemi gerçekten çalıştığından emin olmak için test senaryolarına ihtiyacınız var.

# Yakında dolacak bir test sertifikası oluştur (test amaçlı)
openssl req -x509 -newkey rsa:2048 -keyout /tmp/test_key.pem 
    -out /tmp/test_cert.pem -days 5 -nodes 
    -subj "/CN=test.local"

# Bu sertifikanın kaç gün kaldığını kontrol et
openssl x509 -noout -enddate -in /tmp/test_cert.pem
openssl x509 -noout -checkend $((30*86400)) -in /tmp/test_cert.pem
echo "Çıkış kodu: $?"

# Script'i manuel tetikle ve çıktıyı izle
/usr/local/bin/ssl_check.sh 2>&1 | tee /tmp/ssl_test_output.log

# Log dosyasını kontrol et
tail -50 /var/log/ssl_monitor/ssl_monitor.log

# Systemd timer geçmişini kontrol et
journalctl -u ssl-monitor.service --since "24 hours ago"

Dikkat Edilmesi Gereken Noktalar

Self-signed sertifikalar için openssl s_client komutuna -verify_return_error eklememeniz gerekebilir, yoksa bağlantı reddedilir.

Güvenlik duvarı kuralları bazen SSL kontrol araçlarını engelleyebilir. Kontrolleri mümkünse sunucunun kendisinden veya güvenilen bir iç ağdan yapın.

Rate limiting konusuna dikkat edin. Yüzlerce domaini saniyeler içinde kontrol etmeye çalışırsanız, bazı sunucular IP’nizi geçici olarak engelleyebilir. Script’e sleep 1 eklemek bu riski azaltır.

Timeout değerlerini ortamınıza göre ayarlayın. Yavaş veya uzak sunucular için 10 saniye yetersiz kalabilir.

İzin yönetimi açısından, bu script’lerin root olmayan ama gerekli izinlere sahip özel bir kullanıcı (ssl-monitor gibi) ile çalıştırılması güvenlik pratiği açısından daha sağlıklıdır.

Sonuç

SSL sertifika yönetimi, “bir kez kur unut” mantığıyla yaklaşılacak bir konu değil. Let’s Encrypt’in getirdiği 90 günlük sertifika döngüsü ve artan domain sayısı göz önüne alındığında, otomatik izleme artık bir lüks değil zorunluluk.

Bu yazıda anlattığımız sistemin temel katmanları şöyle özetlenebilir: OpenSSL ile ham sertifika bilgisi çekme, Bash veya Python ile kontrol otomasyonu, çok kanallı bildirim sistemi ve Systemd timer ile güvenilir zamanlama. Bu yapıyı küçük bir script olarak başlatıp zamanla Nagios veya Zabbix entegrasyonuna kadar büyütebilirsiniz.

En iyi sysadmin, müşteriyi aramak yerine müşterinin “siteniz güvenli değil” diyeceği günden 3 hafta önce sertifikayı yenilemiş olan kişidir. Bu uyarı sistemi sizi tam olarak o noktaya taşıyacaktır.

Yorum yapın