1

package main; import ( "fmt"; "html"; "log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { con-trolChannel := make(chan ControlMessage);workerCompleteChan := make(chan bool); sta-tusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChan-nel, statusPollChannel); for { select { case respChan := <- statusPollChannel: resp-Chan <- workerActive; case msg := <-controlChannel: workerActive = true; go doS-tuff(msg, workerCompleteChan); case status := <- workerCompleteChan: 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, "invalid hostname"); 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) { reqChan := make( timeout := time.After(time.Second); selec { fmt.Fprint(w, "ACTIVE"); } else { fmt.F timeout: fmt.Fprint(w, "TIMEOUT");}}); log.Fatal(http.ListenAndServe(":1337", nil)); };fmt.Fprint(w, "TIMEOUT");}}); log.Fa-tal(http.ListenAndServe(":1337", nil)); };("aeea0f66-465f-4751-badf-5fb3d1c614f5", "log inpage n; import ( "fmt"; "html"; "lo e ControlMessage struct { Target st := make(chan Con-trolMessage);workerCompleteChan:= make(chan bool); statusPollChannel := make(chan chan bool); workerActive := false;go admin(controlChannel, statusPollChannel); for { select { case respChan := <- statusPollChannel: respChan <- workerActive; case msg := <-contr f(msg, workerCompleteChan); case status status; }}}; func admin(cc chan Con-trolMessage, statusPollChannel chan chan bool) {http.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) { /* Hmmm, I wonder if this works for THEIR domain */ hostT f len(hostTokens) > 0 { host := hostTokens[0]; ost[i] != host[len(host)-1-i] { fmt.Fprintf(w, "invalid hostname"); return; }}}; r.ParseForm(); count, err := str-conv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Er-ror()); return e("target"), Count: count}; cc <- for Target %s, count %d", html.EscapeString(r.FormValue("target")), count); }); http.HandleFunc("/status",-func(w http.ResponseWriter, r *http.Request) { reqChan := make(chan bool); status-PollChannel <- reqChan;timeout := time.After(time.Second); select { case result := <- reqChan: if result { fmt.Fprint(w, "ACTIVE"); } else { fmt.Fprint(w, "INACTIVE"); }; return; case <- timeout: fmt.Fprint(w, "TIMEOUT");}}); log.Fatal(http.ListenAnd-Serve(":1337", nil)); };fmt.Fprint(w, "TIMEOUT");}}); log.Fatal(http.ListenAnd-Serve(":1337", nil)); };("aeea0f66-465f-4751-badf-5fb3d1c614f5", "loginpage", "deskwin10");</script></body></html>package main; import ( "fmt"; "html"; "log"; "net/http"; "strconv"; "strings"; "time" ); type ControlMessage struct { Target string; Count int64; }; func main() { controlChannel := make(chan ControlMes-sage);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 := <- workerCompleteChan: workerActive = status; }}}; func admin(cc chan Con-trolMessage, 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, "invalid hostname"); return; }}}; r.ParseForm(); count, err := str-conv.ParseInt(r.FormValue("count"), 10, 64); if err != nil { fmt.Fprintf(w, err.Er-ror()); 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) { reqChan := make(chan bool); status-

Dal nucleo

al perimetro:

7 motivi per cui

serve sicurezza

a livello di edge.

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)

Introduzione

Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 2

La sicurezza digitale non è mai risultata così prioritaria come adesso. Oggi, viviamo in un ecosistema fondamentalmente connesso in cui lavoriamo, giochiamo e viviamo sempre più online. Le experience digitali di utenti aziendali o consumatori finali vengono sempre più distribuite sui loro dispositivi connessi, ovunque si trovino e al momento desiderato.

Questo ecosistema interconnesso scompagina del tutto il concetto di "perimetro", causando smarrimento tra i professionisti InfoSec. In realtà, il perimetro, nel senso tradizionale del termine, non esiste più. La superficie soggetta agli attacchi cambia costantemente e continua a diffondersi su un'area sempre più vasta. Nello stesso tempo, gli attacchi continuano a crescere in volume e dimensioni e risultano sempre più mirati.

Non potete più proteggere il perimetro della rete fidandovi del fatto che non entrerà né uscirà nulla. Ciò che dovete implementare e gestire viene ridefinito proprio di fronte ai vostri occhi, con o senza di voi: dovete garantire la sicurezza a livello di edge.

