הקשחת ליבת לינוקס עם sysctl: המדריך המעשי המלא

מבוא: למה הקשחת הקרנל היא קו ההגנה הקריטי ביותר שלכם

אוקיי, בואו נדבר רגע על מה שבאמת חשוב. הליבה (Kernel) של לינוקס היא הרכיב הכי קריטי במערכת ההפעלה — היא מנהלת את כל המשאבים, שולטת בתקשורת בין חומרה לתוכנה, ומהווה את השכבה הנמוכה ביותר שתוקף צריך לפרוץ כדי להשיג שליטה מלאה. אם הקרנל נפרץ — המשחק נגמר. אין SELinux, אין AppArmor, אין firewall שיציל אתכם. התוקף הוא root, והוא שולט בהכל.

הנתונים של 2025 פשוט מדהימים (ולא במובן החיובי): נרשמו 5,530 פגיעויות CVE בליבת לינוקס — עלייה של 28% לעומת 2024. ב-16 הימים הראשונים של 2025 לבד נרשמו 134 CVE חדשים. זה קצב של כמעט 9 פגיעויות חדשות ביום! והנקודה החשובה — חלק ניכר מהן ניתן למיטיגציה באמצעות הגדרות sysctl נכונות, עוד לפני שהתיקון הרשמי מגיע.

דוגמה מעולה? CVE-2024-1086 — הפגיעות המכונה "Flipping Pages". ב-2025, CISA אישרה שהיא מנוצלת באופן פעיל על ידי קבוצות כופרה כמו RansomHub ו-Akira להסלמת הרשאות מקומית. והדבר המעניין באמת? אפשר למתן את הסיכון באופן מיידי עם פרמטר sysctl אחד בלבד: kernel.unprivileged_userns_clone=0.

הקשחת sysctl אינה תחליף לעדכוני אבטחה — אבל היא רשת הביטחון שמגנה עליכם כשהפאץ' עדיין לא מותקן.

במדריך הזה נכסה את כל מה שצריך לדעת על הקשחת ליבת לינוקס באמצעות פרמטרי sysctl — מהבסיס ועד לתצורות מתקדמות תואמות CIS Benchmarks. כל סעיף כולל הסבר על מה הפרמטר עושה, איזה וקטור תקיפה הוא חוסם, ודוגמאות קוד מוכנות ליישום. אז בואו נתחיל.

מה זה sysctl ואיך זה עובד?

sysctl הוא כלי שמאפשר לצפות ולשנות פרמטרים של הקרנל בזמן ריצה — בלי צורך בקומפילציה מחדש או אתחול. חשבו על זה כלוח הבקרה של הקרנל: הוא חושף הגדרות שמשפיעות על התנהגות הרשת, ניהול זיכרון, מערכת הקבצים ועוד.

הפרמטרים נגישים כקבצים וירטואליים תחת /proc/sys, וניתן לשנות אותם באמצעות הפקודה sysctl או על ידי כתיבה ישירה לקבצים. והחלק הטוב — שינויים אלה ניתנים ליישום מיידי ולשמירה קבועה.

שינויים זמניים לעומת קבועים

שינוי זמני (נעלם אחרי אתחול):

# Apply a temporary sysctl change
sudo sysctl -w kernel.dmesg_restrict=1

# Verify the change
sysctl kernel.dmesg_restrict

שינוי קבוע (שורד אתחול):

# Create a dedicated hardening config file
sudo tee /etc/sysctl.d/99-security-hardening.conf <<EOF
# Kernel hardening parameters
kernel.dmesg_restrict = 1
kernel.kptr_restrict = 2
EOF

# Apply the configuration
sudo sysctl -p /etc/sysctl.d/99-security-hardening.conf

הקידומת 99- בשם הקובץ מבטיחה שהוא נטען אחרון ודורס הגדרות קודמות. טיפ שימושי: מאז גרסת ליבה 5.8, ניתן גם להגדיר פרמטרי sysctl דרך פרמטר אתחול — sysctl.$tunable=$value — מה שמבטיח שההקשחה פעילה ממש מתחילת תהליך הבוט.

פרמטרי אבטחה ברמת הקרנל

עכשיו מגיע החלק המעניין. הפרמטרים הבאים מגנים ישירות על הקרנל מפני חשיפת מידע וניצול פגיעויות. כל פרמטר כאן חוסם וקטור תקיפה ספציפי, ואנחנו נפרט בדיוק מה ולמה.

