package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

15 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1

5 motivi per cui

le aziende

hanno bisogno di un

nuovo modello di

accesso alle

applicazioni

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

25 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1Analisi riassuntivaPer prosperare nel competitivo ambiente aziendale di oggi, le imprese devono fornire experience e servizi innovativi, efficaci, agili e sicuri. La trasformazione digitale e le tecnologie che la rendono possibile sono fondamentali per questa evoluzione. Le aziende che hanno più successo valutano e perfezionano continuamente il proprio stack tecnologico per soddisfare meglio gli imperativi della propria organizzazione e conservare la loro quota di mercato. Allora, perché un numero ancora così elevato di aziende si affida a tecnologie obsolete, complesse e, soprattutto, non sicure per l'accesso alle applicazioni? Le soluzioni di accesso alle applicazioni preesistenti, come le VPN, i proxy e i desktop remoti tradizionali, richiedono per natura la fiducia da parte dell'azienda. Un utente o un dispositivo devono essere verificati, ma, una volta autorizzati, possono accedere all'intera rete. L'onere della sicurezza spetta a un perimetro che offre una fiducia implicita una volta penetrati al suo interno. Tuttavia, questa struttura non è più attuabile perché la maggior parte delle moderne aziende dispone di utenti, dispositivi, applicazioni e dati al di fuori del tradizionale perimetro di rete. Inoltre, benché gli utenti e i dispositivi che richiedono l'accesso alla rete aziendale debbano comunque essere sempre verificati, non si deve garantire loro unilateralmente la fiducia o l'accesso completo alla rete solo per il fatto di trovarsi al suo interno. Un nuovo modello di accesso alle applicazioni che supporta un sistema Zero Trust è necessario per questo panorama aziendale. Questa adozione è critica e urgente a causa di cinque fattori dell'ambiente aziendale moderno:

1. Un panorama delle minacce sempre più ostile2. Un livello di velocità e scalabilità delle attività aziendali mai visto

prima d'ora3. Un ecosistema sempre più ampiamente distribuito 4. Il passaggio delle applicazioni aziendali ai sistemi cloud e SaaS 5. La carenza di competenze IT

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

35 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1I crimini informatici sono in aumento e difficilmente diminuiranno

1

di violazioni della sicurezza è collegato a utenti autorizzati

PIÙ DEL

40%

70%{ }delle aziende che subiscono incidenti importanti non riapre

o fallisce entro

3 anni

PIÙ DEL

In tutto il mondo, si stima che il costo del crimine informatico sia pari a 600 miliardi di dollari l'anno e, dal 2014, è incrementato anche di 100 miliardi in più.¹ Gli utenti malintenzionati sono sempre più pazienti e insistenti, nonché altamente incentivati dall'aspetto pecuniario. Gli attacchi sono personalizzati e mirati a specifiche aziende e le stesse minacce sono ampiamente disponibili per l'acquisto tramite crescenti schemi CaaS (Cybercrime-as-a-Service). Inoltre, i deterrenti per i cybercriminali sono minimi, in quanto prevale l'utilizzo di browser anonimi e criptovalute e la risposta internazionale resta disomogenea.

Ogni giorno, si registrano più di 350.000 nuovi programmi dannosi² e computer e utenti di Internet devono affrontare 80 miliardi di scansioni dannose.³ Inoltre, solo nella prima metà del 2018, sono stati compromessi 3.353.172.708 record, fino al 72% in più dalla prima metà del 2017.4 Tuttavia, forse è più sorprendente il fatto che oltre il 40% delle violazioni della sicurezza sia collegato a utenti autorizzati.5

Anche le conseguenze per le aziende compromesse aumentano sempre di più. In media, una violazione dei dati costa a un'organizzazione 3,86 milioni di dollari, anche se le più gravi "mega-violazioni" possono arrivare a costare da 40 a 350 milioni di dollari.6 Secondo il 90% dei CEO, riconquistare la fiducia delle parti interessate dopo una violazione è uno dei compiti più difficili da realizzare e più del 70% delle aziende che subiscono incidenti importanti non riapre o fallisce entro tre anni.7 Nessun segmento verticale è escluso: i giganti globali dell'industria, come anche enti pubblici e forze militari, hanno tutti subito attacchi paralizzanti negli ultimi anni.

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

