GitHub e Git spiegati bene

Indice dei contenuti

• Cos’è GitHub e a cosa serve
• Che cos’è Git: il cuore di GitHub
• Come Git e GitHub lavorano insieme
• Chi usa GitHub e perché
• Da dove iniziare

---

In questo articolo parleremo di GitHub, una piattaforma fondamentale nel mondo dello sviluppo software, e del sistema di controllo versione Git, sul quale GitHub si basa.

Capiremo insieme perché questi strumenti sono così usati anche nel contesto della cyber security, da chi vengono utilizzati, come funzionano e perché sono indispensabili in ogni progetto informatico moderno.

Se ti occupi di sicurezza informatica o vuoi iniziare a contribuire a progetti open source, questo approfondimento fa per te.

Cos’è GitHub e a cosa serve

GitHub è una piattaforma cloud-based che consente di archiviare, condividere e collaborare su progetti software.

Ogni progetto viene salvato in un repository, uno spazio virtuale strutturato che contiene tutti i file del codice, le cartelle, la documentazione e soprattutto la cronologia delle modifiche, fondamentale per tenere traccia dell’evoluzione di un programma nel tempo.

Immagina un progetto di sviluppo di un’applicazione mobile per la sicurezza delle reti Wi-Fi. Ogni volta che uno sviluppatore aggiunge una nuova funzionalità.

Esempio
Un modulo che rileva reti sospette – salva i cambiamenti in un commit, con un messaggio descrittivo. Questo commit viene registrato nel repository GitHub. Gli altri membri del team possono vedere cosa è stato fatto, commentare, proporre alternative e persino testare quella specifica modifica senza toccare il codice principale.

Tra i vantaggi principali dell’utilizzo di GitHub, spiccano:

• La possibilità di documentare ogni cambiamento effettuato sul codice. Questo permette non solo di risalire all’origine di un errore, ma anche di avere una visione storica dell’intero sviluppo. Ad esempio, se un aggiornamento introduce una vulnerabilità, si può tornare facilmente alla versione precedente sicura.
• L’agevolazione del lavoro di squadra, anche in gruppi numerosi e geograficamente distribuiti. Ogni membro può lavorare su una copia del progetto (un “branch”) e unire le modifiche solo quando sono pronte, grazie alle funzionalità di merge offerte da Git, su cui GitHub si basa.
• La possibilità per altri utenti, anche esterni, di suggerire miglioramenti tramite pull request. Questo meccanismo è tipico del mondo open source: ad esempio, una comunità può contribuire a uno strumento di cyber security open source proponendo nuove funzionalità, correggendo bug o migliorando le performance, tutto attraverso GitHub.
• La grande facilità con cui si può condividere il codice: un repository pubblico può essere visualizzato, scaricato, analizzato da chiunque. È così che molti progetti di sicurezza – come strumenti di penetration testing, scanner di vulnerabilità o utility per il reverse engineering – crescono grazie alla collaborazione della community.

In ambito cyber security, GitHub diventa uno strumento prezioso per vari motivi:

• Gestione del codice sicuro
  Consente di applicare controlli di accesso, di effettuare revisioni del codice prima dell’integrazione e di rilevare eventuali modifiche sospette in tempo reale.
• Tracciabilità delle modifiche
  Ogni aggiornamento è tracciato con data, autore e contenuto. Questo è essenziale per gli audit di sicurezza e per risalire rapidamente a un’eventuale introduzione di codice malevolo o errato.
• Controllo sulle collaborazioni
  Solo utenti autorizzati possono effettuare modifiche, ma tutti possono contribuire aprendo issue o pull request. Questo mantiene un equilibrio tra apertura e sicurezza.

Esempio
Il tool “Fail2Ban”, molto usato per la protezione da brute force su server Linux, ha un repository GitHub attivo dove gli utenti segnalano problemi, propongono modifiche e aiutano a migliorare il prodotto. Grazie a questa struttura, il progetto è diventato più solido, sicuro e aggiornato nel tempo.

In definitiva, GitHub non è solo una piattaforma per programmatori: è un vero e proprio ecosistema collaborativo, sempre più importante anche per chi lavora nella sicurezza informatica, dove il codice – e la sua corretta gestione – può fare la differenza tra una rete protetta e una esposta a rischi gravi.

Che cos’è Git: il cuore di GitHub

Alla base di GitHub troviamo Git, un sistema di controllo versione distribuito ideato da Linus Torvalds nel 2005 per supportare lo sviluppo del kernel Linux.

Da allora, Git è diventato lo standard globale per la gestione del codice sorgente nei progetti software, anche (e soprattutto) in ambito cyber security.