הגבלת גישה ללוגים של הקרנל

# Restrict kernel log access to root only
kernel.dmesg_restrict = 1

לוגים של הקרנל (dmesg) מכילים מידע על חומרה, דרייברים, כתובות זיכרון והודעות שגיאה — אוצר של מודיעין לתוקף שמנסה למפות את המערכת ולזהות נקודות תורפה. הגבלת הגישה ל-root בלבד חוסמת את זה לגמרי.

הסתרת סמלי קרנל

# Hide kernel symbols from all users
kernel.kptr_restrict = 2

הקובץ /proc/kallsyms מכיל כתובות של פונקציות פנימיות בקרנל. תוקף שמנסה לנצל פגיעות צריך לדעת היכן נמצאות פונקציות ספציפיות בזיכרון — ובלי המידע הזה, הוא עיוור. ערך של 2 מסתיר את כל הכתובות מכל המשתמשים (כולל משתמשים עם CAP_SYSLOG). ערך של 1 מסתיר רק ממשתמשים ללא ה-capability הזה — אבל 2 הוא מה שאתם רוצים.

הגבלת BPF למשתמשים לא-מורשים

# Restrict BPF to root only
kernel.unprivileged_bpf_disabled = 1

# Harden BPF JIT compiler
net.core.bpf_jit_harden = 2

מהדר ה-JIT של BPF הוא יעד אטרקטיבי למתקפות heap spraying (וראיתי לא מעט מקרים כאלה בפרקטיקה). הגבלת השימוש ב-BPF ל-root בלבד מצמצמת משמעותית את משטח התקיפה. הפרמטר השני מקשיח את מהדר ה-JIT עצמו — שכבת הגנה כפולה.

הגבלת ptrace

# Restrict ptrace to root only
kernel.yama.ptrace_scope = 2

קריאת המערכת ptrace() מאפשרת לבדוק ולשנות תהליכים בזמן ריצה. זה כלי מרכזי ל-debugging, בלי ספק, אבל גם כלי מסוכן מאוד בידיים הלא נכונות. עם ptrace, תוקף יכול לקרוא זיכרון של תהליכים אחרים, לחלץ סיסמאות, מפתחות הצפנה ו-tokens. ערך 2 מגביל את ptrace ל-root בלבד.

חסימת kexec

# Disable kexec - prevents loading a new kernel at runtime
kernel.kexec_load_disabled = 1

kexec היא קריאת מערכת שמאפשרת לטעון ליבה חדשה בזמן ריצה. נשמע תמים? ממש לא. תוקף עם הרשאות root יכול לנצל אותה כדי לטעון קרנל זדוני ולקבל שליטה מוחלטת — כולל עקיפת כל מנגנוני האבטחה. חסימת kexec חוסמת את וקטור התקיפה הזה לחלוטין.

הגבלת userfaultfd

# Restrict userfaultfd to privileged users
vm.unprivileged_userfaultfd = 0

קריאת המערכת userfaultfd() מנוצלת לעיתים קרובות בצורה מפתיעה לניצול פגיעויות מסוג use-after-free — אחד מסוגי הפגיעויות הנפוצים ביותר בקרנל. הגבלתה למשתמשים בעלי CAP_SYS_PTRACE מקשה משמעותית על ניצול הפגיעויות האלה.

ביטול SysRq

# Disable SysRq key completely
kernel.sysrq = 0

מקש SysRq חושף פונקציונליות debugging מסוכנת — כולל אתחול מחדש, סינכרון דיסקים, והריגת תהליכים. ודבר שהרבה אנשים לא יודעים: SysRq ניתן להפעלה גם מרחוק, לא רק דרך מקלדת פיזית. ביטול מלא (ערך 0) חוסם את כל זה.

הגבלת User Namespaces

# Restrict user namespaces to privileged users
# For kernels with the relevant patch:
kernel.unprivileged_userns_clone = 0

# Alternative - disable completely (for kernels without the patch):
# user.max_user_namespaces = 0