45 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1Considerati questi fatti, non usare qualsiasi mezzo possibile per rafforzare il sistema di sicurezza della propria azienda è semplicemente un atto da irresponsabili. Tuttavia, le soluzioni di accesso tradizionali, come VPN, proxy e desktop remoti, sono stati progettati per aprire una breccia nel firewall della rete, offrendo tipicamente un accesso alla rete senza limitazioni. Questo sistema crea sicuramente notevoli problemi per gli odierni modelli aziendali. Nel caso di una violazione, questo accesso consente un movimento laterale e l'accesso ad applicazioni e dati al di là di quelli consentiti dalle credenziali dell'utente. Queste tecnologie di accesso preesistenti, inoltre, non sono intelligenti e non forniscono registrazioni dettagliate. Non possono confermare o verificare accuratamente l'identità degli utenti che tentano di accedere ad applicazioni specifiche. Le VPN tradizionali non possono neanche essere integrate in altri meccanismi di sicurezza, quali protezione del percorso dati, sicurezza e accelerazione delle applicazioni, e SSO (Single Sign-On).

Con il continuo proliferare dei crimini informatici e con le crescenti richieste di accesso da parte di gruppi di utenti più ampi, è essenziale adottare un nuovo modello di accesso alle applicazioni in grado di supportare una struttura di sicurezza Zero Trust. Fornire l'accesso a livello di applicazione, ma non di rete, e valutare l'autenticazione e l'autorizzazione di tutte le richieste rappresentano aspetti fondamentali; le autorizzazioni unilaterali a livello di rete devono essere sostituite da un accesso a livello di applicazione, personalizzato e diverso a seconda dei casi.

Poiché tutto sta diventando più veloce, non si rimarcherà mai abbastanza l'importanza della velocità come mezzo per il successo di un'azienda nell'odierno scenario. I vostri clienti e dipendenti se la aspettano e i vostri concorrenti lottano per averla. I leader di tutti i settori si trovano a dover guidare le loro organizzazioni verso una maggiore flessibilità, rimuovendo gli ostacoli che si frappongono al loro progredire, rendendo più consapevole la forza lavoro, incoraggiando la produttività e bilanciando le esigenze dell'infrastruttura con bassi costi fissi.

Un livello di velocità e scalabilità delle attività aziendali mai visto prima d'ora

2

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

55 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1ha visto il secondo

maggior numero di fusioni e acquisizioni mai registrato:

L'anno 2018

su 13.575 trattative

$ 2,72mila miliardi

Oltre a concentrarsi in particolar modo sul miglioramento del time-to-market, le aziende si stanno evolvendo e trasformando rapidamente. Fusioni ed acquisizioni sono comuni nell'odierno panorama aziendale. In effetti, il 2018 ha visto il secondo maggior numero di fusioni e acquisizioni mai registrato: 2,72 mila miliardi di dollari in 13.575 trattative.8 Inoltre, secondo il rapporto 2019 di Deloitte sulle tendenze relative a fusioni ed acquisizioni, si prevede un continuo aumento delle dimensioni delle trattative.9 Nel contempo, persistono le cessioni, con l'80% degli intervistati che ha affermato di avere progetti di vendita di risorse nell'anno a venire.10

Considerate queste realtà, le soluzioni di accesso alle applicazioni devono essere efficienti, convenienti e scalabili. Purtroppo, tecnologie di accesso obsolete non riescono a soddisfare questi requisiti, in quanto spesso

comprendono combinazioni ad hoc di hardware e software complicati. Come conseguenza di queste architetture frammentate, il provisioning e il deprovisioning dell'accesso, soprattutto a grandi gruppi di utenti, sono complicati e dispendiosi in termini di tempo per il reparto IT. Dal punto di vista dell'utente finale, ciò comporta spesso problemi di connessione, latenza e interruzioni, che causano frustrazione per i bassi tassi di adozione delle applicazioni e un maggior numero di ticket per l'help desk.

