Vai al contenuto
GLGiuseppe Lanza Scrivimi

Il Mac pronto per il lavoro da sistemista

Command Line Tools, Rosetta 2, Homebrew e i pacchetti per il sistemista (nmap, mtr, iperf3, telnet, minicom, jq, coreutils GNU), un programma in C e le chiavi SSH.

Sistemi: macOS 13 Ventura – 26 Tahoe · Apple Silicon e IntelLivello: BaseTempo: 40 minutiAggiornata: novembre 2026

Cosa manca a un Mac appena acceso

Ho un Mac nuovo e domani devo configurare uno switch, controllare le porte di un server e fare un test di banda: cosa mi serve? Il Mac di fabbrica ha già molto (ssh, curl, rsync, nc, screen, tcpdump, openssl), ma mancano il compilatore, un gestore di pacchetti e gli strumenti di rete che su Linux diamo per scontati: nmap, mtr, iperf3, wget, perfino telnet, che Apple ha tolto da High Sierra.

In questa guida lo prepariamo in ordine: prima i Command Line Tools di Apple, poi Rosetta 2 se serve, poi Homebrew e i pacchetti; alla fine compiliamo un piccolo programma in C, facciamo le prime scansioni con nmap e sistemiamo le chiavi SSH.

I Command Line Tools

Sono il pacchetto di Apple con compilatore, linker, make, git e gli header di sistema: tutto quello che serve per compilare, senza i 10 e più GB di Xcode. Homebrew li richiede. Per prima cosa verifichiamo se ci sono già:

xcode-select -p
/Library/Developer/CommandLineTools        # installati
xcode-select: error: unable to get active developer directory…   # mancano

Se mancano, li installiamo:

xcode-select --install

Si apre una finestra: cliccate su Installa e accettate la licenza. Il download è di qualche centinaio di MB. Una volta completato verifichiamo:

xcode-select -p
pkgutil --pkg-info=com.apple.pkg.CLTools_Executables   # versione installata
gcc --version
Apple clang version …
Target: arm64-apple-darwin…

Notate la seconda riga: sul Mac gcc è in realtà clang. Apple ha lasciato il nome per compatibilità con script e Makefile, ma il compilatore è sempre clang. Per i programmi in C di tutti i giorni non cambia nulla; se un progetto richiede proprio il GCC di GNU, si installa con Homebrew (brew install gcc) e si chiama con il numero di versione, per esempio gcc-15.

Aggiornarli e reinstallarli

Gli aggiornamenti dei Command Line Tools arrivano con Aggiornamento Software; dal Terminale:

softwareupdate --list                  # compare «Command Line Tools for Xcode …» se c’è un aggiornamento
softwareupdate --install "Command Line Tools for Xcode-…"   # il nome esatto è quello dell’elenco

Dopo un aggiornamento importante di macOS capita che il compilatore dia errori strani o che manchino gli header (stdio.h non trovato). La soluzione è reinstallarli. Attenzione: xcode-select non ha un’opzione per rimuoverli (le opzioni sono solo --install, -p, -s, -r, -v); occorre cancellare la cartella e reinstallare:

sudo rm -rf /Library/Developer/CommandLineTools
sudo xcode-select --reset            # riporta il percorso attivo al valore predefinito
xcode-select --install

Controllate due volte il percorso prima di dare rm -rf con sudo. Se avete installato anche Xcode completo, potete scegliere quale usare: sudo xcode-select -s /Applications/Xcode.app/Contents/Developer per Xcode, sudo xcode-select -s /Library/Developer/CommandLineTools per tornare ai soli strumenti.

Rosetta 2: quando serve

Rosetta 2 traduce al volo i programmi compilati per Intel (x86_64) e li fa girare sui Mac Apple Silicon. Non è installata di serie: macOS la propone la prima volta che apriamo un’app solo Intel. Se preferiamo installarla subito, senza finestre (comodo anche negli script di preparazione):