User namespaces נועדו במקור לשפר sandboxing ולהנגיש אותו למשתמשים רגילים. רעיון נחמד בתיאוריה. אבל בפועל? הם חושפים משטח תקיפה ענק של הקרנל ושימשו בפגיעויות רבות להסלמת הרשאות — כולל CVE-2024-1086 שהזכרנו בהתחלה. הגבלתם היא בכנות אחד הצעדים האפקטיביים ביותר שאפשר לעשות.

הגבלת Performance Events

# Restrict performance events to privileged users
kernel.perf_event_paranoid = 3

אירועי ביצועים (Performance Events) מוסיפים משטח תקיפה ניכר לקרנל וגרמו לפגיעויות רבות לאורך השנים. ערך 3 הוא הכי מחמיר — מגביל את כל השימוש ל-CAP_PERFMON (או CAP_SYS_ADMIN בגרסאות ליבה לפני 5.8).

הקשחת פרמטרי רשת

הרשת היא משטח התקיפה הגדול ביותר ברוב המערכות — וזה לא אמור להפתיע אף אחד. הפרמטרים הבאים חוסמים מתקפות נפוצות ברמת הרשת, מ-SYN flood ועד IP spoofing.

תצורה מלאה להקשחת רשת

# === Network Security Hardening ===

# Enable TCP SYN cookies - mitigate SYN flood attacks
net.ipv4.tcp_syncookies = 1

# Disable IP forwarding (unless this is a router)
net.ipv4.ip_forward = 0
net.ipv6.conf.all.forwarding = 0

# Disable ICMP redirects - prevent route hijacking
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.default.accept_redirects = 0
net.ipv6.conf.all.accept_redirects = 0
net.ipv6.conf.default.accept_redirects = 0

# Do not send ICMP redirects
net.ipv4.conf.all.send_redirects = 0
net.ipv4.conf.default.send_redirects = 0

# Disable source routing - prevent attackers from specifying packet routes
net.ipv4.conf.all.accept_source_route = 0
net.ipv4.conf.default.accept_source_route = 0
net.ipv6.conf.all.accept_source_route = 0
net.ipv6.conf.default.accept_source_route = 0

# Enable reverse path filtering - prevent IP spoofing
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# Log suspicious packets (martians)
net.ipv4.conf.all.log_martians = 1
net.ipv4.conf.default.log_martians = 1

# Ignore ICMP broadcast requests - prevent Smurf attacks
net.ipv4.icmp_echo_ignore_broadcasts = 1

# Ignore bogus ICMP error responses
net.ipv4.icmp_ignore_bogus_error_responses = 1

# TCP connection timeouts
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 60
net.ipv4.tcp_keepalive_probes = 3

# Disable IPv6 router advertisements (if not needed)
net.ipv6.conf.all.accept_ra = 0
net.ipv6.conf.default.accept_ra = 0

הסבר מפורט של הפרמטרים הקריטיים

TCP SYN Cookies: מתקפת SYN Flood מציפה את המערכת בחבילות SYN שממלאות את תור החיבורים. SYN cookies מאפשרים למערכת להגיב לבקשות בלי להקצות זיכרון לכל חיבור — ובכך מנטרלים את המתקפה. זה אחד מאותם פרמטרים שאין סיבה לא להפעיל.

Reverse Path Filtering: כשחבילה מגיעה לממשק רשת, הקרנל בודק אם הנתיב חזרה לכתובת המקור עובר דרך אותו ממשק. אם לא — החבילה נחסמת. פשוט ויעיל נגד מתקפות IP spoofing.

ICMP Redirects: הודעות ICMP Redirect אומרות למערכת לשנות את טבלת הניתוב שלה. תוקף יכול לנצל זאת כדי להפנות תעבורה דרך מכונה שהוא שולט בה — קלאסיקה של Man-in-the-Middle. חסימה של קבלה ושליחה של redirects סוגרת את הדלת הזו.

Source Routing: ניתוב מקור מאפשר לשולח לציין את הנתיב המדויק שחבילה צריכה לעבור. זו יכולת שאף אחד לא באמת צריך ב-production — אבל תוקף בהחלט יכול לנצל אותה כדי לעקוף firewalls ולהגיע ליעדים שלא אמורים להיות נגישים. חסימתה היא חובה.

הגנה על זיכרון ומערכת קבצים

הפרמטרים הבאים מגנים על שלמות הזיכרון ומערכת הקבצים — שני המרכיבים המרכזיים שתוקפים מנסים לנצל כדי להסלים הרשאות.