Cosa fa Git e perché è importante

Git consente di registrare ogni modifica effettuata ai file di un progetto, in modo preciso, cronologico e tracciabile. Questo significa che puoi sapere in qualsiasi momento:

• Chi ha modificato cosa
• Quando è stata fatta la modifica
• Perché è stata apportata

Inoltre, Git permette di lavorare in modo parallelo e sicuro, anche in team composti da decine o centinaia di sviluppatori. Ogni sviluppatore può lavorare su una copia indipendente del progetto, detta branch (ramo), e unire le modifiche al progetto principale solo dopo revisione, approvazione e test.

Un esempio concreto

Immagina un team che sviluppa un sistema per il monitoraggio delle intrusioni in una rete aziendale. Uno sviluppatore lavora su una nuova funzionalità che analizza i log per individuare accessi sospetti. Per evitare di compromettere la versione stabile, crea un nuovo branch:

git checkout -b rilevamento-intrusioni

Inizia a modificare il codice sorgente, effettuando commit ad ogni cambiamento:

git add analisi_log.py

git commit -m "Aggiunto modulo per rilevamento pattern sospetti nei log"

Una volta completato il lavoro e testato il modulo, lo sviluppatore propone l’integrazione del suo branch nella versione principale del progetto (di solito chiamata main) tramite una pull request su GitHub, che viene revisionata dal team. Se approvata, viene eseguita la merge:

git checkout main

git merge rilevamento-intrusioni

Grazie a Git, le modifiche vengono integrate senza sovrascrivere accidentalmente il lavoro degli altri membri del team e mantenendo una cronologia dettagliata.

Evitare conflitti e gestire codice critico

Uno dei punti di forza di Git è la sua capacità di gestire conflitti in modo intelligente. Se due sviluppatori modificano la stessa riga di codice, Git lo segnala durante la merge e consente di risolvere il conflitto manualmente. Questo è particolarmente importante nei progetti di cyber security, dove:

• La coerenza del codice è fondamentale per evitare falle di sicurezza.
• Gli errori umani possono introdurre vulnerabilità critiche.
• Ogni modifica deve essere revisionata e documentata per ragioni di conformità e auditing.

Versionare codice per tool di sicurezza

Supponiamo di avere uno script Python che scansiona porte aperte su una rete interna:

import socket

def scan_ports(ip):

    for port in range(1, 1025):

        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:

            s.settimeout(0.5)

            result = s.connect_ex((ip, port))

            if result == 0:

                print(f"Port {port} is open")

scan_ports("192.168.1.1")

Tramite Git, puoi:

• Tenere traccia delle modifiche a ogni versione dello script.
• Documentare l’aggiunta di nuove funzionalità (es. scansione UDP, logging su file).
• Verificare chi ha introdotto una modifica che, per esempio, esponeva per errore i risultati della scansione a terzi.

In sintesi

Git è molto più di uno strumento per sviluppatori: è un pilastro dell’integrità del codice. Permette di lavorare in modo ordinato, sicuro e trasparente. Nei progetti di cyber security, dove ogni dettaglio conta, Git assicura:

• Controllo rigoroso sulle versioni
• Collaborazione senza rischi
• Tracciabilità completa delle modifiche

Questo lo rende uno strumento indispensabile, non solo per scrivere software, ma per proteggerlo.

Come Git e GitHub lavorano insieme

Quando si usano insieme Git e GitHub, si ottiene un potente sistema per versionare, collaborare e proteggere il codice sorgente. Ogni file caricato su GitHub viene automaticamente gestito da Git, che si occupa di tracciare ogni cambiamento, permettendo di sapere chi ha fatto cosa, quando e perché.

Questo è fondamentale in ogni progetto di sviluppo, ma lo è ancora di più quando si lavora su codice sensibile in ambito cyber security.

Repository locale e repository remoto: due mondi sincronizzati

Il flusso di lavoro tipico prevede due ambienti:

• Un repository locale, ovvero una copia del progetto sul proprio computer.
• Un repository remoto, ospitato su GitHub, accessibile online.

Lo sviluppatore lavora localmente, e sincronizza il lavoro con GitHub attraverso due comandi fondamentali: push e pull.

Esempio pratico: dal locale a GitHub

Supponiamo che tu stia creando uno script per monitorare le connessioni aperte su un server:

mkdir net-monitor

cd net-monitor

git init

Crei un semplice script Python:

# monitor.py

import psutil

for conn in psutil.net_connections():

    if conn.status == "ESTABLISHED":

        print(f"Active connection: {conn.laddr} → {conn.raddr}")