softwareupdate --install-rosetta --agree-to-license

Con --agree-to-license accettiamo la licenza dalla riga di comando, senza conferma. Per verificare che ci sia:

arch -x86_64 /usr/bin/true && echo "Rosetta presente"
pgrep -l oahd                # il servizio di traduzione di Rosetta

Quando serve davvero? Per i programmi che esistono solo per Intel: vecchi client VPN o di gestione, utility dei produttori di apparati, alcuni driver di adattatori seriali con il loro pannello, immagini Docker amd64, strumenti a riga di comando distribuiti solo come binari Intel. Se tutto quello che usiamo è nativo, possiamo farne a meno. Per sapere per quale architettura è compilato un programma:

file /usr/local/bin/programma
lipo -archs /Applications/App.app/Contents/MacOS/App   # x86_64, arm64 o entrambe

Sui Mac Intel Rosetta non esiste e il comando risponde che non è necessaria. Apple ha già annunciato che Rosetta non resterà disponibile per sempre in forma completa nelle versioni future di macOS: se dipendete da un programma solo Intel, chiedete al produttore la versione nativa.

Homebrew

Homebrew è il gestore di pacchetti di fatto per il Mac: compila o scarica già pronti migliaia di programmi open source e li tiene aggiornati. Si installa con il comando pubblicato sul sito ufficiale brew.sh (copiatelo da lì, perché può cambiare):

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Lo script chiede la password di amministratore, installa i Command Line Tools se mancano e alla fine stampa le righe da aggiungere al profilo della shell (consiglio: lanciatelo da un account amministratore, per non avere problemi di permessi). Sui Mac Apple Silicon Homebrew sta in /opt/homebrew, che non è nel PATH predefinito; aggiungiamolo:

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"
brew --version
brew doctor          # «Your system is ready to brew» se è tutto a posto

Sui Mac Intel il percorso è /usr/local, che è già nel PATH: il passaggio di shellenv di solito non serve. In alternativa allo script, nella pagina delle release di Homebrew su GitHub c’è anche un pacchetto .pkg.

I comandi di tutti i giorni

brew search mtr              # cerca un pacchetto
brew info nmap               # versione, dipendenze, note
brew install nmap            # installa
brew list                    # cosa abbiamo installato
brew update                  # aggiorna l’elenco dei pacchetti
brew outdated                # cosa è da aggiornare
brew upgrade                 # aggiorna tutto (o: brew upgrade nmap)
brew uninstall nmap
brew cleanup                 # elimina le versioni vecchie e la cache
brew doctor                  # diagnosi dei problemi

Le app grafiche si installano con --cask: brew install --cask wireshark, brew install --cask iterm2. Un consiglio pratico: brew bundle dump scrive in un file Brewfile l’elenco di tutto quello che abbiamo installato, e brew bundle install lo reinstalla identico su un altro Mac.

I pacchetti utili per un sistemista

A questo punto installiamo gli strumenti di rete e di lavoro quotidiano. Possiamo farlo con un solo comando:

brew install nmap wget mtr iperf3 telnet inetutils minicom htop jq watch gnu-sed coreutils

Tabella 1 – Cosa fa ciascuno:

PacchettoA cosa serveEsempio
nmapScansione di host e porte, riconoscimento dei servizisudo nmap -sS -sV 192.0.2.10
wgetScaricare file, anche ricorsivamentewget -c https://…/firmware.bin
mtrtraceroute e ping insieme, in tempo reale: perdita di pacchetti per ogni saltosudo mtr 192.0.2.1
iperf3Misura della banda tra due hostiperf3 -s su uno, iperf3 -c 192.168.1.10 sull’altro
telnetIl client telnet classico, per apparati vecchi o per provare una portatelnet 192.0.2.1 23
inetutilsClient GNU di rete (telnet, ftp, tftp, rsh…), con il prefisso ggftp, gtftp, gtelnet
minicomTerminale seriale per le console degli apparatiminicom -D /dev/tty.usbserial-XXXX -b 9600
htopUn top più leggibile e interattivohtop
jqLeggere e filtrare JSON (API, output di system_profiler -json)curl -s https://… | jq '.items[].name'
watchRipete un comando ogni N secondiwatch -n 2 'netstat -an | grep ESTABLISHED'
gnu-sed, coreutilsLe versioni GNU di sed, ls, date, stat, timeout…gsed -i 's/a/b/' f, gdate -d yesterday

