💡 טיפ: מערכות בינה מלאכותית יכולות לנתח מיליוני אירועי אבטחה בשנייה אחת — הרבה מעבר ליכולת האנושית — ולזהות איומים לפני שהם גורמים נזק.

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

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

💡 טיפ: חברו את מערכת הבינה המלאכותית שלכם לפידי מודיעין איומים מרובים (כמו VirusTotal או MISP) כדי לקבל תמונה מלאה ועדכנית של הנוף האיומים בזמן אמת.

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

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

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

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

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

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

💡 טיפ: תוכלו לבקש מ-ChatGPT להסביר לכם כל פקודת Linux או קוד Python שאתם לא מבינים — פשוט הדביקו אותה ושאלו "מה עושה הפקודה הזו?"

cd lab1   # enter directory named "lab1"
cd ..     # go up one level (parent directory)
cd ~      # go to home directory (shortcut: ~ = /home/username)

💡 טיפ: בקשו מ-ChatGPT להסביר לכם כל פקודת ניווט עם דוגמה מעשית, ותקבלו הבנה מעמיקה תוך דקות.

cp detect.py detect_backup.py  # copy file — original stays, new copy is created
mv detect.py /workspace/       # move file — original is removed from current location

💡 טיפ: שאלו את ChatGPT "מתי עדיף להשתמש ב-mv במקום cp ואז rm?" כדי להבין מתי כל פקודה מתאימה.

nano detect.py   # open file in nano text editor (simple terminal editor)
# Ctrl+O → Enter  — save the file
# Ctrl+X          — exit nano

💡 טיפ: בקש מ-ChatGPT להסביר פקודת cat או echo עם דוגמה קונקרטית לקובץ שאתה עובד עליו — זה מקצר את זמן הלמידה משמעותית.

grep "error" log.txt           # search for lines containing "error" in log.txt
grep -i "attack" log.txt       # -i = case-insensitive (matches Attack, ATTACK, attack)
grep -r "password" /var/log/   # -r = recursive search through all files in directory
grep -n "anomaly" detect.py    # -n = show line numbers next to each match

💡 טיפ: תוכל לבקש מ-ChatGPT לבנות עבורך פקודת grep מורכבת עם regex על ידי תיאור מה אתה מחפש בשפה פשוטה.

cat log.txt | grep "error" | head -20  # read file → filter errors → show first 20
ls -la | grep ".py"                    # list files → show only Python files
ps aux | grep python                   # list processes → show only Python processes
# | (pipe) sends output of one command as input to the next

💡 טיפ: תוכל לבקש מ-ChatGPT לבנות עבורך פקודת grep מורכבת עם regex על ידי תיאור מה אתה מחפש בשפה פשוטה.

sudo apt update           # run apt update as root (superuser) — refresh package list
sudo pip install pandas   # install Python package with admin privileges
sudo cat /etc/shadow      # read protected file (only root can access /etc/shadow)

💡 טיפ: תוכל לבקש מ-ChatGPT להסביר פלט של ls -la ולנתח אם ההרשאות מהוות סיכון אבטחה.

ping google.com -c 4       # send 4 ICMP packets to google.com — test connectivity
curl -I https://site.com   # fetch only HTTP headers (not body) — check server response
wget https://site.com/file.txt  # download file from URL and save it locally

💡 טיפ: תוכלו לבקש מ-ChatGPT לנתח עבורכם פלט של ss -tulnp ולזהות פורטים חשודים או לא מוכרים.

pip install pandas scikit-learn        # install one or more packages from PyPI
pip list                               # show all installed packages and their versions
pip show pandas                        # show details about a specific package
pip freeze > requirements.txt          # save all installed packages to a file
pip install -r requirements.txt        # install all packages listed in requirements.txt

💡 טיפ: תוכלו לבקש מ-ChatGPT לנתח את קובץ requirements.txt שלכם ולהמליץ על חבילות מאובטחות ועדכניות לפרויקט הסייבר שלכם.

company_name   = "Maersk"
damage_million = 300
print(f"{company_name} suffered ${damage_million}M in damage")
# Output: Maersk suffered $300M in damage

💡 Tip: When asking ChatGPT to analyze cybersecurity data, provide the data as a dict with clear fields — it will understand the structure much better.