Lo aggiungi al repository Git:

git add monitor.py

git commit -m "Initial commit: script for active connection monitoring"

Poi crei un nuovo repository su GitHub, lo colleghi al tuo progetto e carichi il codice:

git remote add origin https://github.com/tuonomeutente/net-monitor.git

git push -u origin main

A questo punto, il codice è disponibile anche online e pronto per essere condiviso, revisionato o integrato da altri membri del team.

Pull e push: sincronizzazione continua

Durante il lavoro in team, è fondamentale mantenere allineati i repository locale e remoto.

• Quando vuoi recuperare gli aggiornamenti fatti da altri, usi:

git pull origin main

• Quando hai finito di lavorare sul tuo codice e vuoi caricarlo su GitHub, usi:

git push origin main

Questi due comandi ti assicurano di lavorare sempre sull’ultima versione del progetto e di non perdere modifiche importanti fatte dai colleghi.

Pull request: revisione e integrazione del codice

Una volta che hai lavorato su una nuova funzionalità o risolto un problema, non è buona prassi modificare subito la versione principale (main). Invece, si crea un branch:

git checkout -b fix-logging

Si apportano le modifiche, si fa il commit e si caricano i cambiamenti:

git add logger.py

git commit -m "Improved logging to write to syslog"

git push origin fix-logging

A questo punto, su GitHub si apre una pull request: è una proposta di integrazione del nuovo ramo nel progetto principale. Qui è possibile:

• Discutere con il team.
• Richiedere modifiche.
• Eseguire test di sicurezza.
• Fare il merge finale in main solo dopo l’approvazione.

Sicurezza nel flusso di lavoro

Il flusso di push, pull e pull request è completamente tracciato. Git registra:

• L’identità dello sviluppatore (tramite nome, email, e autenticazione GitHub).
• Ogni modifica con hash univoci (i commit ID).
• Le differenze tra versioni (diff).
• Gli eventuali conflitti e risoluzioni.

In ambito cyber security, tutto questo è fondamentale per:

• Audit di sicurezza
  Sapere quando e da chi è stato introdotto un nuovo modulo o fix.
• Incident response
  Ripristinare una versione precedente in caso di attacco o errore grave.
• Controllo degli accessi
  Solo utenti autorizzati possono effettuare push, e i permessi possono essere gestiti granularmente (lettura, scrittura, amministrazione).

Esempio finale: collaborazione sicura

Immagina un progetto per un firewall applicativo open source. Il codice è su GitHub, pubblico. Un ricercatore scopre una possibile vulnerabilità nel modulo di analisi delle richieste HTTP. Non ha accesso diretto al progetto, ma può:

1. Fare un fork del repository.
2. Correggere il codice nel suo fork.
3. Aprire una pull request spiegando la vulnerabilità e la soluzione.

Il team principale potrà:

• Esaminare la proposta.
• Testarla.
• Integrare la modifica (merge).
• Ringraziare pubblicamente il contributore, mantenendo il progetto aggiornato e sicuro.

In sintesi, Git e GitHub lavorano insieme per offrire un ambiente di sviluppo:

• Collaborativo
• Controllato
• Sicuro
• Scalabile

Un vero punto di riferimento per chi scrive codice critico, lavora in team distribuiti o sviluppa strumenti per la cyber security.

Chi usa GitHub e perché

GitHub è utilizzato da una vasta comunità:

• Sviluppatori singoli e team aziendali.
• Ricercatori, studenti e docenti.
• Professionisti della sicurezza informatica che analizzano, correggono e monitorano codice sorgente.
• Hacker etici che contribuiscono a migliorare la sicurezza di software open source.

La ragione di questo successo è semplice: GitHub è lo standard de facto per il versionamento del codice e per la collaborazione software. È utile per centralizzare il lavoro, aumentare la trasparenza e facilitare la comunicazione tra sviluppatori.

Nel campo della cyber security, GitHub è spesso utilizzato per:

• Analizzare codice sospetto o vulnerabile.
• Gestire strumenti di scansione e test di penetrazione open source.
• Collaborare a progetti di red teaming o blue teaming.
• Mantenere aggiornati gli script di automazione della sicurezza.

Da dove iniziare

Se sei nuovo nel mondo di Git e GitHub, non preoccuparti: imparare a usare questi strumenti è più semplice di quanto sembri. Il primo passo è creare un account gratuito su GitHub andando su https://github.com. Bastano un’email e una password, e sarai subito parte di una delle più grandi community di sviluppatori al mondo.

Il GitHub Flow: il flusso di lavoro base