Soluzioni scarsamente integrate fanno anche ritardare il time-to-market; il business si interrompe e il reparto IT deve affrontare un fragile e complesso stack di rete ogni volta che sono necessari cambiamenti alla rete o aggiornamenti alle regole del firewall. Tutto ciò si riduce in uno spreco di risorse aziendali e in una diminuzione della produttività. La mancanza di un'agevole experience SSO (Single Sign-On), inoltre, provoca frustrazione negli utenti e blocca le operazioni ogni volta che gli utenti devono reinserire le password e l'IT deve risolvere i problemi riscontrati. Alla decelerazione delle attività aziendali si aggiungono anche gli errori nelle operazioni di rifiuto degli accessi come conseguenza di misure di autenticazione e autorizzazione non uniformi.

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

65 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1Inoltre, le operazioni di onboarding e revoca tramite i modelli di accesso tradizionali possono richiedere la configurazione o la dismissione di oltre 10 componenti di rete e di applicazioni per ogni utente.11 Succede anche che alcuni reparti IT con soluzioni di accesso alle applicazioni preesistenti siano costretti a inviare fisicamente l'hardware a una terza parte per rafforzare i controlli di sicurezza. Si tratta di un processo decisamente lento.

Dal momento che il ritmo dell'innovazione e delle interruzioni continua ad aumentare, un modello di accesso alle applicazioni aggiornato e basato sul cloud, in grado di fornire immediatezza, performance, convenienza e flessibilità, assume un ruolo di importanza critica. Le tecnologie e l'infrastruttura di un'azienda devono essere in grado di fluttuare, cambiare e tenere il passo con le esigenze dell'odierno panorama aziendale.

Oggi la composizione della forza lavoro è varia. Le aziende si affidano sempre più ad appaltatori, partner, fornitori, sviluppatori, canali di distribuzione e altri soggetti terzi per supportare le proprie iniziative. In effetti, i dipendenti stipendiati rappresentano la maggioranza solo nel 42% delle organizzazioni e, a livello globale, si contano 77 milioni di freelancer, vale a dire un incremento del 36% negli ultimi cinque anni.12 Si prevede che questa tendenza prenderà sempre più piede nel prossimo decennio.13

Non solo l'ecosistema è variegato, ma è mobile e distribuito in tutto il mondo. La maggior parte delle organizzazioni attualmente mette in condizione i propri dipendenti di lavorare da remoto. Il numero di persone che lavorano da casa, ma non sono liberi professionisti, è cresciuto del 140% dal 2005, mentre i dipendenti trascorrono il 50 - 60% dell'orario di lavoro lontani dalla scrivania14, una tendenza che continuerà nel tempo, perché si è riscontrato che i knowledge worker sono più produttivi, motivati e fedeli all'azienda se hanno la possibilità di lavorare da remoto.15

Gli ecosistemi diventano sempre più grandi e distribuiti

3

I dipendenti trascorrono il

50-60%Il numero di persone che lavorano

da casa, ma non sono liberi professionisti, è cresciuto del

140%dal 2005

dell'orario di lavoro lontani dalla scrivania

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

75 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1Inoltre, ovviamente, nell'odierno mondo iperconnesso, le aziende dispongono di filiali e uffici satellite, oltre che di singoli lavoratori remoti, sparsi in tutto il mondo. E come se un ecosistema della forza lavoro dinamico e distribuito a livello globale non complicasse sufficientemente gli accessi, queste componenti si connettono con la rete aziendale tramite un numero sempre maggiore di dispositivi: computer desktop, laptop, cellulari, tablet e BYOD (Bring Your Own Device). Queste tendenze richiedono un'infrastruttura più permeabile e accessibile. Le tecnologie di accesso devono essere in grado di fornire un sistema di accesso alle applicazioni calibrato per ogni utente, da ciascun luogo e su qualsiasi dispositivo, senza compromettere la sicurezza. I tradizionali modelli di accesso alle applicazioni non sono a questa altezza. Le soluzioni di accesso obsolete consentono anche un movimento laterale illimitato, vale a dire che, una volta che l'utente malintenzionato è riuscito ad accedere alla rete aziendale, può spostarsi indisturbato e rubare facilmente i materiali desiderati. Inoltre, le tecnologie preesistenti spesso forniscono un accesso di primo livello e globale alla rete, comportando gravi divulgazioni di informazioni e attività indipendentemente dalle esigenze degli utenti, dell'affiliazione, del reparto o della superiorità di grado. Ciò significa che un dirigente e un tecnico HVAC di terze parti possono accedere alle stesse applicazioni e agli stessi dati aziendali.