failed_attempts  = 0
correct_password = "cyber123"
max_attempts     = 3

while failed_attempts < max_attempts:
    user_input = input("Enter password: ")
    if user_input == correct_password:
        print("Access granted!")
        break
    failed_attempts += 1
    print(f"Wrong. {max_attempts - failed_attempts} attempts left.")

if failed_attempts == max_attempts:
    print("Account locked!")

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

import pandas as pd

network_logs = pd.read_csv("network_data.csv")

print(network_logs.head())      # first 5 rows
print(network_logs.shape)       # (1050, 3)
print(network_logs.describe())  # min, max, mean per column

attack_events = network_logs[network_logs['label'] == 1]
print(f"Found {len(attack_events)} attacks")

💡 טיפ: תוכל לבקש מ-ChatGPT לכתוב עבורך קוד pandas שמנתח קובץ CSV של לוגים ומוצא חריגות — רק תעלה את הקובץ ותתאר מה אתה מחפש.

import matplotlib.pyplot as plt  # plotting library
import numpy as np               # math/arrays library

time           = np.arange(10)                    # [0,1,2,...,9] — x axis (time steps)
normal_traffic = np.random.normal(100, 20, 10)    # 10 random values: mean=100, std=20
attack_traffic = [100,105,98,102,5000,103,99,101,97,104]  # spike at index 4 = attack
alert_threshold = 500                             # anything above this is an alert

plt.figure(figsize=(10, 4))                       # create canvas 10x4 inches
plt.plot(time, normal_traffic, 'b-o', label='Normal')      # blue line = normal
plt.plot(time, attack_traffic, 'r-o', label='Under Attack') # red line = attack
plt.axhline(y=alert_threshold, color='orange',
            linestyle='--', label='Alert Threshold')        # horizontal alert line
plt.legend()                                      # show labels
plt.title('Network Traffic — Attack Detection')   # chart title
plt.savefig('traffic.png')                        # save to file
plt.show()

💡 טיפ: השתמש ב-numpy לזיהוי חריגות סטטיסטיות ו-matplotlib להצגתן ויזואלית

כך מודלי בינה מלאכותית "רואים" מתקפות לפני שמאמנים אותם.

from sklearn.ensemble import RandomForestClassifier  # ML model that detects threats
from sklearn.model_selection import train_test_split  # splits data into train and test
from sklearn.metrics import accuracy_score            # measures how accurate the model is
import pandas as pd

network_logs   = pd.read_csv('data.csv')              # load the dataset from a CSV file
features       = network_logs[['bytes_sent', 'connections']]  # input: what we measure
labels         = network_logs['label']                # output: 0=normal, 1=attack

# use 80% of data to train, 20% to test
features_train, features_test, labels_train, labels_test = train_test_split(
    features, labels, test_size=0.2
)

threat_detector = RandomForestClassifier()            # create the model
threat_detector.fit(features_train, labels_train)     # train it on the training data

predictions = threat_detector.predict(features_test)  # predict on unseen test data
accuracy    = accuracy_score(labels_test, predictions) # compare predictions to real labels
print(f"Accuracy: {accuracy:.1%}")                    # e.g. "Accuracy: 94.3%"

💡 טיפ: כשאתם מאמנים מודל sklearn לזיהוי איומים, בקשו מ-ChatGPT לעזור לכם לפרש את feature_importances_ ולהבין אילו תכונות הכי משפיעות על הסיווג.

# 1. List of network events(each network event is a dictionary)
events = [
    {"bytes": 500,   "connections": 10},
    {"bytes": 50000, "connections": 450},
    {"bytes": 200,   "connections": 30},
    {"bytes": 80000, "connections": 600},
    {"bytes": 100,   "connections": 5},
]

# 2. Function to check threat level
def check_threat(connections, bytes_sent):
    if connections > 100 and bytes_sent > 10000:
        return "HIGH"
    elif connections > 50:
        return "MEDIUM"
    return "LOW"

# 3+4. Loop and print
high_count = 0
results = []
for event in events:
    level = check_threat(event["connections"], event["bytes"])
    line = f"connections={event['connections']}, bytes={event['bytes']} -> {level}"
    print(line)
    results.append(line)
    if level == "HIGH":
        high_count += 1

# 5. Count HIGH events
print(f"\nTotal HIGH events: {high_count}")