# === Memory and Filesystem Protections ===

# Enable ASLR (Address Space Layout Randomization) - maximum level
kernel.randomize_va_space = 2

# Protect hard links - prevent unauthorized hard link creation
fs.protected_hardlinks = 1

# Protect symbolic links - prevent symlink attacks
fs.protected_symlinks = 1

# Protect FIFOs in world-writable sticky directories
fs.protected_fifos = 2

# Protect regular files in world-writable sticky directories
fs.protected_regular = 2

# Restrict core dumps
fs.suid_dumpable = 0

# Limit kernel memory map count (prevent certain exploits)
vm.mmap_min_addr = 65536

למה כל פרמטר חשוב

ASLR (ערך 2): רנדומיזציה של מרחב הכתובות. מה שזה עושה בפועל — מערבב את המיקום של קוד, מחסנית, heap וספריות בזיכרון בכל הרצה מחדש. התוצאה? תוקף שמנסה לנצל פגיעות buffer overflow לא יודע היכן בדיוק נמצא הקוד שלו בזיכרון, וזה מקשה מאוד על ניצול מוצלח.

הגנה על Hard Links ו-Symlinks: מונע ממשתמשים ליצור קישורים קשיחים או סימבוליים לקבצים שאינם שלהם. בלי הגנה זו, תוקף יכול ליצור symlink בתיקייה ציבורית שמצביע על קובץ רגיש (למשל /etc/shadow) ולגרום לתהליך בעל הרשאות גבוהות לגשת אליו דרך הלינק. תרחיש קלאסי שקל למנוע.

vm.mmap_min_addr: מגדיר כתובת מינימלית למיפוי זיכרון. ערך של 65536 מונע מיפוי של דפי זיכרון בכתובות נמוכות — טכניקה שמשמשת בפגיעויות NULL pointer dereference כדי להריץ קוד שרירותי. זה שינוי קטן עם השפעה גדולה.

פרמטרי אתחול (Boot-Time Parameters)

חלק מהגנות האבטחה צריכות להיות פעילות כבר מתחילת תהליך האתחול — לפני ששירותי userspace עולים. את הפרמטרים האלה מגדירים ב-GRUB:

# Edit GRUB configuration
sudo nano /etc/default/grub

# Add these to GRUB_CMDLINE_LINUX:
GRUB_CMDLINE_LINUX="slab_nomerge slub_debug=FZ init_on_alloc=1 init_on_free=1 page_alloc.shuffle=1 pti=on randomize_kstack_offset=on vsyscall=none lockdown=confidentiality module.sig_enforce=1"

# Update GRUB
sudo update-grub    # Debian/Ubuntu
sudo grub2-mkconfig -o /boot/grub2/grub.cfg    # RHEL/CentOS

הסבר הפרמטרים

slab_nomerge: מונע מיזוג של slabs בגדלים דומים. למה זה חשוב? מיזוג כזה עלול להוביל למצבים שבהם אובייקט מסוג אחד כותב מעבר לגבולות שלו אל אובייקט מסוג אחר באותו slab — וזה בדיוק מה שתוקפים מחפשים.

slub_debug=FZ: מפעיל redzoning (F) ובדיקות שפיות (Z) על allocator ה-slab. redzoning מוסיף "אזורי שמירה" סביב כל אובייקט ומזהה כתיבה מעבר לגבולות.

init_on_alloc=1 ו-init_on_free=1: מאפסים דפי זיכרון בהקצאה ובשחרור. מונע דליפת מידע רגיש (סיסמאות, מפתחות הצפנה) דרך זיכרון שלא נוקה כראוי. כן, יש תקורת ביצועים קטנה — אבל היא שווה את זה.

pti=on: מפעיל Kernel Page Table Isolation — מיטיגציה נגד מתקפות Meltdown ועקיפות KASLR. בעצם מפריד בין טבלאות הדפים של הקרנל למרחב המשתמש כך שתהליך רגיל לא יכול "להציץ" לזיכרון הקרנל.

lockdown=confidentiality: מצב נעילה של הקרנל ברמת סודיות — מונע קריאה וכתיבה ישירה לזיכרון הקרנל, גם מתהליכים עם הרשאות root. חיוני במיוחד כשמשתמשים ב-Secure Boot.