Qualche nota pratica:

  • mtr ha bisogno dei privilegi di root per inviare i pacchetti: lanciatelo con sudo. Homebrew lo mette in /opt/homebrew/sbin, che brew shellenv aggiunge al PATH.
  • Per la sola console seriale non è indispensabile minicom: il Mac ha già screen (screen /dev/tty.usbserial-XXXX 9600). Adattatori, driver e impostazioni sono in Il Mac come console per apparati di rete.
  • Per telnet basta uno dei due pacchetti: telnet installa il comando con il nome classico, inetutils lo chiama gtelnet ma porta con sé anche gftp e gtftp, comodi per caricare firmware e configurazioni.

Gli strumenti GNU senza rompere il Mac

coreutils, gnu-sed (e grep, findutils, gawk se servono) si installano con il prefisso g proprio per non nascondere i comandi BSD di sistema: gls, gdate, gstat, gtimeout, gsed. È la scelta giusta: alcuni script e programmi di macOS si aspettano le versioni BSD. Se in una sessione vogliamo i nomi GNU senza prefisso, possiamo anteporre al PATH le cartelle gnubin, ma solo nella finestra corrente:

export PATH="$(brew --prefix coreutils)/libexec/gnubin:$(brew --prefix gnu-sed)/libexec/gnubin:$PATH"
sed --version        # adesso è GNU sed, solo in questa finestra

Le differenze tra i comandi BSD e GNU sono riassunte in Il Terminale del Mac per sistemisti.

Compilare un programma in C

Con i Command Line Tools il Mac compila come una macchina Linux. Vediamo un esempio utile: un «ping TCP» che misura quanto tempo serve per aprire una connessione su una porta. È comodo quando il ping ICMP è bloccato da un firewall ma vogliamo sapere se un servizio risponde e con che latenza.

~/src/tcping.c
/* tcping.c - misura il tempo di apertura di una connessione TCP */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/time.h>

int main(int argc, char *argv[])
{
    if (argc != 3) {
        fprintf(stderr, "uso: %s host porta\n", argv[0]);
        return 2;
    }

    struct addrinfo hints, *res, *p;
    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;       /* IPv4 o IPv6 */
    hints.ai_socktype = SOCK_STREAM;   /* TCP */

    int err = getaddrinfo(argv[1], argv[2], &hints, &res);
    if (err != 0) {
        fprintf(stderr, "%s: %s\n", argv[1], gai_strerror(err));
        return 2;
    }

    int esito = 1;
    for (p = res; p != NULL; p = p->ai_next) {
        char ip[NI_MAXHOST];
        getnameinfo(p->ai_addr, p->ai_addrlen, ip, sizeof ip,
                    NULL, 0, NI_NUMERICHOST);

        int s = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
        if (s < 0)
            continue;

        struct timeval t0, t1;
        gettimeofday(&t0, NULL);
        int r = connect(s, p->ai_addr, p->ai_addrlen);
        gettimeofday(&t1, NULL);
        close(s);

        double ms = (t1.tv_sec - t0.tv_sec) * 1000.0
                  + (t1.tv_usec - t0.tv_usec) / 1000.0;
        if (r == 0) {
            printf("%s porta %s aperta: %.1f ms\n", ip, argv[2], ms);
            esito = 0;
            break;
        }
        printf("%s porta %s non raggiungibile (%.1f ms)\n", ip, argv[2], ms);
    }
    freeaddrinfo(res);
    return esito;
}