La configurazione, la distribuzione e la dismissione di un'architettura di accesso antiquata per questa variegata forza lavoro mobile in continua evoluzione richiedono ore di attenzione da parte del reparto IT, che deve fornire VPN o VDI o una serie di altre soluzioni, tra cui hardware e/o software lato client, sistemi di sicurezza, IAM e configurazione correlata alle policy. Come visto in precedenza, il personale IT può anche inviare per e-mail hardware precaricato con i requisiti di accesso ad utenti remoti e di terze parti per un livello di sicurezza aggiuntivo, il che, tuttavia, risulta anche inefficiente e poco pratico. Inoltre, la replica delle reti e degli stack di sicurezza su più ambienti e sedi, al fine di supportare la forza lavoro globale, è complessa e, spesso, incredibilmente costosa. Tra l'altro, le tecnologie di accesso preesistenti non possono integrarsi facilmente con la moltitudine dei tipi di dispositivi utilizzati dall'odierna forza lavoro.

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

85 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1Considerando la varietà di utenti e punti di accesso, la prevalenza di dipendenti di terze parti e il tasso di abbandono, queste operazioni di onboarding e offboarding degli accessi prosciugano le risorse e, alla lunga, sono insostenibili. Con il continuo espandersi e diffondersi dei moderni ecosistemi di dipendenti, è fondamentale adottare un nuovo modello di accesso alle applicazioni in grado di supportare un'infrastruttura aziendale aperta e una maggiore consapevolezza delle identità. La strada per il successo è garantita dall'adozione di un'architettura di sicurezza Zero Trust in grado di fornire la convalida e l'accesso in base ai casi specifici.

Vengono distribuite sempre più applicazioni aziendali, alle quali si accede in sede o nel cloud, per lo svolgimento di operazioni business-critical. Anche se l'infrastruttura in sede continuerà a resistere, è pur vero che nell'ultimo decennio non è stata fondata nessuna azienda di software con una sede fisica.16 Il cloud è una tematica chiave e la popolarità delle applicazioni nel cloud non fa che aumentare. Un'azienda di medie dimensioni utilizza più di 1.427 diversi servizi cloud e, in media, i dipendenti accedono a più di 36 diversi servizi ogni giorno nel proprio lavoro.17 Inoltre, nel mercato del cloud pubblico, i servizi SaaS (Software-as-a-Service) la fanno da padrone.

Il passaggio delle applicazioni aziendali ai sistemi cloud e SaaS continuerà4

Il 59% di tutti i workflow sul cloud sono stati distribuiti come sistemi SaaS entro la fine del 2018.18 Oggi, in media, le aziende usano 16 applicazioni SaaS, ma, entro il 2020, si prevede che il mercato SaaS raggiungerà i 76 miliardi di dollari, con il 73% delle organizzazioni che userà esclusivamente applicazioni SaaS.19 Tutto ciò ha senso se si considera il fatto che, in quanto consumatori, noi viviamo in un mondo SaaS. Ne sono la testimonianza LinkedIn, Facebook, Instagram e Uber, applicazioni accessibili prontamente da qualsiasi luogo e dispositivo con performance elevate. Gli utenti aziendali esigono la stessa experience quando accedono alle applicazioni aziendali: un accesso semplice e unificato da qualsiasi posizione, sul dispositivo di loro scelta, senza necessità di ricorrere a VPN o software client.

il mercato SaaS è destinato a raggiungere

i 76 miliardi di dollari

ENTRO IL 2020

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

