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:

OraCosa è successo
08:25:12.131Il sistema operativo conferma la piena raggiungibilità di internet
08:25:12.218Rilevamento proxy: nessuno configurato, connessione diretta
08:25:12.241La prima richiesta HTTPS fallisce, errorCode: 167772294 Error in SSL handshake
08:25:12.569Il rinnovo del token di accesso CloudApps fallisce, stesso codice
08:25:12.571Il rinnovo del token di accesso Kms fallisce, stesso codice
08:25:15.684Nuovo tentativo, falliscono entrambi
08:25:21.745Nuovo tentativo, falliscono entrambi
08:25:27.132Scade il timer di quindici secondi, il banner passa a NoInternet
08:26:12.091Scadono 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.

Dove ogni copia di OpenSSL sulla macchina cerca i suoi trust anchorUna macchina, due copie di OpenSSL, e solo una sa dove sono i certificatiA runtime nessuna delle due viene informata. Ognuna ha la risposta in una stringa compilata, decisa da chi ha fatto la build.La copia di sistema: OpenSSL 3.5.8, Fedora 44OPENSSLDIR compilato/etc/pki/tlsla directory c'ècert.pem → tls-ca-bundle.pemcerts/ → anchor con hashla catena è verificata su anchor realiL'handshake si completa. Ogni altro programma funziona.Ecco perché l'utente è sicuro che la rete vada bene.La copia spedita con Webex: CiscoSSL 3.5.5.8.5.4OPENSSLDIR compilato/workspace/.conan2/p/b/cisco8ee8b59cf93de/p/ssldirectory assente su ogni macchina clientecert.pem → assentecerts/ → assentelo store carica zero trust anchorL'handshake fallisce: errore 0x0A000086, decimale 167772294.Il banner mostrato all'utente dice che la rete non va.
Due copie di OpenSSL sulla stessa macchina. A nessuna delle due viene detto a runtime dove sta la fiducia. Ognuna ha una stringa compilata dentro, e una di quelle stringhe nomina una directory che è esistita solo sull’host di build di qualcun altro.

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.

Ogni passaggio di rete riesce. Quello che fallisce legge un file locale.Quattro passaggi attraversano la rete e riescono. Il quinto legge un file e no.Eseguito con libssl.so.3 e libcrypto.so.3 spedite, fuori da Webex, solo con i predefiniti della libreria.connessione TCP :443okClientHello, SNIokServerHello, catenaok, catena ricevutaverifica la catenanessun anchor caricatocosa riporta la libreriaSSL_connect -> -1verify result 20: unable to get local issuer certificateerr: 0xa000086 error:0A000086:SSL routines::certificate verify failed0x0A000086 in decimale è 167772294, il numero di ogni riga fallita nel log di Webex.L'applicazione non ha mai scritto la parola «certificato». Ha registrato «Error in SSL handshake» e un intero decimale, e l'interfaccial'ha trasformato in «Offline - No internet connection», l'unica cosa che la macchina chiaramente non era.Qui non c'è nessun guasto di rete. Mancava solo una directory.
Quattro passaggi attraversano la rete e riescono, compresa la ricezione dell’intera catena di certificati del server. Il passaggio che fallisce apre un file locale. All’utente viene mostrato un messaggio sulla sua connessione a internet.

Perché niente ti ha avvisato

Due cose cospirano per rendere tutto silenzioso, e solo una è colpa di Cisco.

Cosa non dice mai una parolaProgettato daPerché resta zitto
Caricare un trust store che non c’èOpenSSL, di propositoSSL_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 ripiegareCisco, e a ragioneCertificati 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.

Lo stesso trust store rotto, a un flag di policy da un guasto molto diversoIl percorso della fiducia è rotto in entrambe le colonne. Solo la policy decide come lo scopri.In comune: l'OPENSSLDIR compilato non esiste, quindi lo store carica zero autorità di certificazioneCome lo spedisce WebexvalidateCertificates: trueallowSelfSignedCertificate: falsehttpRequestSSLRetryEnabled: 0Niente con cui verificare, quindi rifiuta.Handshake fallito. Banner. Perdi una giornata.Rumoroso, e innocuo.Uno qualsiasi impostato al contrariovalidateCertificates: falseo self-signed ammessio retry senza verificaNiente con cui verificare, quindi procede.Handshake completato. Con chiunque.Silenzioso, e non innocuo.A separare i due esiti è un valore di policy di un altro team, a valle del difetto, per motivi estranei.Il percorso della fiducia non proteggeva nessuno. Era rotto ovunque; restava solo da vedere come sarebbe fallito.
La differenza tra «Webex oggi è offline» e «Webex si è fidato di chiunque abbia risposto» è un valore di policy impostato da un altro team, a valle del difetto, per motivi che non c’entrano niente.

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:

FileCosa esegue la sua riga ExecScritto da
/usr/share/applications/webex.desktopla riga env con le tre variabili qui sopra, per interol’.rpm, poi modificato a mano
~/.local/share/applications/webex.desktop/opt/Webex/bin/CiscoCollabHost %U, senza nessun ambienteil 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.

Due desktop entry con lo stesso nome, e vince quello che Webex scrive per séL'ambiente era impostato nel file che il desktop non legge maiDue entry, un nome. L'ordine di ricerca è scritto, e non favorisce la copia del pacchetto.Modificato a mano, e scavalcato/usr/share/applications/webex.desktopExec=env OPENSSL_CONF=... SSL_CERT_FILE=...mai letto finché esiste l'altro fileScritto da Webex, e vince~/.local/share/applications/webex.desktopExec=/opt/Webex/bin/CiscoCollabHost %Unessun ambiente impostatoscartatolanciatoSpecifica XDG base directory: the base directory defined by $XDG_DATA_HOME is considered moreimportant than any of the base directories defined by $XDG_DATA_DIRS.La prova, dal processo in esecuzione e non da un ragionamento:tr '\0' '\n' < /proc/20293/environ | grep -E 'SSL|OPENSSL' → nessun output, 99 variabili, nessuna di questeIl fix era vero, il file era vero, e il processo a cui era destinato partiva da tutt'altra parte.
L’ambiente era impostato nel file che il desktop non legge mai. Webex scrive la propria entry nella directory dati dell’utente, la specifica dice che quella ha la precedenza su quella del pacchetto, e la prova è il processo in esecuzione: novantanove variabili d’ambiente e nessuna delle tre.

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.

PrimaDopo
Controllo di retepassapassa
Prima richiesta HTTPS167772294 Error in SSL handshakeHTTP 200
Token CloudAppsfallitoottenuto
Token Kmsfallitoottenuto
Autenticazionebloccata su UserNotAuthenticatedUserAuthenticated
Banner a 15 s«Offline - No internet connection»nessuno
Servizi telefonicimai tentatiin connessione
Tempo per autenticarsimai~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 rompePerchéCosa fai
Un aggiornamento di Webexcisco8ee8b59cf93de deriva dagli input di build, quindi una dipendenza ricompilata vuol dire una directory nuovaRilanci lo script; legge il percorso dal nuovo binario invece di dare per scontato quello vecchio
Un cambio di distribuzioneLa destinazione del symlink è una scelta della distribuzione, non uno standard11La ripunti; lo script prova quattro percorsi noti
Una reinstallazione/workspace non è nel backup, non è pacchettizzato e non appartiene a nienteLo 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.

Un percorso nel bundle si riloca da solo. L'altro nomina una macchina in un data centre chissà dove.Sapevano che il bundle doveva spostarsi. L'hanno applicato solo al codice.Entrambi i valori sono fissati in build, dalle stesse persone, lo stesso giorno. Uno si espande al caricamento, l'altro mai.Da dove viene il codice: registrato come espressione relativaRUNPATH in libcurl.so$ORIGIN:$ORIGIN/../lib/opt/Webex/lib risolto~/.local/share/WebexLauncher/46.8.0.35631_.../lib risolto anche questoCorretto, e voluto. Lo stesso albero è spedito due volte in due prefissi diversi e il linker lo trova in entrambi.Da dove viene la fiducia: registrato come la directory di lavoro di qualcunoOPENSSLDIR in libcrypto.so.3/workspace/.conan2/p/b/cisco8ee.../p/sslpercorso inesistente non risoltoENGINESDIR e MODULESDIR: stesso albero, stesso esitoTre percorsi assoluti dentro un container di build, spediti a ogni cliente, su un prodotto con contratto di supporto.Tra le due metà di questa figura c'è solo una persona che esegue l'artefatto su una macchina che non l'ha compilato.Questo è tutto il difetto. Non un bug difficile. Uno mai testato.
La stessa build, lo stesso giorno, gli stessi ingegneri. Il percorso di ricerca delle librerie è registrato come un’espressione che si risolve ovunque finisca l’albero. Il percorso della fiducia è registrato come la directory di lavoro di qualcuno.

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 installatoValoreCosa dimostra
Build Host nell’header RPMc964ea9239ael’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 libreriaconan-Release-Linux-x86_64-gcc-13una toolchain Conan in container
Requires nell’RPMglibc >= 2.28una 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.