Compiliamo e proviamo:

cd ~/src
gcc -Wall -Wextra -O2 -o tcping tcping.c
./tcping 192.0.2.10 443
192.0.2.10 porta 443 aperta: 12.4 ms
./tcping 192.0.2.10 3389
192.0.2.10 porta 3389 non raggiungibile (0.8 ms)
echo $?                      # 0 = aperta, 1 = chiusa, 2 = errore: utile negli script

Il programma usa getaddrinfo, quindi accetta nomi e indirizzi IPv4 e IPv6, e prova tutti gli indirizzi restituiti dal DNS finché uno risponde. Un limite voluto, per tenerlo corto: non ha un timeout, quindi su una porta filtrata da un firewall (che non risponde affatto) connect resta in attesa a lungo prima di arrendersi; interrompetelo con Ctrl+C.

Per usarlo come un comando qualunque copiamolo in una cartella del PATH, per esempio sudo cp tcping /usr/local/bin/. Un programma compilato da noi non ha l’attributo di quarantena e Gatekeeper non lo blocca. Se lo vogliamo portare anche su un Mac Intel, compiliamo un binario universale:

clang -O2 -arch arm64 -arch x86_64 -o tcping tcping.c
lipo -archs tcping
x86_64 arm64

nmap: le prime scansioni

Solo sulle proprie reti

Una scansione delle porte è un’attività che gli amministratori di rete e i sistemi di sicurezza considerano ostile. Usiamo nmap solo su reti e host che gestiamo, oppure con un’autorizzazione scritta del proprietario che indichi indirizzi e orari. Scansionare sistemi altrui senza permesso può avere conseguenze legali, oltre a far scattare allarmi e blocchi.

Ne avevo parlato già nella mia vecchia guida sulla sicurezza di Linux: lo strumento è lo stesso, sul Mac cambia solo l’installazione. Partiamo dalla scoperta degli host attivi in una rete:

sudo nmap -sn 192.168.1.0/24          # quali host rispondono, senza scansione di porte

Poi la scansione che uso più spesso, sulle porte più comuni di un host, con il riconoscimento dei servizi e delle versioni:

sudo nmap -sS -sV -T4 192.168.1.10
  • -sS è la scansione SYN («mezza apertura»): veloce e discreta, ma richiede i privilegi di root, per questo il sudo. Senza sudo nmap ripiega su -sT, che completa la connessione.
  • -sV interroga le porte aperte per capire quale servizio e quale versione rispondono (per esempio OpenSSH 9.6p1, nginx 1.24).
  • -T4 è un profilo di temporizzazione più rapido del predefinito, adatto a reti locali. Su collegamenti lenti o con firewall sensibili meglio -T3 o meno.

Per default nmap controlla solo le 1000 porte più comuni. Per tutte le 65.535 porte TCP:

sudo nmap -sS -sV -T4 -p- 192.168.1.10
sudo nmap -sS -p 22,80,443,3389 192.168.1.0/24 --open   # solo alcune porte, solo gli host che le hanno aperte
sudo nmap -sU --top-ports 50 192.168.1.10                # UDP: lento, limitiamo le porte
sudo nmap -sS -sV -T4 -oA scansione-2026-11-16 192.168.1.10   # salva in tre formati

Un esempio di risultato:

PORT     STATE SERVICE  VERSION
22/tcp   open  ssh      OpenSSH 9.6p1 Ubuntu 3ubuntu13 (Ubuntu Linux; protocol 2.0)
80/tcp   open  http     nginx 1.24.0 (Ubuntu)
443/tcp  open  ssl/http nginx 1.24.0 (Ubuntu)
3306/tcp filtered mysql

open vuol dire che un servizio risponde, closed che l’host risponde ma sulla porta non c’è nulla, filtered che un firewall scarta i pacchetti. Sul Mac, se abbiamo più interfacce attive (Wi-Fi, Ethernet, VPN), conviene indicare quella da usare con -e en0. Per un’interfaccia grafica c’è Zenmap, distribuito sul sito ufficiale di nmap.