95 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1Anche se questa tendenza è ben avviata, capeggiata da Salesforce.com, Microsoft Office 365, Box, Amazon Web Services, Slack, Google G Suite e altri, la delivery di questa experience SaaS in un ambiente aziendale è più facile a dirsi che a farsi. Le tradizionali architetture di rete aziendali e il modello di sicurezza perimetrale che utilizzano non sono adatti per l'odierno mondo basato sulle applicazioni cloud. Per far fronte a questo scenario in continuo mutamento, molte aziende si affidano alle già menzionate appliance hardware e software assemblate per fornire l'accesso alla rete aziendale. Tali appliance trasmettono il traffico cloud tramite la rete WAN attraverso uno stack di sicurezza centralizzato, quindi lo reindirizzano verso l'IaaS (Infrastructure-as-a-Service) e Internet tramite connessioni dirette o VPN. Si tratta di un'operazione complessa e costosa da replicare a livello globale, in diversi ambienti e aree geografiche. Questo modello, inoltre, deteriora le performance delle applicazioni e la user experience, facendo salire i costi fissi e quelli associati. Ma, principalmente, i modelli di accesso tradizionali aumentano la superficie di attacco delle aziende, esponendo utenti, dispositivi e applicazioni ai rischi di sicurezza inerenti alla rete Internet pubblica. In risposta a queste vulnerabilità ed inefficienze, le aziende hanno dovuto dotare le proprie applicazioni di sistemi di protezione dagli attacchi DDoS su scala Internet e aggiungere l'accelerazione per mitigare problemi di latenza e performance, nonché specifiche protezioni dagli attacchi a livello di applicazioni. Questi approcci frammentari e isolati semplicemente non hanno alcun senso dal punto di vista finanziario ed operativo. È necessario un nuovo modello di accesso alle applicazioni: un modello basato sul cloud in grado di fornire agli utenti un'interfaccia semplice e conveniente, rafforzando, nel contempo, anche la sicurezza aziendale tramite un accesso adattativo e basato sulle identità.

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

105 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1

competenze aumenta sempre di più come conseguenza della prevalenza e della sofisticatezza delle minacce informatiche. Molti attribuiscono questo abisso a un ripido declino degli studi nelle discipline STEM (scienza, tecnologia, ingegneria e matematica); nonostante un significativo sforzo compiuto nella promozione dell'istruzione STEM negli anni passati, la popolarità di queste discipline continua a calare.22

Le risorse IT vengono sempre più sfruttate5

Al momento, vi è una carenza globale di 2,9 milioni di professionisti della cybersicurezza.20 Secondo un recente sondaggio, il 70% delle organizzazioni ha segnalato che questa carenza stava influendo negativamente sulle loro attività aziendali.21 Inoltre, mentre diminuisce il numero di professionisti della sicurezza qualificati, la richiesta di queste

il numero di posizioni vacanti nel settore della sicurezza aumenterà fino ad arrivare a

3,5

ENTRO IL 2021

70%

carenza globale di 2,9 milioni di

professionisti della cybersicurezza

delle organizzazioni ha segnalato che questa carenza stava influendo negativamente sulle loro attività aziendali

Si prevede che, entro il 2021, il numero di posizioni vacanti nel settore della sicurezza salirà a 3,5 miliardi.23 Per gestire questa tendenza, i leader aziendali devono sforzarsi di dare maggiore importanza agli addetti del reparto IT e di fornire loro le giuste risorse per massimizzare la loro efficienza. Ma la scarsità di professionisti della sicurezza non è esclusivamente un problema relativo al numero di laureati nelle discipline STEM. La verità è

che entrano in gioco tanti fattori operativi interni impegnativi che i dirigenti aziendali si trovano a dover affrontare: gli esperti IT e di sicurezza sono relegati in secondo piano, distolti dagli imperativi aziendali critici e per il futuro, nonché dalle strategie innovative e dalla formazione, a causa di incidenti di sicurezza precipitati per via di stack tecnologici arretrati e scarsamente integrati, incluse le soluzioni di accesso preesistenti.

milioni

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