# 6. Save to file
with open("results.txt", "w") as f:
    for line in results:
        f.write(line + "\n")
    f.write(f"\nTotal HIGH events: {high_count}\n")
print("Results saved to results.txt")

💡 טיפ: מודלים לזיהוי חריגות עובדים הכי טוב כשמאמנים אותם על נתונים "נורמליים" בלבד — כך הם לומדים לזהות כל מה שחורג מהרגיל.

💡 טיפ: תוכלו לבקש מ-ChatGPT לכתוב עבורכם Dockerfile מותאם אישית — פשוט תארו לו את הפרויקט שלכם ואת הסביבה הנדרשת.

FROM python:3.11-slim      # start from official Python 3.11 image (slim = smaller size)
WORKDIR /app               # set /app as the working directory inside the container
COPY . .                   # copy all files from your computer into /app
RUN pip install -r requirements.txt  # install all required Python packages
CMD ["python", "app.py"]   # default command to run when container starts

💡 טיפ: בקשו מבינה מלאכותית לכתוב עבורכם Dockerfile מותאם לפרויקט שלכם — פשוט תארו את השפה, הגרסה והתלויות.

💡 טיפ: בקשו מ-ChatGPT להסביר פקודת Docker שאינכם מכירים — פשוט הדביקו אותה וכתבו "מה הפקודה הזו עושה?"

💡 טיפ: בקשו מ-ChatGPT לייצר עבורכם פקודת docker run מלאה

עם volumes ו-ports מותאמים לפרויקט שלכם — פשוט תארו לו מה אתם רוצים להריץ.

💡 טיפ: אם קיבלתם שגיאה בהרצת Docker, העתיקו אותה ל-ChatGPT — הוא יאבחן את הבעיה ויציע פתרון תוך שניות.

docker pull python:3.11-slim
# download Python 3.11 image from Docker Hub (slim = smaller size)

docker run -it -v $(pwd)/lab1:/workspace -w /workspace python:3.11-slim bash
# -it = interactive terminal (you can type commands)
# -v $(pwd)/lab1:/workspace = share your lab1 folder with the container
# -w /workspace = start inside the /workspace folder
# bash = open a bash shell

pip install pandas scikit-learn matplotlib
# install 3 Python libraries: data tables, ML, and charts

💡 טיפ: תוכלו לבקש מ-ChatGPT להסביר כל שגיאת Docker שתקבלו — פשוט העתיקו את הודעת השגיאה ושאלו "מה הבעיה וכיצד לתקן?".

import pandas as pd, numpy as np  # pandas = tables, numpy = math/random numbers
np.random.seed(42)                 # fix the random seed so results are the same every run

# --- Create 1000 rows of NORMAL traffic ---
normal = pd.DataFrame({
    'bytes_sent':  np.random.normal(500, 100, 1000),  # avg 500 bytes, std 100, 1000 rows
    'connections': np.random.normal(10, 2, 1000),     # avg 10 connections, std 2
    'label': 0                                         # 0 = normal traffic
})

# --- Create 50 rows of ATTACK traffic ---
anomaly = pd.DataFrame({
    'bytes_sent':  np.random.normal(50000, 5000, 50), # avg 50,000 bytes — 100x more than normal!
    'connections': np.random.normal(500, 50, 50),     # avg 500 connections — 50x more than normal!
    'label': 1                                         # 1 = attack traffic
})

df = pd.concat([normal, anomaly]).sample(frac=1)  # combine and shuffle all rows randomly
df.to_csv('network_data.csv', index=False)         # save to CSV file (no row numbers)
print("Created", len(df), "records")               # should print: Created 1050 records

💡 טיפ: בקשו מ-ChatGPT להסביר לכם כיצד לשנות את פרמטרי הנתונים המדומים כדי לדמות סוגי מתקפות שונים.

import pandas as pd                               # for loading and working with data tables
from sklearn.ensemble import IsolationForest      # ML model that finds unusual data points
from sklearn.metrics import classification_report # shows how accurate the model is

df = pd.read_csv('network_data.csv')             # load the CSV file we created earlier
X = df[['bytes_sent', 'connections']]            # use these 2 columns as input features

model = IsolationForest(contamination=0.05, random_state=42)
# contamination=0.05 means we expect ~5% of data to be anomalies
# random_state=42 makes results the same every run