Il modo più semplice per iniziare è seguire il GitHub Flow, il processo che GitHub consiglia per lavorare in modo ordinato e collaborativo. Ecco i passaggi principali, spiegati passo dopo passo e con esempi concreti:

1. Creazione di un repository

Un repository è come una cartella virtuale che contiene tutto il tuo progetto: file di codice, documentazione, immagini, cronologia delle modifiche e molto altro.

Puoi crearne uno direttamente dal tuo browser GitHub cliccando su “New repository”, oppure da terminale:

git init nome-progetto

Poi, colleghi il tuo progetto locale a quello su GitHub:

git remote add origin https://github.com/tuonomeutente/nome-progetto.git

2. Creazione di un branch

Per lavorare in sicurezza senza toccare il codice principale (main), si crea un branch:

git checkout -b nuova-funzionalità

Esempio
Se stai aggiungendo un modulo per criptare i dati utente in un’applicazione, potresti chiamare il ramo crittografia.

3. Scrittura del codice

In questo nuovo ramo puoi scrivere il tuo codice senza preoccuparti di rompere nulla. Esempio: stai aggiungendo una funzione di hashing password in Python.

import hashlib

def hash_password(password):

    return hashlib.sha256(password.encode()).hexdigest()

Poi salvi e fai commit:

git add sicurezza.py

git commit -m "Aggiunta funzione hash_password con SHA-256"

4. Push del branch e apertura di una pull request

Per condividere il tuo lavoro con gli altri membri del progetto (o con te stesso su GitHub, se sei da solo), invii il branch sul repository remoto:

git push origin nuova-funzionalità

Su GitHub vedrai l’opzione per aprire una pull request: è una richiesta formale per dire “ecco cosa ho fatto, posso unirlo al codice principale?”. Qui puoi:

• Descrivere cosa hai aggiunto o modificato
• Aggiungere documentazione o screenshot
• Assegnare revisori

5. Revisione e merge del codice

Altri membri del team (o tu stesso, se stai lavorando in autonomia) possono ora revisionare il codice, commentare eventuali problemi o suggerire miglioramenti. Se tutto è ok, si procede con il merge del branch nel ramo principale (main).

Questo si può fare via interfaccia web oppure da terminale:

git checkout main

git merge nuova-funzionalità

Infine, puoi cancellare il branch ormai integrato:

git branch -d nuova-funzionalità

Risorse per principianti

Se sei all’inizio, GitHub mette a disposizione una serie di guide gratuite nella sezione “Start your journey”, che puoi trovare su:

https://docs.github.com/en/get-started

Qui puoi imparare:

• Come creare e organizzare un profilo GitHub
• Come leggere e capire una pull request
• Come contribuire a progetti open source
• Come usare GitHub Desktop per chi non ama il terminale

Anche il sito https://learngitbranching.js.org è perfetto per capire visivamente come funzionano i rami Git.

Vuoi iniziare con qualcosa di reale?

Prova a cercare su GitHub un progetto open source legato alla cyber security, come ad esempio:

• OWASP Cheat Sheet Series
• fail2ban
• nmap

Scegli una piccola issue, leggila, prova a sistemarla sul tuo fork e invia la tua prima pull request. È così che si entra nella community — scrivendo codice, ma anche leggendo, studiando e migliorando.

---

Domande frequenti

1. Cos’è GitHub?
   È una piattaforma online per archiviare e gestire codice sorgente usando il sistema Git.
2. GitHub è gratuito?
   Sì, esiste un piano gratuito con funzionalità complete per uso personale e open source.
3. Che differenza c’è tra Git e GitHub?
   Git è il sistema di controllo versione, mentre GitHub è la piattaforma cloud che lo utilizza.
4. Come si usa GitHub?
   Tramite il browser o strumenti locali come GitHub Desktop, interagendo con repository remoti.
5. Posso usare GitHub anche senza conoscere Git?
   Sì, ma conoscere Git ti offre maggiore controllo e comprensione.
6. È sicuro usare GitHub per progetti di sicurezza?
   Sì, se si configurano correttamente i permessi e si seguono le best practice.
7. Cos’è una pull request?
   È una richiesta di revisione e integrazione di modifiche al codice.
8. Cosa significa “commit”?
   Un commit è una modifica salvata con un messaggio che ne descrive il contenuto.
9. Si può collaborare con altri su GitHub?
   Sì, la collaborazione è una delle funzioni principali di GitHub.
10. Esistono alternative a GitHub?
    Sì, come GitLab o Bitbucket, ma GitHub è la piattaforma più usata al mondo.