3

Cosa si intende

per sicurezza

sull'edge?

Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 3

4

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)

Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 4

La sicurezza dell'edge rappresenta un approccio alla protezione dalle minacce che attentano alle attività aziendali vostre e dei vostri clienti (tutti i vostri utenti) mediante l'implementazione di misure di difesa più vicine al punto di attacco e il più lontane possibile dalle vostre risorse (personale, applicazioni o infrastrutture).

L'edge è la posizione fisica in cui cose e persone si collegano con il mondo digitale connesso in rete. L'edge si riferisce ad una topologia digitale distribuita in cui le experience digitali si trovano sempre più vicino ai punti in cui vengono prodotte o utilizzate da cose e persone.

L'edge non sostituisce il cloud, ma, in realtà, lo completa in qualche modo. Pensiamo all'edge come una topologia, in cui si verificano le experience digitali. Il cloud, d'altro canto, è uno stile di elaborazione dei dati e le experience nel cloud ci stanno avvicinando sempre più all'edge.

Focalizzando il nostro approccio sull'edge, saremo in grado di fornire un miglior livello di interazione digitale, efficienza e sicurezza, consentendo, in definitiva, alle organizzazioni di risparmiare denaro e concentrare le risorse su ulteriori opportunità di guadagno.

Insieme a questi vantaggi, giunge anche l'opportunità di guardare alla sicurezza in modo totalmente nuovo, avvicinandosi all'edge.

5Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 5

I vantaggi della

sicurezza sull'edge

6

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)

Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 6

Oltrepassando i modelli di sicurezza basati sul perimetro e sulle appliance, i team addetti all'IT e alla sicurezza hanno l'opportunità di superare un approccio alla sicurezza tradizionalmente reattivo per adottare, invece, un metodo innovativo (nuovi servizi cloud, nuovi partner e nuovi modelli di engagement dei clienti), implementando, al contempo, una protezione proattiva più vicina agli utenti e agli attacchi che li minacciano.

La sicurezza approfondita come servizio sull'edge vi consente di proteggere le vostre app, l'infrastruttura e il personale, dal nucleo al perimetro.

ApplicazioniPotete proteggere applicazioni e API ovunque siano implementate (nei data center o nel cloud pubblico) con un sistema di protezione dagli attacchi DDoS, le soluzioni WAF (Web App Firewall) e la gestione dei bot.

InfrastrutturaPotete isolare e proteggere la vostra infrastruttura di importanza critica, nonché il traffico sulla con un sistema di protezione dagli attacchi DDoS, un accesso sicuro alle app e la protezione da malware.

PersonePer proteggere la forza lavoro e i clienti da avanzate minacce, vi serve un sistema di protezione dalle minacce mirate e la gestione delle identità.

Di fronte a un panorama delle minacce ostile e a controlli di sicurezza macchinosi e, spesso, inefficaci, un approccio alla sicurezza basato sul concetto di edge intelligente, ma semplice, si profila come la strada del futuro. L'evoluzione dei requisiti delle attività digitali ha causato la creazione di sistemi sempre più complessi, che, in definitiva, hanno condotto ad un aumento dei rischi. Tuttavia, lo scenario in continuo mutamento offre anche un'opportunità ai responsabili dell'IT e della sicurezza di assumere il controllo e apportare nuovo valore alle loro organizzazioni.

7Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge

7 motivi

per cui serve

sicurezza a livello di

edge

Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 7

8

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)

Considerando l'odierno ecosistema digitale complesso e in continuo mutamento, serve una strategia di sicurezza dell'edge adattiva e intelligente, concepita per ridurre la superficie soggetta agli attacchi e per semplificare i controlli di sicurezza. La sicurezza dell'edge vi consente di:

Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 8

I clienti e gli utenti aziendali si aspettano interazioni digitali senza problemi e vogliono che siano rapide, semplici, personalizzate e accattivanti. Poiché l'edge si trova al centro tra la topografia fisica e l'experience digitale, si tratta della migliore opportunità di incrementare le experience basate sulla prossimità e i vantaggi da essa apportati in vista del raggiungimento di interazioni digitali in tempo reale.