df['anomaly'] = (model.fit_predict(X) == -1).astype(int)
# fit_predict trains the model AND predicts at the same time
# returns -1 for anomaly, +1 for normal → convert to 1/0

print(classification_report(df['label'], df['anomaly']))
# compare our predictions to the real labels and show accuracy

💡 טיפ: כדי לשפר את דיוק IsolationForest, נסו לבקש מ-ChatGPT לעזור לכם לכוונן את ערך ה-contamination בהתבסס על התפלגות הנתונים שלכם.

import matplotlib.pyplot as plt   # library for creating charts and graphs
import pandas as pd               # library for working with data tables

df = pd.read_csv('network_data.csv')  # load the data with anomaly predictions

colors = df['anomaly'].map({0: 'steelblue', 1: 'crimson'})
# map 0 (normal) → blue, 1 (attack) → red

plt.figure(figsize=(10, 6))       # create a canvas 10 inches wide, 6 inches tall
plt.scatter(df['bytes_sent'], df['connections'],
            c=colors, alpha=0.6, edgecolors='white', linewidth=0.5)
# scatter plot: x=bytes sent, y=connections, colored by normal/attack
# alpha=0.6 makes dots slightly transparent

plt.xlabel('Bytes Sent')          # label for x axis
plt.ylabel('Connections')         # label for y axis
plt.title('Anomaly Detection — Red = Attack | Blue = Normal')  # chart title
plt.tight_layout()                # remove extra whitespace around the chart
plt.savefig('anomaly_result.png', dpi=150)  # save as image file (high quality)
print("Chart saved: anomaly_result.png")    # confirm it was saved

💡 טיפ: בקשו מ-ChatGPT להציע שיפורים לגרף שלכם — למשל הוספת legend, annotations על נקודות חריגות, או שינוי צבעים לנגישות טובה יותר.

💡 טיפ: בקשו מ-ChatGPT לייצר עבורכם דוגמאות של מיילי פישינג ומיילים לגיטימיים לאימון המודל שלכם.

docker pull python:3.11-slim                    # download Python image
docker run -it -v $(pwd)/lab2:/workspace \
  -w /workspace python:3.11-slim bash           # start container with lab2 folder shared
pip install pandas scikit-learn                 # install required libraries

import pandas as pd                             # for creating and saving data tables

emails = [
  ("You won a prize! Click now for 1,000,000 NIS", 1),   # 1 = phishing
  ("Your account will be frozen in 24 hours", 1),         # 1 = phishing
  ("Your password expired — click to renew", 1),          # 1 = phishing
  ("Exclusive offer! Buy now before stock runs out", 1),  # 1 = phishing
  ("Team meeting tomorrow at 10:00 — please confirm", 0), # 0 = legitimate
  ("Monthly report attached for your review", 0),         # 0 = legitimate
  ("Reminder: project submission on Thursday", 0),        # 0 = legitimate
  ("Happy birthday from the whole team", 0),              # 0 = legitimate
]

df = pd.DataFrame(emails, columns=['text', 'label'])  # create table with 2 columns
df.to_csv('emails.csv', index=False)                  # save to CSV file
print("Created", len(df), "emails")                   # should print: Created 8 emails

💡 טיפ: בקשו מ-ChatGPT לייצר עבורכם עוד דוגמאות של מיילי פישינג בעברית כדי להעשיר את מאגר הנתונים ולשפר את דיוק המודל.

import pandas as pd                                      # for loading data
from sklearn.feature_extraction.text import TfidfVectorizer  # converts text to numbers
from sklearn.naive_bayes import MultinomialNB            # simple but effective text classifier
from sklearn.pipeline import Pipeline                    # chains steps together

df = pd.read_csv('emails.csv')                          # load our email dataset

model = Pipeline([
    ('tfidf', TfidfVectorizer()),  # step 1: convert email text to numbers
    ('nb', MultinomialNB())        # step 2: train classifier on those numbers
])
model.fit(df['text'], df['label'])  # train the model on all emails
print("Model trained successfully!")

# Testing new emails:
test_emails = [
    "You won! Click here for your prize",   # should predict: phishing
    "Meeting tomorrow morning",              # should predict: legitimate
    "Your account was hacked — verify now", # should predict: phishing
    "Thank you for attending the conference" # should predict: legitimate
]