Terminali alternativi e chiavi SSH

Il Terminale di Apple va benissimo, ma chi passa la giornata in console spesso preferisce iTerm2 (brew install --cask iterm2): pannelli divisi, ricerca nell’output, profili per host, invio dello stesso comando a più sessioni. Esistono anche altri terminali moderni installabili come cask; la scelta è di gusto, i comandi restano gli stessi. Ricordate solo che ogni terminale ha bisogno del suo permesso di accesso completo al disco, se serve.

Per collegarci ai server usiamo le chiavi e non le password. Generiamo una chiave Ed25519 con passphrase:

ssh-keygen -t ed25519 -C "utente@MacBook-di-Mario"
ssh-copy-id utente@192.168.1.10        # copia la chiave pubblica sul server

Sul Mac la passphrase si può salvare nel Portachiavi, così non la digitiamo a ogni collegamento:

~/.ssh/config
Host *
    AddKeysToAgent yes
    UseKeychain yes
    IdentityFile ~/.ssh/id_ed25519

Host srv-web
    HostName 192.168.1.10
    User utente
ssh-add --apple-use-keychain ~/.ssh/id_ed25519   # la prima volta: salva la passphrase
ssh srv-web

UseKeychain e --apple-use-keychain esistono solo nell’OpenSSH di Apple: se lo stesso config lo usiamo anche su Linux, mettiamo prima di UseKeychain la riga IgnoreUnknown UseKeychain. Come rendere sicuro il server dall’altra parte (solo chiavi, niente root, fail2ban) è spiegato in SSH sicuro su Linux; lo stesso meccanismo di chiavi lo avevo usato per i backup automatici in Un semplice backup con rsync.

Problemi comuni

SintomoCausa e soluzione
xcrun: error: invalid active developer pathMancano i Command Line Tools, capita spesso dopo un aggiornamento di macOS. Eseguiamo xcode-select --install; se dice che sono già installati, li reinstalliamo cancellando /Library/Developer/CommandLineTools.
fatal error: 'stdio.h' file not foundHeader mancanti o Command Line Tools danneggiati: sudo xcode-select --reset, e se non basta reinstalliamo.
zsh: command not found: brewHomebrew è installato ma /opt/homebrew/bin non è nel PATH: aggiungiamo la riga eval "$(/opt/homebrew/bin/brew shellenv)" a ~/.zprofile e apriamo una nuova finestra.
unknown or unsupported macOS version da brewHomebrew è più vecchio del macOS installato. Di solito si risolve con brew update; poi brew doctor.
Bad CPU type in executableIl programma è solo Intel e Rosetta non è installata: softwareupdate --install-rosetta --agree-to-license.
mtr: Failure to start mtr-packetMancano i privilegi: lanciamo sudo mtr.
nmap: You requested a scan type which requires root privilegesLe scansioni -sS, -sU e -O vanno lanciate con sudo.
gcc non accetta un’opzione di GCCSul Mac gcc è clang. Adattiamo le opzioni o installiamo il GCC vero con brew install gcc e usiamo gcc- seguito dalla versione.

Il passo successivo

Con gli strumenti installati non rimane che usarli: per le console seriali di switch e router vedi Il Mac come console per apparati di rete, per rotte, DNS e catture di pacchetti La rete dal Terminale del Mac, per i certificati Certificati e chiavi con OpenSSL dal Mac. Per capire chi è collegato a un server e da dove, dopo la scansione con nmap, c’è Analizzare connessioni, porte e ban su un server Linux.

Prima di andare in produzione

Prova sempre la configurazione in laboratorio, salva quella attuale prima di modificarla e tieni un accesso di emergenza (console o accesso fuori banda) quando lavori su firewall e VPN da remoto.