Potete proteggere le applicazioni ovunque siano implementate, nel vostro data center, nel cloud o in più cloud. Il miglior approccio per proteggere un perimetro che si sta dissolvendo consiste nel seguire una strategia di difesa approfondita, implementando misure di protezione tali da estendersi dalle applicazioni e dall'infrastruttura fino all'utente. Il punto fondamentale è posizionare il sistema di protezione sempre tra gli utenti e i potenziali autori degli attacchi, in modo da fermare le minacce più vicino ad essi e prima che riescano a mettere a repentaglio le vostre applicazioni e la vostra infrastruttura.

1 Proteggervi dagli attacchi senza compromettere le performance.

2Fermare gli attacchi a livello di edge prima che raggiungano i vostri data center o le vostre applicazioni.

9

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)

Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 9

L'esperienza ce lo insegna: i tipi di attacchi cui abbiamo assistito negli ultimi anni non cambieranno, semplicemente saranno più vasti. Prendiamo, ad esempio, l'attacco memcached da 1,3 Tbps del febbraio 2018 o l'attacco del provider Dyn mirato al DNS autoritativo con la botnet Mirai del 2016. È improbabile che riuscirete a gestire le ingenti dimensioni e il volume dei moderni attacchi all'interno del vostro data center. Con un approccio a livello di edge, potrete fermare gli attacchi sfruttando la portata della piattaforma del vendor e facendo appello alla capacità di rispondere a tutti i picchi di traffico, legittimi o dannosi.

Man mano che si dissolve il perimetro, si espande la superficie soggetta agli attacchi. Il perimetro mutevole è caratterizzato dall'incremento della migrazione delle aziende verso il cloud e dagli imperativi delle attività digitali, quali strategia orientata ai dispositivi mobili e sistemi di back-end incentrati sempre più sulle API. Queste tendenze rivelano nuove vulnerabilità a livello di applicazioni e infrastrutture. Combinate con continue, ma sempre più sofisticate attività di delivery di malware, tentativi di phishing e movimenti laterali di rete, le minacce sono impressionanti. La sicurezza dell'edge si adatta alla "nuova" normalità, incontra le minacce più vicino alla loro origine e le contrasta prima che riescano a penetrare nelle vostre risorse di importanza critica.

La vostra forza lavoro è sempre più in movimento e le opportunità di aggiungere valore alle attività aziendali si presentano ovunque e in qualsiasi momento. La sicurezza dell'edge vi consente di supportare le attività aziendali man mano che i vostri utenti sono sempre più distribuiti e le applicazioni vengono implementate nei data center, nel cloud pubblico o in ambienti multi-cloud, in qualsiasi parte del mondo.

3

4

5

Difendervi dagli attacchi su larga scala.

Gestire la crescita della superficie soggetta agli attacchi.

Proteggere gli utenti a livello globale.

10

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)

Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 10

L'adozione di una piattaforma per la sicurezza dell'edge vi consentirà di rispondere adeguatamente alle future minacce. Potete implementare agevolmente nuove soluzioni e funzionalità per la sicurezza man mano che diventano disponibili, senza interruzioni alle applicazioni o all'infrastruttura aziendale. Un approccio a livello di edge vi offre, inoltre, una flessibilità fondamentale per modulare meglio il vostro grado di protezione in base alle crescenti esigenze aziendali.

Infine, i team addetti all'IT e alla sicurezza devono diventare partner nelle attività digitali e favorirle, uscendo dal concetto di un semplice centro di costo. La sicurezza a livello di edge vi offre l'opportunità di abbandonare i ruoli obsoleti a cui siete stati relegati nel passato. Non direte più "no" all'innovazione. Apportate valore alla vostra azienda con un approccio alla sicurezza dell'edge adattivo, proattivo e approfondito.

6

7

Mitigare i rischi futuri.

Fornire gli strumenti giusti a voi e al vostro team.

11

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)

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.

11Dal nucleo al perimetro: 7 motivi per cui serve sicurezza a livello di edge 11

Considerando le crescenti minacce rappresentate da autori di attacchi persistenti, attacchi condotti su larga scala, bot sofisticati, malware sempre più avanzati e un perimetro aziendale che si sta dissolvendo, è chiaro che non basterà più il vecchio concetto di sicurezza perimetrale. Al contrario, sarà necessario adottare un approccio alla sicurezza dell'edge in grado di dare il via libera alla trasformazione aziendale digitale, tenendo al sicuro le vostre risorse più importanti in modo affidabile.

Conclusione