115 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1I modelli di accesso alle applicazioni antiquati e la loro complessa tecnologia difficile da gestire richiedono un impegno significativo e costante del reparto IT. Il supporto di questi modelli di accesso problematici monopolizza le risorse IT e, spesso, sono richieste ore, se non giorni, per fornire e/o dismettere un singolo utente o dispositivo, nonché per gestire gli aggiornamenti di sistema e gli interventi di manutenzione di base. Le soluzioni di accesso alle applicazioni preesistenti rendono anche complesse, o quasi impossibili, le verifiche, in quanto spesso non offrono al reparto IT la visibilità o una reportistica aggregata sull'accesso e sull'attività della rete.

Il reparto IT è sempre più bombardato di richieste di assistenza, come risultato di experience di accesso frammentate e di errori nelle operazioni di rifiuto degli accessi, tra cui password dimenticate, dispositivi e applicazioni bloccati e richieste di autorizzazioni da parte di utenti senza un accesso basato su modelli in base al proprio ruolo. La mancanza di un accesso unificato provoca anche una maggiore fatica correlata all'uso delle password e spinge gli utenti ad adottare abitudini pericolose, come riutilizzare le stesse password, usare password non complesse o annotare le proprie credenziali, limitando ulteriormente la capacità del reparto IT di limitare e proteggere l'accesso alla rete. Sfortunatamente, la maggior parte di questi problemi riguarda le risorse IT

senior, considerato il numero e la complessità di sistemi sovrapposti e interdipendenti, il che allontana ulteriormente gli addetti alla sicurezza più competenti dai progetti strategici che potrebbero incidere sui profitti.

Mentre continua ad aumentare il divario tra i professionisti della cybersicurezza disponibili e la domanda degli utenti, è necessario adottare un modello di accesso alle applicazioni aggiornato e basato sul cloud per fornire un accesso immediato, sicuro e semplice tramite un portale unificato e facile da gestire. Una soluzione in grado di consentire un'agevole implementazione di restrizioni remote per un accesso alle applicazioni personalizzato potrà liberare preziose risorse IT con un notevole impatto a livello aziendale.

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

125 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

1Il nuovo modello di accesso alle applicazioni

Ora è chiaro che, per affrontare questi cinque fattori moderni, le aziende hanno bisogno di una nuova architettura tale da fornire l'accesso alle proprie applicazioni. Questo nuovo modello deve soddisfare le sfide odierne:

Eliminando sull'infrastruttura le dipendenze tra utenti e risorse aziendali, ma integrando, al contempo, la protezione del percorso dati, la gestione degli accessi e delle identità (IAM), la sicurezza e l'accelerazione delle applicazioni, il SSO (Single Sign-On) e altre misure di sicurezza avanzate.

Passando a un modello in cui l'accesso sia agile, indipendente da luoghi e dispositivi e transitorio.

Separando e isolando l'accesso alla rete di base e consentendo l'accesso alle sole applicazioni di cui gli utenti hanno bisogno per svolgere la propria attività.

Andando incontro alle aspettative degli utenti di trovare experience semplici e performance elevate e distribuendo le applicazioni aziendali tramite un modello SaaS.

Consentendo al personale IT di fornire facilmente e rapidamente un accesso basato sulle identità per liberare preziose risorse che si occupano della cybersicurezza.

L'accesso deve essere agile, flessibile, scalabile e adattabile, ma, soprattutto, non deve avvenire a scapito della sicurezza. La risposta è una soluzione di accesso basata sul cloud, in grado di aggiungere intelligence ai processi decisionali e di esaminare utenti, dispositivi e posizioni, nonché schemi di accesso, ad ogni richiesta.

Per saperne di più sulla soluzione offerta da Akamai per un accesso semplice, unificato e sicuro alle applicazioni aziendali, visitate il sito akamai.com/it/it/eaa.

1

2

3

4

5

package main; import ( "fmt"; "html";"log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel,statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-controlChannel: workerActive = true; go doStuff(msg,workerCompleteChan); case status := <- worker-CompleteChan: workerActive = status; }}}; func admin(cc chan ControlMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostTokens :=strings.Split(r.Host, ":"); if len(hostTokens) > 0 { host := hostTokens[0]; for i :=0; i < len(host)/2; i++ { if host[i] !=host[len(host)-1-i] { fmt.Fprintf(w, "invalidhostname"); return; }}}; r.ParseForm();count, err := strconv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Error()); return; }; msg := ControlMessage{Target: r.FormValue("target"), Count: count}; cc <- msg; fmt.Fprintf(w, "Control message issued for Target %s, count%d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",func(w http.ResponseWriter, r *http.Request)

135 motivi per i quali le aziende hanno bisogno di un nuovo modello di accesso alle applicazioni

11) Rapporto McAfee 2018: Impatto economico del crimine informatico, https://csis-prod.s3.amazonaws.com/s3fs-

