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:
| Pacchetto | A cosa serve | Esempio |
|---|---|---|
nmap | Scansione di host e porte, riconoscimento dei servizi | sudo nmap -sS -sV 192.0.2.10 |
wget | Scaricare file, anche ricorsivamente | wget -c https://…/firmware.bin |
mtr | traceroute e ping insieme, in tempo reale: perdita di pacchetti per ogni salto | sudo mtr 192.0.2.1 |
iperf3 | Misura della banda tra due host | iperf3 -s su uno, iperf3 -c 192.168.1.10 sull’altro |
telnet | Il client telnet classico, per apparati vecchi o per provare una porta | telnet 192.0.2.1 23 |
inetutils | Client GNU di rete (telnet, ftp, tftp, rsh…), con il prefisso g | gftp, gtftp, gtelnet |
minicom | Terminale seriale per le console degli apparati | minicom -D /dev/tty.usbserial-XXXX -b 9600 |
htop | Un top più leggibile e interattivo | htop |
jq | Leggere e filtrare JSON (API, output di system_profiler -json) | curl -s https://… | jq '.items[].name' |
watch | Ripete un comando ogni N secondi | watch -n 2 'netstat -an | grep ESTABLISHED' |
gnu-sed, coreutils | Le versioni GNU di sed, ls, date, stat, timeout… | gsed -i 's/a/b/' f, gdate -d yesterday |
Qualche nota pratica:
mtrha bisogno dei privilegi di root per inviare i pacchetti: lanciatelo consudo. Homebrew lo mette in/opt/homebrew/sbin, chebrew shellenvaggiunge alPATH.- 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
telnetbasta uno dei due pacchetti:telnetinstalla il comando con il nome classico,inetutilslo chiamagtelnetma porta con sé anchegftpegtftp, 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.
/* 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
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 ilsudo. Senzasudonmap ripiega su-sT, che completa la connessione.-sVinterroga le porte aperte per capire quale servizio e quale versione rispondono (per esempioOpenSSH 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-T3o 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:
Host *
AddKeysToAgent yes
UseKeychain yes
IdentityFile ~/.ssh/id_ed25519
Host srv-web
HostName 192.168.1.10
User utentessh-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
| Sintomo | Causa e soluzione |
|---|---|
xcrun: error: invalid active developer path | Mancano 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 found | Header mancanti o Command Line Tools danneggiati: sudo xcode-select --reset, e se non basta reinstalliamo. |
zsh: command not found: brew | Homebrew è 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 brew | Homebrew è più vecchio del macOS installato. Di solito si risolve con brew update; poi brew doctor. |
Bad CPU type in executable | Il programma è solo Intel e Rosetta non è installata: softwareupdate --install-rosetta --agree-to-license. |
mtr: Failure to start mtr-packet | Mancano i privilegi: lanciamo sudo mtr. |
nmap: You requested a scan type which requires root privileges | Le scansioni -sS, -sU e -O vanno lanciate con sudo. |
gcc non accetta un’opzione di GCC | Sul 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.
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.