Compilano in un container e non ne eseguono mai il risultato in unoIl container è già nella pipeline. Lo usano solo per la metà che conviene al vendor.Ogni valore qui sotto è letto dal pacchetto installato sulla macchina, non dedotto.Build, dentro un containerBuild Host: c964ea9239ae/workspace/.conan2/p/b/...conan-Release-Linux-x86_64-gcc-13tre prove distinte di un containerFirma e pubblicazionebuild 20:47:43firma 21:02:07quindici minuti, e un cancello di rilascioche attesta chi, mai seClientednf install webexlo apre«Offline - No internet»Il passaggio che nella pipeline non c'è da nessuna partedocker run --rm fedora:44 sh -c 'dnf -y install ./webex.rpm && CiscoCollabHost &sleep 20; grep -c "Error in SSL handshake" ~/.local/share/Webex/current_log.txt'Stessa infrastruttura. Un'immagine per distribuzione. Meno di un minuto ciascuna, e su questa build fallisce a gran voce.Compilare per più distribuzioni non è più difficile da quando esiste questo tooling, lo stesso con cui compilano.Una pipeline che compila in un container e non vi esegue mai il risultato è un compilatore tra un cron job e una chiave di firma.
Tre prove indipendenti nel pacchetto spedito che la build è avvenuta in un container, una firma apposta quindici minuti dopo la build, e l’unico passaggio che non compare da nessuna parte: eseguire il pacchetto finito in un’immagine pulita di ogni piattaforma per cui viene venduto come supportato.

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 bundleDimensione o numero
Oggetti condivisi in /opt/Webex/lib150
La loro libcurl, CiscoSSL, zlib-ng, ICU, Kerberos, client CUPS, hunspell e motore di inferenzatutti
Installato in /opt/Webex1,1 GB
Una seconda copia in ~/.local/share/WebexLauncher, per utente1,1 GB
Su disco per un client di chat e chiamate2,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 eliminaCosa costa
RUNPATH, e ogni modo di sbagliarlo, perché al caricamento non c’è nessuna ricercaglibc 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 compilareLe 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 vecchiaOgni patch è tua: nessun aggiornamento di sicurezza della distribuzione arriva ai tuoi clienti
dlopen di un .so versionato da una directory che potrebbe non esserciUn 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 libreriaCosa è stato speditoCosa avrebbe dovuto essere
Trust anchorOPENSSLDIR/cert.pem, fissato in fase di buildspedito nell’albero, oppure SSL_CERT_FILE impostato all’avvio5
ConfigurazioneOPENSSLDIR/openssl.cnf, stesso percorso, mai trovatoOPENSSL_CONF, puntato alla copia nel pacchetto5
Provider, FIPS compresoMODULESDIR, assoluto, quindi fips.so è irraggiungibileOPENSSL_MODULES, «the directory from which cryptographic providers are loaded»5
EngineENGINESDIR, assolutoOPENSSL_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:

FixSforzoPerché è giusto
Impostare --openssldir=/opt/Webex/lib/ssl e spedire l’alberoun flag di configureIl 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 distribuzioniuna dozzina di righeStandard, documentato, già supportato dalla loro stessa libreria5
Spedire loro stessi il bundle CA dentro il pacchettosolo packagingControllo totale della fiducia, al prezzo di doverlo tenere aggiornato
Correggere openssl.cnf perché attivi il provider defaultuna rigaServe comunque, e oggi è nascosto dal guasto del percorso6
Marcare openssl.cnf come %configuna riga di specImpedisce a un aggiornamento di mangiarsi in silenzio la modifica di un amministratore15
Pubblicare i percorsi e le variabili rispettateuna paginaL’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:

VendorVoci nel catalogo KEV
Microsoft388
Cisco98
Apple94
Adobe81
Google74
Oracle46
Fortinet30
VMware26

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.

Lo stesso controllo mancante con due poste diverse, e solo uno te lo diceUn controllo mancante, due poste. Solo uno ti dice che c'è.Stesso fallimento: un valore non controllato, in un artefatto mai eseguito, firmato da un processo che attesta la provenienzaIl tipo che si rompe rumorosamentecos'eraun percorso di trust store inesistentechi l'ha trovatoil cliente, al primo avvioquanto è costatouna serata, una scrivaniachi l'ha saputoio, subitoFinisce scritto in pubblico.Il tipo che non rompe nientecos'erauna lunghezza mai controllatachi l'ha trovatochi è andato a cercarloquanto è costatoun incidentechi l'ha saputoil cliente, dal rapportoFinisce come 1 delle 98 di Cisco nel catalogo.Un processo che non intercetta la colonna di sinistra non avrebbe mai intercettato quella di destra. La differenza è fortuna, non diligenza.
Il difetto di questo articolo e le voci di quel catalogo sono lo stesso fallimento con vestiti diversi. Uno si è annunciato sulla mia scrivania al primo avvio. L’altro tipo si annuncia prima a qualcun altro.

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.


  1. Cisco — Webex App system requirements — l’elenco delle piattaforme supportate, Linux compreso. ↩︎

  2. OpenSSL — INSTALL.md, --openssldir — «Directory for OpenSSL configuration files, and also the default certificate and key store.» ↩︎ ↩︎

  3. OpenSSL — SSL_CTX_load_verify_locations(3) — il file CA predefinito è cert.pem e la directory CA predefinita certs, entrambi dentro la directory OpenSSL predefinita; e sui valori di ritorno, «A missing default location is still treated as a success.» ↩︎ ↩︎

  4. 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. ↩︎

  5. OpenSSL — openssl-env(7) — SSL_CERT_DIR e SSL_CERT_FILE «specify the default directory or file containing CA certificates». ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  6. OpenSSL — provider(7) — il provider predefinito e cosa resta non disponibile con una configurazione che lo omette. ↩︎ ↩︎

  7. OpenSSL — config(5) — il file di configurazione che OpenSSL carica all’inizializzazione, e dove viene cercato. ↩︎

  8. freedesktop.org — XDG Base Directory Specification — «The base directory defined by $XDG_DATA_HOME is considered more important than any of the base directories defined by $XDG_DATA_DIRS.» ↩︎

  9. freedesktop.org — Desktop Entry Specification — dove vengono cercati i file .desktop e come uno ne oscura un altro con lo stesso nome. ↩︎

  10. Filesystem Hierarchy Standard 3.0 — le directory che un filesystem root dovrebbe contenere, /workspace esclusa. ↩︎

  11. update-ca-trust(8) — come viene prodotto su Fedora e affini il bundle consolidato sotto /etc/pki/ca-trust/extracted. ↩︎

  12. ld.so(8) — $ORIGIN si espande nella directory che contiene il programma o l’oggetto condiviso, ed è ciò che rende rilocabile un albero incluso. ↩︎

  13. glibc timeline — «2018-08-01 GLIBC 2.28 — The GNU C Library version 2.28 is now available». ↩︎

  14. glibc — Release wiki — la tabella versione-distribuzione; Red Hat Enterprise Linux 8 ha glibc 2.28. ↩︎

  15. RPM — spec file reference — %config e cosa fa il package manager con un file marcato come configurazione. ↩︎ ↩︎

  16. Fedora packaging guidelines — configuration files — quando un file spedito va marcato %config. ↩︎

  17. glibc FAQ — perché un binario glibc linkato staticamente ha comunque bisogno a runtime dei moduli NSS dell’host. ↩︎

  18. CISA — Known Exploited Vulnerabilities Catalog — contato dal feed JSON pubblicato, versione del catalogo 2026.09.14, 1.710 voci. ↩︎ ↩︎