for email in test_emails:                              # loop through each test email
    prediction = model.predict([email])[0]             # 0=legitimate, 1=phishing
    label = "PHISHING" if prediction == 1 else "Clean" # convert number to label
    print(f"{email[:40]}... → {label}")                # print first 40 chars + result

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

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

docker pull jupyter/scipy-notebook          # download Jupyter with science libraries pre-installed
docker run -p 8888:8888 \
  -v $(pwd)/lab3:/home/jovyan/work \
  jupyter/scipy-notebook                    # -p 8888:8888 = open port so browser can connect
                                            # -v = share lab3 folder with the container

import pandas as pd                         # for creating data tables
import numpy as np                          # for generating random numbers
np.random.seed(42)                          # same seed = same results every run

# --- Create 500 rows of NORMAL files ---
normal = pd.DataFrame({
    'file_size':    np.random.normal(2000, 500, 500),   # avg 2KB, normal programs are small
    'num_imports':  np.random.normal(15, 5, 500),       # avg 15 imports, normal amount
    'has_encryption': np.random.choice([0,1], 500, p=[0.9, 0.1]),  # 10% chance of encryption
    'network_calls': np.random.normal(5, 2, 500),       # avg 5 network calls, low activity
    'label': 0                                           # 0 = normal file
})

# --- Create 100 rows of MALWARE files ---
malware = pd.DataFrame({
    'file_size':    np.random.normal(15000, 3000, 100), # avg 15KB — much larger than normal
    'num_imports':  np.random.normal(60, 10, 100),      # avg 60 imports — suspicious!
    'has_encryption': np.random.choice([0,1], 100, p=[0.2, 0.8]),  # 80% encrypted — red flag
    'network_calls': np.random.normal(80, 20, 100),     # avg 80 calls — very suspicious
    'label': 1                                           # 1 = malware
})

df = pd.concat([normal, malware]).sample(frac=1)        # combine and shuffle randomly
df.to_csv('malware_data.csv', index=False)              # save to CSV
print("Created", len(df), "files")                      # should print: Created 600 files

💡 טיפ: תוכלו לבקש מ-ChatGPT להסביר כל שורה בקוד יצירת הנתונים כדי להבין לעומק איך מדמים מאפייני נוזקות מול קבצים תקינים.

import pandas as pd                                      # for loading data
from sklearn.ensemble import RandomForestClassifier      # ML model — many decision trees combined
from sklearn.model_selection import train_test_split     # splits data into train and test sets
from sklearn.metrics import classification_report        # shows accuracy, precision, recall

df = pd.read_csv('malware_data.csv')                    # load our malware dataset
features = ['file_size', 'num_imports', 'has_encryption', 'network_calls']  # input columns
X_train, X_test, y_train, y_test = train_test_split(
    df[features], df['label'], test_size=0.2, random_state=42
)   # 80% for training, 20% for testing

model = RandomForestClassifier(n_estimators=100, random_state=42)
# n_estimators=100 means 100 decision trees vote together
model.fit(X_train, y_train)                             # train the model
print(classification_report(y_test, model.predict(X_test)))  # show accuracy results

import matplotlib.pyplot as plt                          # for creating charts
importances = pd.Series(model.feature_importances_, index=features)
# feature_importances_ = how much each feature helped the model decide
importances.sort_values().plot(kind='barh', color='steelblue')
# sort from least to most important, draw horizontal bar chart
plt.title('Which features matter most for detecting malware?')
plt.tight_layout()                                       # remove extra whitespace
plt.savefig('feature_importance.png', dpi=150)          # save chart as image

# Test a suspicious file with high values in all features
model.predict([[18000, 70, 1, 95]])
# file_size=18000 (large), num_imports=70 (many), has_encryption=1 (yes), network_calls=95 (high)
# Expected output: [1] = MALWARE detected

💡 טיפ: כדי לשפר את דיוק מודל ה-Random Forest לזיהוי נוזקות, נסו לבקש מ-ChatGPT להציע פיצ'רים נוספים שניתן לחלץ מקבצים חשודים.

💡 טיפ: השתמשו בכלי כמו ChatGPT כדי לסכם את נושאי כל מפגש מראש ולהגיע מוכנים יותר לשיעור.

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

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

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