module.sig_enforce=1: מחייב חתימה דיגיטלית על כל מודול קרנל שנטען. מונע מתוקף לטעון מודולים זדוניים (rootkits) גם אם הוא השיג הרשאות root. שכבת הגנה קריטית.

סקריפט הקשחה מלא — יישום מיידי

דיברנו מספיק בתיאוריה — הנה סקריפט שלם שמיישם את כל ההגדרות שעברנו עליהן. הוא יוצר גיבוי של ההגדרות הקיימות (תמיד תמיד תמיד גבו לפני שינויים!) ומחיל את ההקשחה באופן מסודר:

#!/bin/bash
# Linux Kernel Hardening Script - 2026
# Compatible with RHEL/CentOS 8+, Ubuntu 20.04+, Debian 11+
set -euo pipefail

CONF_FILE="/etc/sysctl.d/99-security-hardening.conf"
BACKUP_DIR="/root/sysctl-backup-$(date +%Y%m%d-%H%M%S)"

echo "[*] Creating backup of current sysctl settings..."
mkdir -p "$BACKUP_DIR"
sysctl -a > "$BACKUP_DIR/sysctl-all.conf" 2>/dev/null
cp -r /etc/sysctl.d/ "$BACKUP_DIR/" 2>/dev/null || true
echo "[+] Backup saved to $BACKUP_DIR"

echo "[*] Writing hardened sysctl configuration..."
cat > "$CONF_FILE" <

#!/bin/bash
# Verify kernel hardening parameters
echo "=== Kernel Hardening Verification ==="
echo ""

declare -A EXPECTED=(
    ["kernel.dmesg_restrict"]="1"
    ["kernel.kptr_restrict"]="2"
    ["kernel.unprivileged_bpf_disabled"]="1"
    ["net.core.bpf_jit_harden"]="2"
    ["kernel.yama.ptrace_scope"]="2"
    ["kernel.kexec_load_disabled"]="1"
    ["kernel.sysrq"]="0"
    ["kernel.randomize_va_space"]="2"
    ["net.ipv4.tcp_syncookies"]="1"
    ["net.ipv4.ip_forward"]="0"
    ["net.ipv4.conf.all.rp_filter"]="1"
    ["net.ipv4.conf.all.accept_redirects"]="0"
    ["net.ipv4.conf.all.send_redirects"]="0"
    ["fs.protected_hardlinks"]="1"
    ["fs.protected_symlinks"]="1"
    ["fs.suid_dumpable"]="0"
)

PASS=0
FAIL=0

for param in "${!EXPECTED[@]}"; do
    current=$(sysctl -n "$param" 2>/dev/null)
    expected="${EXPECTED[$param]}"
    if [ "$current" = "$expected" ]; then
        echo "[PASS] $param = $current"
        ((PASS++))
    else
        echo "[FAIL] $param = $current (expected: $expected)"
        ((FAIL++))
    fi
done

echo ""
echo "Results: $PASS passed, $FAIL failed out of ${#EXPECTED[@]} checks"

# Install Lynis
sudo apt install lynis -y    # Debian/Ubuntu
sudo yum install lynis -y    # RHEL/CentOS

# Run a full system audit
sudo lynis audit system

# Check specific kernel hardening
sudo lynis audit system --tests-from-group kernel

# Check kernel version
uname -r

# Check if kernel lockdown is supported
cat /sys/kernel/security/lockdown 2>/dev/null

# Check if SELinux/AppArmor is active
cat /sys/kernel/security/lsm

# Check available security features
grep -i "config_security\|config_lockdown\|config_bpf" /boot/config-$(uname -r) 2>/dev/null | head -20

# Quick weekly check - add to cron
#!/bin/bash
# /etc/cron.weekly/sysctl-check
EXPECTED_HASH=$(sha256sum /etc/sysctl.d/99-security-hardening.conf | awk '{print $1}')
STORED_HASH=$(cat /var/lib/sysctl-hardening-hash 2>/dev/null)

if [ "$EXPECTED_HASH" != "$STORED_HASH" ]; then
    echo "WARNING: sysctl hardening config has been modified!" | \
        mail -s "Sysctl Alert on $(hostname)" [email protected]
fi

# Store hash on first run
echo "$EXPECTED_HASH" > /var/lib/sysctl-hardening-hash