public/publication/economic-impact-cybercrime.pdf?kab1HywrewRzH17N9wuE24soo1IdhuHd&

2) https://www.av-test.org/en/statistics/malware/

3) Rapporto McAfee 2018: Impatto economico del crimine informatico, https://csis-prod.s3.amazonaws.com/s3fs-

public/publication/economic-impact-cybercrime.pdf?kab1HywrewRzH17N9wuE24soo1IdhuHd&

4) https://breachlevelindex.com/

5) Rapporto sulla sicurezza e sull'accesso remoto stilato da IDC, https://www.akamai.com/it/it/multimedia/documents/

report/remote-access-security-challenges-and-opportunities.pdf

6) Studio 2018 sul costo delle violazioni di dati redatto dal Ponemon Institute: Panoramica globale, https://www.ibm.

com/security/data-breach

7) https://dataconomy.com/2018/03/12-scenarios-of-data-breaches/

8) https://www.forbes.com/sites/suntrust/2018/12/06/the-5-biggest-trends-in-mergers--acquisitions-for-

2019/#73056e321ca1

9) Rapporto Deloitte 2019: Tendenze relative a fusioni e acquisizioni, https://www2.deloitte.com/it/it/pages/mergers-

and-acquisitions/articles/ma-trends-report.html

10) Ibid.

11) Rapporto sulla sicurezza e sull'accesso remoto stilato da IDC https://www.akamai.com/it/it/multimedia/documents/

report/remote-access-security-challenges-and-opportunities.pdf

12) https://www2.deloitte.com/insights/us/en/focus/human-capital-trends/2018/contingent-workforce-management.

html

13) https://www.upwork.com/press/2017/10/17/freelancing-in-america-2017

14) http://globalworkplaceanalytics.com/telecommuting-statistics

15) https://www.ciphr.com/advice/10-essential-remote-working-statistics/

16) https://searchcloudcomputing.techtarget.com/feature/SaaS-apps-reshaping-face-of-enterprise-IT

17) https://www.skyhighnetworks.com/cloud-security-blog/12-must-know-statistics-on-cloud-usage-in-the-enterprise/

18) https://www.cisco.com/c/en/us/solutions/service-provider/visual-networking-index-vni/index.html#cloud-forecast

19) https://www.bettercloud.com/monitor/state-of-the-saas-powered-workplace-report/

20) https://www.isc2.org/

21) https://www.esg-global.com/blog/esg-research-suggests-cybersecurity-skills-shortage-is-getting-worse

22) http://www.govtech.com/education/k-12/New-Research-Shows-Declining-Interest-in-STEM.html

23) https://cybersecurityventures.com/cybersecurity-market-report/

Grazie alla propria piattaforma di cloud delivery più estesa e affidabile al mondo, Akamai supporta i clienti nell'offerta

di experience digitali migliori e più sicure da qualsiasi dispositivo, luogo e momento. La piattaforma ampiamente

distribuita di Akamai garantisce protezione dalle minacce informatiche e performance di altissimo livello. Il portfolio

Akamai di soluzioni per le web e mobile performance, la sicurezza sul cloud, l’accesso remoto alle applicazioni aziendali

e la delivery di contenuti video è affiancato da un servizio clienti affidabile e da un monitoraggio 24x7. Per scoprire

perché i principali istituti finanziari, i maggiori operatori e-commerce, provider del settore Media & Entertainment ed

enti governativi si affidano ad Akamai, visitate il sito https://www.akamai.com/it/it/ o https://blogs.akamai.com/it/

e seguite @AkamaiItalia su Twitter. Data di pubblicazione: 02/19.

Fonti