Webex mette un banner giallo in cima alla finestra. Offline - No internet connection. I servizi telefonici risultano disconnessi, non si sincronizza niente e non riesci a entrare nella riunione iniziata novanta secondi fa.
Non è un fastidio quando quella cosa è il tuo telefono di lavoro. Webex è dove arrivano le mie chiamate e la mia linea VoIP passa da lì, quindi un client che non si autentica è un telefono da scrivania che non squilla, una riunione a cui non partecipo e un collega che trova la segreteria. Mi ha fermato il lavoro. Non rallentato, non degradato. Fermato.
E non stava a me né causarlo né evitarlo. Una giornata di lavoro è andata storta per un controllo qualità che non è stato fatto, presso un fornitore che viene pagato, su un prodotto venduto con un contratto di supporto e su una piattaforma che la sua stessa pagina dei requisiti dichiara supportata. Non ho configurato male niente. Ho installato il pacchetto del vendor, dal repository del vendor, su una piattaforma che il vendor elenca, e non riusciva ad aprire una connessione TLS. Poi ho passato una serata del mio tempo a capire perché, tempo che chi ha firmato il pacchetto non ha speso.
La macchina non è offline. Il browser lì accanto carica le pagine. La posta arriva, il terminale scarica da un remote, e se chiedi al sistema operativo se raggiunge internet ti risponde di sì. Lo conferma anche Webex, nel suo stesso log, undici secondi prima di dirti il contrario.
Quello che è successo davvero è che la copia di OpenSSL che Cisco spedisce dentro Webex non trova nemmeno un’autorità di certificazione, perché è stata compilata per cercarle in /workspace/.conan2/p/b/cisco8ee8b59cf93de/p/ssl. Quella è una directory su un container di build di Cisco. Sul tuo computer non è mai esistita e non esisterà mai. Ogni connessione TLS dell’applicazione fallisce alla verifica del certificato, il token di login non si può rinnovare, un timer di quindici secondi scade e l’interfaccia ricorre all’unica spiegazione per cui ha una stringa.
Quindi il banner sbaglia in un modo preciso e poco utile. Dà la colpa alla tua rete. Il guasto è un percorso dentro la loro build.
È la versione 46.8.0.35631, su Fedora 44, kernel 7.2.4. È una piattaforma supportata. Cisco pubblica i requisiti di sistema per Linux e spedisce un .rpm firmato, webex-46.8.0.35631-1.x86_641. Quello che segue è come dimostrarlo in una decina di minuti, perché nessuno dei fix ovvi funziona, quello che funziona, e poi la parte che conta più di tutto il resto: non è un bug sottile. È una build che nessuno ha mai eseguito su una macchina diversa da quella che l’ha compilata.
Cosa ti sta dicendo davvero il banner
Webex gestisce lo stato di connettività con una macchina a stati composita, sette sotto-macchine ognuna con i propri timer. All’avvio si inizializzano così:
ConnectivityStateMachine::ConnectivityBanner - Initializing with state: Connected
ConnectivityStateMachine::Network - Initializing with state: NoNetwork
ConnectivityStateMachine::Services - Initializing with state: Connected
ConnectivityStateMachine::Mercury - Initializing with state: Disconnected
ConnectivityStateMachine::Authentication - Initializing with state: UserNotAuthenticated
ConnectivityStateMachine::Syncing - Initializing with state: Synced
ConnectivityStateMachine::Survivability - Initializing with state: SurvivabilityHide
Quaranta millisecondi dopo il sistema operativo risponde, e l’applicazione lo annota:
NetworkManagerPowerNetworkWatcher.cpp:93 onConnectivityCheckSuccess::
The host is connected to a network, that appears to be able to reach the full Internet.
Quella riga sta nello stesso file, nella stessa sessione, del banner che dice che non c’è connessione a internet. L’applicazione lo sapeva. Aveva la risposta in mano alle 08:25:12.131 e alle 08:25:27.132 ha mostrato il contrario.
In mezzo, questo:
| Ora | Cosa è successo |
|---|---|
| 08:25:12.131 | Il sistema operativo conferma la piena raggiungibilità di internet |
| 08:25:12.218 | Rilevamento proxy: nessuno configurato, connessione diretta |
| 08:25:12.241 | La prima richiesta HTTPS fallisce, errorCode: 167772294 Error in SSL handshake |
| 08:25:12.569 | Il rinnovo del token di accesso CloudApps fallisce, stesso codice |
| 08:25:12.571 | Il rinnovo del token di accesso Kms fallisce, stesso codice |
| 08:25:15.684 | Nuovo tentativo, falliscono entrambi |
| 08:25:21.745 | Nuovo tentativo, falliscono entrambi |
| 08:25:27.132 | Scade il timer di quindici secondi, il banner passa a NoInternet |
| 08:26:12.091 | Scadono i timer di sessanta secondi, i servizi scendono a DisconnectedShortTerm |
La sotto-macchina Authentication non esce mai da UserNotAuthenticated, quindi Services si considera disconnessa, quindi scatta il banner. Ogni passaggio è un comportamento corretto, dato l’input. È l’input a essere sbagliato, e l’input è un numero: 167772294, su ogni richiesta fallita, dalla prima all’ultima.
Quel numero è tutto l’articolo. Tienilo a mente.
Tre percorsi, nessuno dei quali esiste
Webex non usa l’OpenSSL di sistema. Si porta il suo, insieme alla sua libcurl, e la libcurl si collega a quello incluso invece che al tuo:
$ ldd /opt/Webex/bin/libcurl.so | grep -E 'ssl|crypto'
libssl.so.3 => /opt/Webex/bin/../lib/libssl.so.3
libcrypto.so.3 => /opt/Webex/bin/../lib/libcrypto.so.3
Fin qui tutto bene. Includere una libreria TLS è una scelta difendibile e molti vendor lo fanno. Quello che conta è cosa ci è stato cucito dentro, e OpenSSL te lo dice se glielo chiedi:
$ strings /opt/Webex/lib/libcrypto.so.3 | grep -E 'OPENSSLDIR|ENGINESDIR|MODULESDIR'
OPENSSLDIR: "/workspace/.conan2/p/b/cisco8ee8b59cf93de/p/ssl"
ENGINESDIR: "/workspace/.conan2/p/b/cisco8ee8b59cf93de/p/lib/engines-3"
MODULESDIR: "/workspace/.conan2/p/b/cisco8ee8b59cf93de/p/lib/ossl-modules"
Tre. Non un’impostazione sfuggita. L’intero prefisso di installazione, trascinato dalla macchina che l’ha compilato, in una libreria che arriva al cliente come pacchetto firmato su una piattaforma supportata.
OPENSSLDIR si imposta una volta sola, in fase di configure, con --openssldir, e la documentazione di build di OpenSSL è chiarissima su a cosa serve: «Directory for OpenSSL configuration files, and also the default certificate and key store.»2 Tutto ciò che riguarda la fiducia dipende da lì. Il file CA predefinito è cert.pem lì dentro e la directory CA predefinita è certs lì dentro3. /workspace è una cache di build di Conan. Conan è il package manager C++ con cui compila Cisco, e salva ogni pacchetto sotto un hash dei suoi input di build4. L’hash cisco8ee8b59cf93de è un dato su un container che probabilmente è stato cancellato pochi minuti dopo la fine della build.
Chiedi alla libreria cos’è, e non è nemmeno l’OpenSSL standard:
VERSION CiscoSSL 3.5.5.8.5.4 27 Jan 2026
BUILT_ON built on: Wed Feb 25 06:29:18 2026 UTC
PLATFORM platform: conan-Release-Linux-x86_64-gcc-13
DIR OPENSSLDIR: "/workspace/.conan2/p/b/cisco8ee8b59cf93de/p/ssl"
Un fork interno mantenuto, con un suo schema di versioni, compilato a febbraio, spedito ad agosto, e che si porta ancora dietro la directory di lavoro in cui è stato fatto.
Non prendere strings per una risposta. Chiedilo alla libreria
strings trova del testo in un file. Non dimostra che la libreria lo usi. Quindi carica la libreria spedita e chiediglielo direttamente: bastano una dozzina di righe di Python e niente root:
import ctypes
c = ctypes.CDLL("/opt/Webex/lib/libcrypto.so.3")
for f in ("X509_get_default_cert_file", "X509_get_default_cert_dir",
"X509_get_default_cert_file_env", "X509_get_default_cert_dir_env"):
getattr(c, f).restype = ctypes.c_char_p
print(f"{f:34} {getattr(c, f)().decode()}")
X509_get_default_cert_file /workspace/.conan2/p/b/cisco8ee8b59cf93de/p/ssl/cert.pem
X509_get_default_cert_dir /workspace/.conan2/p/b/cisco8ee8b59cf93de/p/ssl/certs
X509_get_default_cert_file_env SSL_CERT_FILE
X509_get_default_cert_dir_env SSL_CERT_DIR
Eccolo, dalla bocca della libreria stessa. Quando qualcosa dentro Webex chiede a questa copia di OpenSSL il trust store predefinito, riceve un file e una directory che non esistono. È quello che fa SSL_CTX_set_default_verify_paths, ed è quello che fa quasi ogni client se non gli è stato detto altro.
Le ultime due righe meritano attenzione, perché sono la via d’uscita: la libreria lascia che SSL_CERT_FILE e SSL_CERT_DIR sovrascrivano entrambi i valori5. Ricordati anche questo. Diventerà importante, e non nel modo che ti aspetti.
Riprodurre l’esatto codice di errore
Una dimostrazione a occhio non è una dimostrazione. Prendi libssl.so.3 e libcrypto.so.3 così come vengono spediti, fai un handshake vero verso un host vero usando solo i valori predefiniti della libreria, e guarda cosa torna indietro.
Il caso interessante è quello in cui i predefiniti puntano al nulla. SSL_CERT_FILE e SSL_CERT_DIR sovrascrivono esattamente i due valori che un OPENSSLDIR mancante lascia appesi, quindi puntarli a un percorso inesistente riproduce con precisione la condizione del pacchetto spedito:
$ SSL_CERT_FILE=/nonexistent/cert.pem SSL_CERT_DIR=/nonexistent/certs python3 tls.py
set_default_verify_paths -> 1
set_fd -> 1
SNI -> 1
SSL_connect -> -1 SSL_get_error -> 1
verify result 20: unable to get local issuer certificate
err: 0xa000086 error:0A000086:SSL routines::certificate verify failed
0x0A000086 in decimale è 167772294.
È il numero di ogni riga fallita nel log di Webex, e non viene da Webex. Viene dalla libreria TLS di Cisco, eseguita fuori dalla loro applicazione, che fallisce per un solo motivo: non aveva nessun trust anchor con cui verificare la catena. Stessa libreria, stesso errore, nessuna applicazione di mezzo.
Punta le stesse due variabili al bundle vero di Fedora e lo stesso percorso di codice va fino in fondo:
$ SSL_CERT_FILE=/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem python3 tls.py
SSL_connect -> 1 SSL_get_error -> 0
verify result 0: ok
Tra le due esecuzioni la rete non è cambiata in nulla. È cambiato il percorso di un file.
Perché niente ti ha avvisato
Due cose cospirano per rendere tutto silenzioso, e solo una è colpa di Cisco.
| Cosa non dice mai una parola | Progettato da | Perché resta zitto |
|---|---|---|
| Caricare un trust store che non c’è | OpenSSL, di proposito | SSL_CTX_set_default_verify_paths restituisce 1 che i percorsi esistano o no. «A missing default location is still treated as a success»3 |
| Non avere niente su cui ripiegare | Cisco, e a ragione | Certificati validati, self-signed rifiutati, retry SSL disattivato, quindi non esiste una modalità degradata che mascheri il guasto |
La prima è ragionevole. Un programma che porta i propri anchor separatamente non dovrebbe essere costretto a preoccuparsene, quindi la chiamata riesce, lo store è vuoto e da nessuna parte nello stack qualcosa dice ho caricato zero autorità di certificazione. La prima cosa che se ne accorge è un fallimento di verifica mezzo secondo dopo. Ho eseguito quella chiamata sulla libreria spedita con i percorsi puntati a /nonexistent e ha restituito 1. È nell’output qui sopra.
La seconda è una policy che arriva dal servizio, e il log la registra:
Wdm.cpp:1162 parseDeviceJson: Adding policy << allowSelfSignedCertificate with value: false
NetworkManager.cpp:1738 onConfigReady: ...httpRequestSSLRetryEnabled: 0
HttpRequestManager.cpp:1883 rawHttpRequest: {"validateCertificates":"true","useClientCertificate":"false"}
Quei tre flag sono l’unico motivo per cui questo guasto è un’interruzione e non qualcosa di molto peggio, e vale la pena soffermarcisi invece di passare oltre.
Ragionaci. La libreria inclusa carica zero trust anchor, e niente sotto il livello delle policy se ne sarebbe mai accorto, perché il fallimento è silenzioso per progetto fino in fondo. A trasformarlo in un banner sono stati tre flag. Ribaltane uno qualsiasi nel modo in cui molti client li spediscono e la stessa build non fallisce affatto. Si connette, a chiunque abbia un certificato qualsiasi, perché non ha niente con cui verificarlo.
Il problema è come si manifesta. L’utente vede «Offline - No internet connection». Il log riporta «Error in SSL handshake» e un intero decimale. La parola certificato non compare da nessuna parte dove l’utente o un tecnico di supporto di primo livello guarderanno mai, e l’unico indizio diagnostico è un numero da convertire in esadecimale prima che significhi qualcosa.
I fix che non hanno funzionato
Falliscono entrambi quelli ovvi, per motivi diversi, ed entrambi vale la pena conoscerli.
Modificare l’openssl.cnf spedito
Webex spedisce un file di configurazione in /opt/Webex/lib/openssl.cnf, e così com’è attiva un solo provider:
[provider_sect]
fips = fips_sect
Solo FIPS. Non il provider default, che è dove vivono i normali algoritmi TLS6. Rimetterlo è una modifica di una riga e non cambia assolutamente niente, perché l’OpenSSL incluso quel file non lo legge mai. Cerca openssl.cnf dentro OPENSSLDIR7, e OPENSSLDIR è il percorso che non esiste. Il file sta nella directory di installazione con un’aria autorevole. Nessuno lo legge.
È un secondo difetto nascosto dietro il primo. Anche se il problema del percorso venisse risolto domani puntando OPENSSLDIR a /opt/Webex/lib, questa configurazione verrebbe caricata e attiverebbe solo FIPS. E il modulo FIPS stesso viene caricato da MODULESDIR, il terzo percorso morto dello stesso albero, quindi nemmeno il fips.so spedito in /opt/Webex/lib può essere trovato. Tre percorsi, un prefisso sbagliato, e ognuno rotto in un modo che nasconde il successivo.
Impostare le variabili d’ambiente
La libreria rispetta SSL_CERT_FILE e SSL_CERT_DIR. L’ho dimostrato sopra. L’esecuzione riuscita è lì. Quindi la mossa ovvia è impostarle nel desktop entry, ed è quello che è stato provato:
Exec=env OPENSSL_CONF=/opt/Webex/lib/openssl.cnf \
SSL_CERT_FILE=/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem \
SSL_CERT_DIR=/etc/pki/tls/certs/ /opt/Webex/bin/CiscoCollabHost %U
Nessun cambiamento. E il motivo non è che Webex ignori le variabili. Il motivo è che il processo non le ha mai ricevute:
$ tr '\0' '\n' < /proc/20293/environ | grep -E 'SSL|OPENSSL|CURL'
$ tr '\0' '\n' < /proc/20293/environ | wc -l
99
Novantanove variabili nel processo Webex in esecuzione, e nessuna delle tre impostate. Perché su questa macchina ci sono due desktop entry con lo stesso nome:
| File | Cosa esegue la sua riga Exec | Scritto da |
|---|---|---|
/usr/share/applications/webex.desktop | la riga env con le tre variabili qui sopra, per intero | l’.rpm, poi modificato a mano |
~/.local/share/applications/webex.desktop | /opt/Webex/bin/CiscoCollabHost %U, senza nessun ambiente | il launcher di Webex stesso |
E la specifica non lascia dubbi su quale vinca: «The base directory defined by $XDG_DATA_HOME is considered more important than any of the base directories defined by $XDG_DATA_DIRS.»8 $XDG_DATA_HOME è ~/.local/share. La copia dell’utente oscura quella del pacchetto, ogni volta, su ogni desktop che segue la specifica9.
Quindi Webex installa una seconda copia del proprio launcher nella tua home, ed è quella che il desktop esegue. Modifica pure il file del pacchetto quanto vuoi. Stai modificando un documento che nessuno legge.
Il fix che funziona
Se la libreria pretende un percorso, dagli il percorso. Crea la directory che è stata compilata per cercare e riempila di symlink verso quella vera:
#!/bin/bash
# Point the bundled CiscoSSL at the system trust store by building the
# directory it was compiled to look for. Tested: Fedora 44, Webex 46.8.0.35631.
set -euo pipefail
OPENSSLDIR=$(strings /opt/Webex/lib/libcrypto.so.3 \
| grep -oP '(?<=OPENSSLDIR: ")[^"]+')
[ -n "$OPENSSLDIR" ] || { echo "no OPENSSLDIR found in the shipped library"; exit 1; }
for p in /etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem \
/etc/ssl/certs/ca-certificates.crt \
/etc/pki/tls/certs/ca-bundle.crt \
/etc/ssl/cert.pem; do
[ -f "$p" ] && { CA_BUNDLE="$p"; break; }
done
[ -n "${CA_BUNDLE:-}" ] || { echo "no system CA bundle found"; exit 1; }
echo "OPENSSLDIR: $OPENSSLDIR"
echo "CA bundle: $CA_BUNDLE"
sudo mkdir -p "$OPENSSLDIR"
sudo ln -sf "$CA_BUNDLE" "$OPENSSLDIR/cert.pem"
sudo ln -sf "$(dirname "$CA_BUNDLE")" "$OPENSSLDIR/certs"
sudo tee "$OPENSSLDIR/openssl.cnf" > /dev/null <<'CONF'
openssl_conf = openssl_init
[openssl_init]
providers = provider_sect
[provider_sect]
default = default_sect
fips = fips_sect
[default_sect]
activate = 1
CONF
echo "done. now restart Webex"
Riavvialo, e la stessa sequenza di avvio produce il risultato opposto. Stesso binario. Stesse righe di log. Il rinnovo del token, che prima falliva in sessanta millisecondi, ora finisce in trecentotrenta:
AuthTokenRequester.cpp:579 Managed to fetch a new Kms access token.
AuthTokenRequester.cpp:579 Managed to fetch a new CloudApps access token.
AuthTokenSupervisor.cpp:310 Auth tokens refreshed. Expires in [64799 secs].
AuthenticationManager.cpp:1860 onUserAuthenticated: User authenticated.
ConnectivityStateMachine::Authentication - UserNotAuthenticated -> UserAuthenticated
Autenticato in circa 750 ms, quindi il timer di quindici secondi non scatta mai e il banner non compare. I servizi telefonici passano da Disconnected a Connecting, uno stato che la sessione rotta non aveva mai raggiunto in un minuto di tentativi.
| Prima | Dopo | |
|---|---|---|
| Controllo di rete | passa | passa |
| Prima richiesta HTTPS | 167772294 Error in SSL handshake | HTTP 200 |
| Token CloudApps | fallito | ottenuto |
| Token Kms | fallito | ottenuto |
| Autenticazione | bloccata su UserNotAuthenticated | UserAuthenticated |
| Banner a 15 s | «Offline - No internet connection» | nessuno |
| Servizi telefonici | mai tentati | in connessione |
| Tempo per autenticarsi | mai | ~750 ms |
Nota cosa fa il fix al tuo filesystem, perché dovrebbe darti fastidio. Crea sulla tua macchina una directory di primo livello chiamata /workspace, un nome per cui il Filesystem Hierarchy Standard non ha posto10, con dentro il percorso di una cache Conan e l’hash di build di un’azienda da cui hai comprato del software. È questa la forma del rimedio che Cisco ti ha lasciato: montare l’ambiente di build di qualcun altro alla radice del tuo.
E si romperà anche. In tre modi:
| Quando si rompe | Perché | Cosa fai |
|---|---|---|
| Un aggiornamento di Webex | cisco8ee8b59cf93de deriva dagli input di build, quindi una dipendenza ricompilata vuol dire una directory nuova | Rilanci lo script; legge il percorso dal nuovo binario invece di dare per scontato quello vecchio |
| Un cambio di distribuzione | La destinazione del symlink è una scelta della distribuzione, non uno standard11 | La ripunti; lo script prova quattro percorsi noti |
| Una reinstallazione | /workspace non è nel backup, non è pacchettizzato e non appartiene a niente | Lo rilanci, ogni volta, per sempre |
Niente di tutto questo è manutenzione. Sei tu che fai le veci di un passaggio della pipeline di build di qualcun altro, a tempo indeterminato, gratis. Correggere un difetto a runtime, su ogni macchina che possiedi, perché il vendor non l’ha voluto correggere una volta sola in fase di build.
Conoscevano la regola e l’hanno applicata a metà build
Ecco cosa trasforma questo da segnalazione di bug in un’argomentazione.
Leggi la sezione dinamica dei binari spediti:
$ readelf -d /opt/Webex/bin/libcurl.so | grep RUNPATH
0x1d (RUNPATH) Library runpath: [$ORIGIN:$ORIGIN/../lib]
$ readelf -d /opt/Webex/bin/CiscoCollabHost | grep RUNPATH
0x1d (RUNPATH) Library runpath: [$ORIGIN/../lib]
$ORIGIN si espande al momento del caricamento nella directory che contiene l’oggetto stesso12. È lo strumento giusto per un bundle rilocabile e l’hanno usato come si deve. Dovevano: Webex spedisce lo stesso albero due volte, una in /opt/Webex e una in ~/.local/share/WebexLauncher/46.8.0.35631_9e6196c9-…/, e un launcher sceglie tra i due all’avvio. Due prefissi, una build, e il linker trova le sue librerie in entrambi.
Quindi chi ha fatto questo pacchetto aveva capito il problema alla perfezione. I percorsi assoluti non sopravvivono alla spedizione. L’hanno risolto per il codice.
Poi hanno lasciato i percorsi dei dati come stringhe assolute che nominano il container che li ha compilati. Stessa build. Stesso pomeriggio.
Quindi non si può archiviare sotto non lo sapevano. In $ORIGIN non ci si inciampa per caso. Lo usi perché hai capito che un percorso assoluto cucito in un artefatto spedito è un difetto, e l’hai capito abbastanza bene da andarlo a correggere nel linker. Poi la stessa build scrive tre percorsi assoluti nelle stesse librerie, e le spedisce.
Conoscere la regola e applicarla a metà build è peggio che non conoscerla. Non conoscerla è un problema di formazione, e la formazione si può correggere. Questo è un pacchetto che aveva dentro l’idea giusta, nero su bianco, nell’header ELF dove chiunque poteva leggerla, ed è uscito dalla porta rotto lo stesso. Il che ti dice che niente a valle del compilatore guardava il risultato. Niente di niente.
Il container c’era già
Da dove venga /workspace non è un mistero, e non devi tirare a indovinare. È nell’header del pacchetto:
$ rpm -qi webex | grep -E 'Build Host|Build Date|Vendor'
Build Date : Sat 08 Aug 2026 20:47:43 BST
Build Host : c964ea9239ae
Vendor : Cisco
c964ea9239ae non è un hostname che qualcuno abbia digitato. Sono dodici caratteri esadecimali, che è quello che un container riporta come hostname quando nessuno ne imposta uno. Quindi il pacchetto è stato compilato dentro un container, da un’azienda che ha chiaramente le immagini, il registry e l’orchestrazione per farlo, e tre artefatti distinti su questa macchina lo dicono in modo indipendente:
| Prova, letta dal pacchetto installato | Valore | Cosa dimostra |
|---|---|---|
Build Host nell’header RPM | c964ea9239ae | l’ID di un container, non una macchina di build |
OPENSSLDIR in libcrypto.so.3 | /workspace/.conan2/… | un percorso che esiste solo dentro quel container |
PLATFORM nella stessa libreria | conan-Release-Linux-x86_64-gcc-13 | una toolchain Conan in container |
Requires nell’RPM | glibc >= 2.28 | una soglia ABI scelta di proposito, e molto vecchia |
Poi l’hanno firmato. La build è finita alle 20:47:43 e la firma porta la data delle 21:02:07 della stessa sera, key ID 9995e5bbb5ccde3c. Quindici minuti. Quindi esiste un cancello di rilascio, qualcuno o qualcosa lo gestisce, e quello che attesta è chi ha fatto il pacchetto, non se il pacchetto funziona. Una firma è una dichiarazione sulla provenienza. Non è mai stata una dichiarazione di idoneità, e un processo che ha l’una e non l’altra ha le priorità al contrario.
Perché il passaggio mancante è quello economico. Il container è già nella pipeline. Prendi l’artefatto appena uscito, avvia un’immagine pulita di ogni distribuzione che dichiari di supportare, installalo, lancialo e leggi le prime cento righe del log:
docker run --rm fedora:44 sh -c '
dnf -y install ./webex-46.8.0.35631-1.x86_64.rpm &&
timeout 25 /opt/Webex/bin/CiscoCollabHost &
sleep 20
grep -c "Error in SSL handshake" ~/.local/share/Webex/current_log.txt'
Diverso da zero, ogni volta, su questa build. L’installazione è di 1,1 GB, quindi diciamo un minuto per target con la cache calda. Sei distribuzioni sono sei minuti di una macchina già accesa, su hardware che Cisco possiede già, in una pipeline che esiste già. Non è stato eseguito. Nemmeno una volta.
Ed è questa la risposta a quella cosa che si dice ancora su Linux, che supportare più distribuzioni è difficile. Ha smesso di esserlo il giorno in cui è arrivato questo tooling, e il tooling è lo stesso con cui compilano. Un’immagine base per target. Lo stesso artefatto in ognuna. La matrice è un ciclo.
Una pipeline che compila in un container e non ne esegue mai il risultato in uno non è una pipeline. È un compilatore con un cron job davanti e una chiave di firma dietro, e qualunque cosa produca è un tentativo.
Perché una release del 2026 è compilata contro una libc del 2018?
Il pacchetto dichiara di cosa ha bisogno, e la riga interessante è la prima:
$ rpm -q --requires webex | grep glibc
glibc >= 2.28
glibc 2.28 è uscita il 1° agosto 201813. È la versione di Red Hat Enterprise Linux 814, una release il cui supporto completo è finito nel 2024. Questo è un prodotto del 2026, compilato nel 2026, che punta alla libreria C del 2018. E poi si porta una propria copia da 2,5 MB di libstdc++.so.6 nella home dell’utente, perché il runtime C++ che va con una base così vecchia non riesce a reggere il codice.
Perché qualcuno dovrebbe ancora farlo? Perché non vogliono linkare staticamente.
È tutto qui. Nel momento in cui linki dinamicamente la libreria C dell’host, la distribuzione più vecchia che sei disposto a supportare diventa un vincolo sulla macchina su cui compili. Non puoi usare un simbolo di cui il target più vecchio non ha mai sentito parlare, quindi inchiodi la build a un’immagine base antica e resti lì. Ogni anno il divario cresce. Ogni nuova funzionalità del linguaggio o di una libreria arriva con una discussione su se la soglia si possa spostare. Spedisci la tua libstdc++ per tappare il peggio, e adesso mantieni anche un runtime privato.
Quel compromesso aveva senso quando un host di build era una macchina fisica in un rack che qualcuno doveva reinstallare. Non ha più senso da un decennio. Se devi proprio linkare una libc dell’host, un container per target ti dà una build vera su una versione vera di ogni piattaforma, e nessuna vincola le altre.
Ma guarda cosa ha comprato davvero qui la disciplina dei target vecchi. È conservatorismo ABI a caro prezzo: una soglia di otto anni fa, un runtime C++ incluso, una matrice di supporto congelata attorno. E il client continua a non partire. Perché quello che si è rotto è un percorso di file, e nessuna attenzione alle versioni dei simboli protegge un percorso di file. Hanno pagato la tassa di compatibilità e la tassa del bundling, e hanno saltato l’unico controllo che non costa niente. Entrambi i conti. Nessun prodotto.
Hanno pagato per un bundle autosufficiente e non l’hanno avuto
Il modo collaudato di spedire software commerciale su Linux è dipendere il meno possibile dall’host. Statico dove puoi, un albero autosufficiente dove non puoi, e nessuna ipotesi sulla distribuzione sottostante. Non è elegante e nessuno finge che lo sia. Esiste per via dell’alternativa. Un binario che ha bisogno di una certa versione di una certa libreria in un certo posto trasforma la macchina di ogni cliente in un ticket di supporto.
Cisco ha preso la seconda strada e ha incluso tutto. Ecco il conto:
| Cosa contiene il bundle | Dimensione o numero |
|---|---|
Oggetti condivisi in /opt/Webex/lib | 150 |
| La loro libcurl, CiscoSSL, zlib-ng, ICU, Kerberos, client CUPS, hunspell e motore di inferenza | tutti |
Installato in /opt/Webex | 1,1 GB |
Una seconda copia in ~/.local/share/WebexLauncher, per utente | 1,1 GB |
| Su disco per un client di chat e chiamate | 2,2 GB |
Due gigabyte di dipendenze. Questo è il prezzo pieno del bundling: il download, il disco, la duplicazione, il peso di sicurezza di essere l’unico che può correggere qualsiasi cosa lì dentro, tutto quanto. Paghi questo e quello che compri è un programma a cui non importa cosa ha installato l’host, che si comporta allo stesso modo su Fedora, Debian, Arch e qualunque cosa un cliente abbia standardizzato quest’anno, e che non può essere rotto da un aggiornamento di distribuzione di cui non ha mai sentito parlare.
Solo che gli importa. Gli importa moltissimo di una directory, ed è una directory su un server di build.
Hanno spedito il loro Kerberos, il loro ICU e il loro correttore ortografico, e non sono riusciti a spedire un percorso funzionante verso i certificati. Lo scopo stesso del bundle è essere autosufficiente, e non lo è proprio nell’unico aspetto che gli impedisce di funzionare. Ognuno di quegli 1,1 GB viene trovato correttamente tramite $ORIGIN. La quarantina di byte che conta di più no.
Ed è questo che mi fa arrabbiare. Il bundling è l’opzione costosa. Si sono presi la spesa, hanno fatto l’ingegneria difficile, hanno sistemato la rilocazione per centocinquanta librerie su due prefissi di installazione. Poi hanno puntato l’unica parte che decide se tutto il resto funziona verso una macchina che nessun cliente ha mai posseduto.
E nessuno l’ha documentato
Accanto al primo c’è un secondo fallimento, ed è quello che avrebbe intercettato il primo.
Chiedi al pacchetto che documentazione spedisce:
$ rpm -qd webex | wc -l
0
$ rpm -qc webex | wc -l
0
Nessun file di documentazione. E nessun file di configurazione. Zero voci marcate %config in un pacchetto che spedisce un openssl.cnf. Non è una questione estetica. Un RPM marca un file come %config perché il package manager conservi quello che l’amministratore ha cambiato, salvando un .rpmsave invece di sovrascriverlo1516. /opt/Webex/lib/openssl.cnf è spedito come file normale, quindi il prossimo aggiornamento sovrascrive qualsiasi modifica tu ci abbia fatto e non ti dice niente. L’unico file che un cliente potrebbe legittimamente dover ritoccare è quello che il packaging tratta come usa e getta.
Niente di pubblicato dice quale trust store usa il client, quali variabili d’ambiente rispetta o da dove legge la sua configurazione TLS. Non c’è una pagina da consultare. Non è mai stata scritta. L’unico modo in cui ho stabilito tutto questo è stato strings, readelf, ldd e ctypes sui binari spediti. Fare reverse engineering di un prodotto supportato per rispondere a una domanda a cui la documentazione avrebbe dovuto rispondere in una frase.
Ed ecco perché conta più di quanto sembri. Scrivere quella documentazione è già di per sé un test. Metti chiunque presso il vendor davanti a una pagina bianca intitolata da dove Webex per Linux legge i certificati CA, e la prima cosa che deve fare è andare a guardare. Nel momento in cui guarda, trova /workspace/.conan2/p/b/cisco8ee8b59cf93de/p/ssl, e la cosa successiva che gli esce è una domanda. I percorsi di configurazione documentati non sono burocrazia a beneficio del cliente. Sono l’audit più economico che un vendor possa fare sulla propria build, e saltarli è il modo in cui un percorso del genere sopravvive fino a una release.
Niente di tutto ciò è una grande richiesta. Di’ dove sta la tua configurazione. Di’ quali variabili d’ambiente rispetti. Marca i tuoi file di configurazione come configurazione, così un aggiornamento non se li mangia. Così il cliente che incontra un guasto ha un posto dove guardare che non sia un editor esadecimale.
Nessuno l’ha eseguito
Il passaggio mancante è stato nominato abbastanza volte qui sopra. Quello che vale la pena chiedersi è perché sia mancato su questa piattaforma e non sulle altre.
Non su Fedora, comunque. Su macOS e sul Fisher-Price OS (Windows) questa classe di guasto non può presentarsi allo stesso modo, perché quelle piattaforme hanno uno stack TLS di sistema con un trust store gestito dal sistema operativo. Linux non ha niente del genere. OpenSSL è il trust store, e quindi chi lo spedisce è responsabile di dove guarda. Così l’unica piattaforma dove la libreria inclusa regge davvero il peso è la piattaforma che è stata spedita senza test, il che è una decisione su quali clienti meritino uno smoke test.
L’intera indagine ha richiesto una serata: leggere il log, notare che il rilevamento di rete passava prima che il banner dicesse il contrario, estrarre il percorso compilato dal binario, riprodurre l’esatto codice di errore sulla libreria spedita. Tutto fatto con un agente AI che si occupava della correlazione dei log e del test con ctypes mentre io capivo cosa chiedergli. Lo dico per un solo motivo: la diagnosi che un vendor non ha mai fatto prima di firmare questo pacchetto e metterlo nel proprio repository è ora alla portata di una serata per qualsiasi cliente con la pazienza di guardare. Gli ingegneri di Cisco hanno Claude a disposizione come chiunque altro, e l’avrebbe costruito come si deve. Non puoi chiedergli di cucire /workspace/.conan2 in un artefatto spedito senza che ti dica cosa succederà quando l’artefatto lascia il workspace. Gli strumenti per intercettarlo non sono più scarsi, e nemmeno le conoscenze. Quello che manca è qualcuno presso il vendor il cui lavoro fosse guardare.
Intanto il percorso di supporto per chi incontra questo problema è un banner che dice che la sua internet non funziona. Riavvierà il router. Chiamerà il suo provider. Aprirà un ticket che non porta da nessuna parte, perché il sintomo che Cisco ha scelto di mostrare punta lontano da Cisco.
Questa è la lista completa di quello che è andato storto. Vale la pena dire come sarebbe stato fatto bene, perché ogni voce ha una risposta assodata che precede questo prodotto.
Come andava costruito
Basta con quello che è andato storto. Ecco lo standard, e non c’è niente di nuovo. È quello che spedire un binario sul computer di qualcun altro ti chiede da vent’anni.
Parti dalla decisione che Cisco ha preso bene in linea di principio e male nell’esecuzione: quanto dell’host sei disposto a far dipendere. Linkare staticamente è la risposta più forte, e vale la pena essere concreti, perché «basta linkarlo staticamente» viene sventolato da chi non ha mai dovuto farlo e liquidato da chi non ci ha mai provato.
| Cosa elimina | Cosa costa |
|---|---|
RUNPATH, e ogni modo di sbagliarlo, perché al caricamento non c’è nessuna ricerca | glibc non si linka staticamente in modo pulito: la risoluzione di nomi e utenti passa da dlopen, quindi il binario cerca comunque i moduli NSS dell’host17 |
| La soglia glibc, così la distribuzione più vecchia smette di dettare su cosa puoi compilare | Le parti LGPL comportano un obbligo di relinking, quindi restano dinamiche o spedisci il necessario per rifare il link |
Le rotture da aggiornamento di distribuzione, da libreria rinominata o da cache ldconfig vecchia | Ogni patch è tua: nessun aggiornamento di sicurezza della distribuzione arriva ai tuoi clienti |
dlopen di un .so versionato da una directory che potrebbe non esserci | Un download più grande, e nessuna condivisione di pagine tra processi |
E una riga nella colonna di sinistra che le altre si limitano a sostenere: l’artefatto prodotto dalla tua pipeline è l’artefatto che il cliente esegue, byte per byte. Lo testi e hai testato la cosa che hai spedito. È la proprietà di cui tutto questo articolo racconta l’assenza.
Sulla colonna di destra vale la pena essere onesti. Costi veri, e il motivo per cui si ricorre a musl o si accetta un ibrido. Ma guarda la terza riga. Avere ogni patch a proprio carico vale identicamente per quello che Cisco ha già fatto: un albero incluso di 150 librerie è lo stesso impegno senza nessuna delle garanzie al caricamento. Si sono impegnati a gestire ogni patch in ogni caso e non hanno avuto niente in cambio.
Quindi la regola è semplice, ed è la regola che hanno infranto: tutto quello che non puoi linkare dentro, devi trovarlo con un percorso relativo al binario. $ORIGIN per il codice, e la stessa disciplina, deliberatamente, per ogni percorso di dati che la libreria andrà a cercare. In questo caso sono quattro e ognuno ha un aggancio documentato:
| Cosa va a cercare la libreria | Cosa è stato spedito | Cosa avrebbe dovuto essere |
|---|---|---|
| Trust anchor | OPENSSLDIR/cert.pem, fissato in fase di build | spedito nell’albero, oppure SSL_CERT_FILE impostato all’avvio5 |
| Configurazione | OPENSSLDIR/openssl.cnf, stesso percorso, mai trovato | OPENSSL_CONF, puntato alla copia nel pacchetto5 |
| Provider, FIPS compreso | MODULESDIR, assoluto, quindi fips.so è irraggiungibile | OPENSSL_MODULES, «the directory from which cryptographic providers are loaded»5 |
| Engine | ENGINESDIR, assoluto | OPENSSL_ENGINES, oppure niente, visto che OpenSSL 4.0 ha rimosso del tutto il supporto agli engine5 |
Quattro percorsi, quattro variabili d’ambiente, tutte in una sola pagina di manuale che la loro stessa libreria si porta dietro. Se una qualsiasi stringa nel tuo artefatto inizia con / ed è stata decisa in fase di build, è un difetto che aspetta che un cliente lo trovi. Non esiste una terza opzione in cui un percorso di build assoluto vada bene.
I fix per questo caso, e il controllo che lo intercetta
Dal principio a questo difetto specifico. Sei modifiche, nessuna delle quali richiede ricerca:
| Fix | Sforzo | Perché è giusto |
|---|---|---|
Impostare --openssldir=/opt/Webex/lib/ssl e spedire l’albero | un flag di configure | Il percorso allora esiste nel pacchetto, che è a cosa serve il flag2 |
Impostare SSL_CERT_FILE/SSL_CERT_DIR in CiscoSSLUtils all’avvio, provando i percorsi noti delle distribuzioni | una dozzina di righe | Standard, documentato, già supportato dalla loro stessa libreria5 |
| Spedire loro stessi il bundle CA dentro il pacchetto | solo packaging | Controllo totale della fiducia, al prezzo di doverlo tenere aggiornato |
Correggere openssl.cnf perché attivi il provider default | una riga | Serve comunque, e oggi è nascosto dal guasto del percorso6 |
Marcare openssl.cnf come %config | una riga di spec | Impedisce a un aggiornamento di mangiarsi in silenzio la modifica di un amministratore15 |
| Pubblicare i percorsi e le variabili rispettate | una pagina | L’audit più economico che esista, e trova questo guasto mentre la scrivi |
Il primo è il fix da un flag e avrebbe fatto uscire il prodotto funzionante. È un solo valore in uno script di build, impostato una volta, che hanno sbagliato perché niente a valle l’ha mai controllato.
Il controllo è più piccolo del fix:
# in CI, on the packaged artefact, in a clean container
test -d "$(strings lib/libcrypto.so.3 | grep -oP '(?<=OPENSSLDIR: ")[^"]+')" \
|| { echo "shipping a trust store path that does not exist"; exit 1; }
Una riga. Avrebbe fatto fallire questa release a gran voce, a febbraio, sulla macchina che l’ha fatta, nel container che l’ha fatta, prima che il pacchetto venisse firmato. Il motivo per cui non c’è non è la difficoltà e non è il costo. È che nessuno è stato incaricato di scriverlo, e quindi verificare che l’artefatto pacchettizzato si comportasse da software non era compito di nessuno.
Cosa costa a tutti gli altri un processo di build trasandato
Tutto quello che c’è sopra è il processo di build di un solo prodotto visto dall’interno, e non te lo ripercorrerò. La domanda che vale la pena farsi è se quel livello di cura si fermi probabilmente a un solo team.
Quindi metti accanto il registro esterno. La CISA mantiene un catalogo delle vulnerabilità note per essere sfruttate attivamente. Non teoriche, non valutate a punteggio. Osservate mentre vengono usate contro le persone. Al 14 settembre 2026 contiene 1.710 voci18:
| Vendor | Voci nel catalogo KEV |
|---|---|
| Microsoft | 388 |
| Cisco | 98 |
| Apple | 94 |
| Adobe | 81 |
| 74 | |
| Oracle | 46 |
| Fortinet | 30 |
| VMware | 26 |
Seconda, dietro un monopolio dei sistemi operativi e davanti a tutti gli altri. L’aggiunta più recente per Cisco è entrata il 14 settembre 2026, il giorno prima che questo articolo fosse scritto.
Avevo contato lo stesso file tre settimane prima per /it/random/is-your-msp-lying-to-you-part2/: versione 2026.08.27, 1.685 voci, Cisco a 96. Due in più da allora, in ventuno giorni.
Siamo onesti su cosa quella tabella dimostra e non dimostra da sola. Una grande base installata in posti di valore attira attenzione, e l’attenzione trova i bug, quindi qualsiasi vendor di quelle dimensioni avrà una lista lunga. Il numero è un indizio, non un verdetto.
La composizione è più difficile da liquidare del totale. Venticinque delle novantotto voci di Cisco riguardano le linee di sicurezza: i firewall, le appliance, i concentratori VPN, i gateway di posta e web, i servizi di identità. E le quattro voci più recenti aggiunte contro di loro, una dopo l’altra, sono Secure Firewall Management Center due volte, Secure Firewall ASA e Secure Email Gateway, quest’ultima il 14 settembre 202618. Non gli switch. Non il kit di collaboration. I prodotti venduti apposta per essere la cosa che tiene al sicuro tutti gli altri.
Che è la frase verso cui tutto questo articolo stava camminando, quindi eccola detta chiaramente. Questa è un’azienda il cui mestiere è vendere appliance di sicurezza, e non riesce a far verificare un certificato a un client desktop. Non un caso difficile. Non un attacco nuovo. L’operazione di sicurezza più di routine dell’informatica, eseguita da ogni browser a ogni caricamento di pagina, in una libreria di cui hanno fatto il fork loro stessi, e l’hanno spedita puntata a una directory che non è mai esistita sulla macchina di un cliente. Poi l’hanno firmata.
Quello che questo articolo aggiunge è un campione del processo che c’è dietro. Non una vulnerabilità. Un semplice difetto di packaging, la classe di guasto meno sottile che esista, su una piattaforma supportata, che qualsiasi smoke test avrebbe intercettato se qualcuno si fosse preso la briga di eseguirlo, e spedito lo stesso. Se una pipeline di build mette questo davanti a un cliente pagante, non è ovvio cosa fermerebbe. Non ha fermato niente.
Posso chiedere perché questo è stato firmato?
Posso chiedere perché un pacchetto che non riesce a completare un handshake TLS è stato firmato e pubblicato per una piattaforma che la vostra stessa pagina dei requisiti elenca come supportata? Non chi l’ha firmato. Un nome non mi interessa e non è una questione di persone. Cosa l’ha permesso, perché qualcosa l’ha permesso, quindici minuti dopo la fine della build, e qualunque cosa sia è ancora in funzione oggi.
Ora la versione senza giri di parole. Questo non è un progetto che ho tirato giù da una forge accettando il rischio. È pagato. Dietro c’è un contratto, una linea di supporto, una pagina dei requisiti che fa un’affermazione su Linux e una chiave di firma che attesta che il pacchetto viene da Cisco ed è adatto all’installazione. Ognuna di queste è una dichiarazione fatta a un cliente, e su questa release ognuna non valeva niente, perché il risultato non è mai stato aperto.
E lo standard mancato qui non è il mio. È il loro. Le quattro variabili che avrebbero portato quei percorsi sono documentate in una pagina di manuale che spedite dentro il bundle. Il vostro stesso formato di packaging ha un marcatore %config che non avete usato e una sezione di documentazione che avete lasciato vuota. La vostra stessa build girava in un container che non avete mai usato per eseguire il risultato. Non sto chiedendo a un’azienda di networking e collaboration di inventare niente. Sto chiedendo perché non ha letto i propri manuali.
Quindi la scusa che non accetto è che sia difficile. Non è difficile per nessuno, e di certo non è difficile per un’azienda che lo fa tutti i giorni, a questa scala, per questi soldi. Chi fa questo mestiere tutti i giorni non ha scuse, ed essere grandi non è una scusa.
E posso chiederne un’altra, perché è quella che conta davvero. Vendete firewall. Vendete un gateway di posta, un concentratore VPN, un servizio di identità, un centro di gestione per tutto questo, e il discorso di vendita di ognuno è che voi lo capite meglio del vostro cliente. Quindi come fa un’azienda che si presenta come un’autorità sulla sicurezza di rete a spedire un client che non sa validare un certificato? Non che lo valida male in modo ingegnoso. Che non riesce nemmeno a cercarne uno, perché la directory non c’è mai stata.
Non c’è nessuna versione di quella risposta che voglia sentire che inizi con il team desktop separato dal team delle appliance. Sono la stessa firma, la stessa pipeline, la stessa dichiarazione pubblicata su una piattaforma supportata e lo stesso passaggio mancante alla fine, che è aprire la scatola. Se la validazione dei certificati non viene controllata prima della spedizione nel prodotto dove la rottura è rumorosa e innocua, non ho motivo di credere che venga controllata nel prodotto dove la rottura è silenziosa e costosa.
E la parte onesta, detta chiaramente. Niente di tutto questo mi ha sorpreso. Da questo vendor mi aspetto ormai questo standard, ed è per questo che, dove la scelta è mia, non compro il loro kit e non ci costruisco sopra. Non è una preferenza di marchio. È lo stesso giudizio che darei su qualsiasi fornitore: ho misurato il loro lavoro, più di una volta, e continua a tornare uguale. Il catalogo qui sopra è una misura. Quello che è servito per scrivere la prima metà di questo articolo è un’altra.
Il motivo per cui usavo Webex è che la scelta non era mia, e vale la pena dirlo, perché è la posizione in cui si trova la maggior parte di chi legge. Raramente puoi evitare un vendor di cui hai già preso le misure. Qualcun altro firma il contratto, il kit arriva, e il primo a scoprire cosa è stato saltato nella build sei tu, alla tua scrivania, con una riunione che sta per iniziare.
Spedire qualcosa che non hai mai eseguito
Ci sarà una spiegazione interna. Uno sprint pieno, una pipeline passata di mano, una piattaforma senza responsabile. Nessuna merita di essere ascoltata, perché ognuna descrive la stessa cosa: il lavoro non è stato fatto e niente nel processo richiedeva che lo fosse.
C’è un vecchio standard nei mestieri che non è mai arrivato nel software: non te ne vai dal lavoro finché non hai fatto funzionare la cosa. Riempi l’impianto e controlli ogni giunto. Dai tensione al quadro e provi ogni circuito. Non perché dubiti del tuo lavoro. Perché il cliente lo userà, e scoprirlo davanti a lui non è un risultato professionale. Nessuno ti guarda mentre lo fai. Lo fai lo stesso. È tutto il significato della parola.
Il software ha passato trent’anni a sostenere di essere diverso, che la build è il prodotto consegnato e l’installazione è un problema di qualcun altro, che una pipeline verde è la stessa cosa di un prodotto che funziona, e non lo è. Una build che non è mai stata eseguita fuori dal container che l’ha prodotta non è stata finita, è stata abbandonata nel punto in cui finirla diventa noioso. Tutto quello che c’è a valle è un’affermazione su un lavoro che non è stato fatto.
Il fix è un flag di configure. Il controllo è una riga di shell. Quello che è interessante non è il costo di nessuno dei due; il numero interessante è quante persone hanno digitato le loro credenziali in una finestra di Webex, l’hanno vista dire che la loro internet non funzionava, e ci hanno creduto, perché glielo diceva Cisco e Cisco è un’azienda di networking. Ecco cosa ha comprato davvero il test mancante: non un bug, una bugia che il prodotto racconta con sicurezza, a ogni avvio, a persone che non hanno modo di saperne di più.
Ed è questa la linea da tracciare prima di chiudere la scheda, perché le due metà di questo articolo non sono due argomenti. Un percorso di fiducia che punta a un container di build e un bypass dell’autenticazione su un’appliance di frontiera sono lo stesso difetto con una posta diversa. Entrambi sono un valore che nessuno ha controllato, in un artefatto che nessuno ha eseguito, firmato da un processo che attesta la provenienza e non l’idoneità. Quello che avevo davanti era del tipo innocuo. Si è rotto rumorosamente, sulla mia scrivania, e sono stato il primo a saperlo. L’altro tipo non te lo fa questo favore.
Nessuno in Cisco ha deciso di spedire un firewall sfruttabile, così come nessuno ha deciso di spedire un client che non raggiunge internet. Non è una difesa. È l’accusa. Nessuno dei due ha bisogno di essere deciso, ed è proprio questo il problema: entrambi sono ciò che esce dall’altra parte quando una pipeline compila, firma e pubblica senza che nessuno sia reso responsabile di aprire il risultato. Un processo che non intercetta una directory che non esiste non avrebbe mai intercettato una lunghezza non controllata, e un vendor che ti vende l’appliance che sorveglia il tuo perimetro non ha diritto a quel processo.
Quindi quando il nome di un vendor continua a comparire in quella lista, resisti alla spiegazione comoda che sono semplicemente grandi e molto presi di mira. La scala spiega il volume. Non spiega il tipo. Guarda invece cosa fa il loro processo di build con le cose noiose, perché le cose noiose si misurano dall’esterno, da te, oggi, sul kit che hai già.
Controlla i tuoi bundle. strings, readelf e venti minuti ti diranno quali dei tuoi vendor spediscono un percorso verso una macchina che non vedrai mai. Quello che stai misurando davvero non è il percorso. È se lì qualcuno stava guardando, e se la risposta è no su una cosa così economica da intercettare, sai già qual è sulle cose che non lo sono.
Cisco — Webex App system requirements — l’elenco delle piattaforme supportate, Linux compreso. ↩︎
OpenSSL — INSTALL.md,
--openssldir— «Directory for OpenSSL configuration files, and also the default certificate and key store.» ↩︎ ↩︎OpenSSL — SSL_CTX_load_verify_locations(3) — il file CA predefinito è
cert.peme la directory CA predefinitacerts, entrambi dentro la directory OpenSSL predefinita; e sui valori di ritorno, «A missing default location is still treated as a success.» ↩︎ ↩︎Conan 2 —
conan cache— i binari dei pacchetti stanno sotto un percorso con hash nella cache locale, che è da dove viene/workspace/.conan2/p/b/<hash>/p. ↩︎OpenSSL — openssl-env(7) —
SSL_CERT_DIReSSL_CERT_FILE«specify the default directory or file containing CA certificates». ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎OpenSSL — provider(7) — il provider predefinito e cosa resta non disponibile con una configurazione che lo omette. ↩︎ ↩︎
OpenSSL — config(5) — il file di configurazione che OpenSSL carica all’inizializzazione, e dove viene cercato. ↩︎
freedesktop.org — XDG Base Directory Specification — «The base directory defined by
$XDG_DATA_HOMEis considered more important than any of the base directories defined by$XDG_DATA_DIRS.» ↩︎freedesktop.org — Desktop Entry Specification — dove vengono cercati i file
.desktope come uno ne oscura un altro con lo stesso nome. ↩︎Filesystem Hierarchy Standard 3.0 — le directory che un filesystem root dovrebbe contenere,
/workspaceesclusa. ↩︎update-ca-trust(8) — come viene prodotto su Fedora e affini il bundle consolidato sotto
/etc/pki/ca-trust/extracted. ↩︎ld.so(8) —
$ORIGINsi espande nella directory che contiene il programma o l’oggetto condiviso, ed è ciò che rende rilocabile un albero incluso. ↩︎glibc timeline — «2018-08-01 GLIBC 2.28 — The GNU C Library version 2.28 is now available». ↩︎
glibc — Release wiki — la tabella versione-distribuzione; Red Hat Enterprise Linux 8 ha glibc 2.28. ↩︎
RPM — spec file reference —
%confige cosa fa il package manager con un file marcato come configurazione. ↩︎ ↩︎Fedora packaging guidelines — configuration files — quando un file spedito va marcato
%config. ↩︎glibc FAQ — perché un binario glibc linkato staticamente ha comunque bisogno a runtime dei moduli NSS dell’host. ↩︎
CISA — Known Exploited Vulnerabilities Catalog — contato dal feed JSON pubblicato, versione del catalogo 2026.09.14, 1.710 voci. ↩︎ ↩︎