Questo articolo esamina a fondo le funzioni più tecniche di sicurezza nel codice usato per effettuare un'applicazione e fornisce la guida di riferimento per sviluppare un procedimento di applicazione per l'esecuzione sicura. Il potenziale per le vulnerabilità in un'applicazione è ridotto tramite una progettazione forte, ma l'esecuzione delle guarnizioni di applicazione il relativo destino. Il lavoro duro versato in un disegno sicuro diventa illogico se l'esecuzione è fatta male. È inoltre importante capire che l'inclusione delle tecnologie o dei metodi di progettazione sicurezza-relativi necessariamente non implica o non garantisce alcun livello di sicurezza all'interno di un'applicazione. L'esecuzione di un'applicazione e di tutta la tecnologia di sicurezza usate è uno dei componenti finali che porta un livello elevato di affidabilità.
L'analisi nella fase di esecuzione è la responsabilità sia degli sviluppatori che dei responsabili di sviluppo. Gli sviluppatori sono responsabili dell'effettuare il disegno bene, mentre i responsabili sono responsabili del disporre il processo che accerta una buona esecuzione. Ciò può essere fatta via le procedure standardizzate che includono le revisioni documentate di sviluppo e di campioni, di disegno e di codice di codificazione e l'addestramento dello sviluppatore riguardo a sicurezza nello sviluppo di applicazione. Queste procedure avvantaggiano gli sviluppatori e le applicazioni senza riguardo a cui le lingue sono usate o il tipo di applicazione è sviluppato.
Le lingue il più comunemente usate oggi sono il linguaggio di programmazione di C, il Java e le lingue scripting quali il Perl e le coperture di UNIX. Ciascuno di questi lingue ed ambienti può essere usato impropriamente per compromettere la sicurezza di un'applicazione e del sistema su cui funziona. Tuttavia, questo articolo non è una lista di controllo affinchè gli sviluppatori segua. Invece, lo sviluppo di un processo sicurezza-messo a fuoco di pensiero tiene conto una pratica discutibilmente più forte di codificazione.
I linguaggi di programmazione di C, che includono la C, C++ e l'oggetto-C, sono le lingue il più comunemente usate e possono essere pericolosi in mani incerte. Forniscono allo sviluppatore la capacità di maneggiare ed accedere a molte parti del sistema, quale la memoria, delle lime e dei dispositivi. Ciò è una resistenza grande delle lingue di C, ma il pericolo presenta quando lo sviluppatore fa gli errori. La C fornisce un livello elevato di accesso al sistema operativo di fondo e ci sono pochi controlli ed equilibrii per proteggere lo sviluppatore. Se lo sviluppatore redige erroneamente i dati alla posizione errata di memoria o del dispositivo, il programma in C Farà qualunque lo sviluppatore scrive, senza riguardo ai dati o alla destinazione.
|
|
La prima zona vulnerabile connessa spesso con la C è il trabocco dell'amplificatore. Il seguente codice del campione dimostra un trabocco molto di base:
carbone string[10 ];strcpy(string, "AAAAAAAAAAAAAAA"); / * 15 "caratteri di A"
Qui, 15 "caratteri di A" sono copiati nella zona di memoria per una stringa variabile, che è dichiarata per essere un allineamento 10-character statico. La funzione dello strcpy() fa esattamente come diretto senza riguardo per il formato dei dati che sono copiati o della posizione a cui va. Un trabocco dell'amplificatore si presenta quando l'undicesimo elemento è copiato nella posizione di memoria, subito dopo della posizione del decimo elemento della stringa variabile. Ora applichi questo principio a tutti i dati di input che vengono da una fonte esterna, sostituenti la serie di caratteri "di A". Ciò permette che i attackers controllino gli effetti del trabocco.
La funzione dello strcpy() è una di parecchie funzioni in C che non effettuano alcuni limiti che controllano e che non permettono che gli amplificatori arbitrariamente graduati siano copiati. Altre funzioni da evitare sono gets(), strcat(), sprintf() e la famiglia dello scanf() delle funzioni. Ci sono versioni aggiornate di alcune di queste funzioni che concedono le lunghezze copiate per essere specificato. Questi sono strncpy(), strncat(), snprintf() e fgets(). Questi hanno modificato le funzioni copiano soltanto fino al numero di caratteri specificati dal parametro di lunghezza. Tutt'al più, i caratteri di lunghezza sono copiati dalla fonte nella destinazione:
strncpy(destination, fonte, lunghezza);
Punta
Nel usando le versioni "di n" dello strncpy() di funzioni di manipolazione—di stringa, lo strncat(), lo snprintf() ed il fgets()—sono sicuri che la lunghezza non è più grande della stringa della destinazione, piuttosto che la stringa di fonte. L'amplificatore può essere sorpassato se il valore di lunghezza è più grande del formato dell'amplificatore della destinazione.
Nel usando gli indicatori agli amplificatori, anziché gli amplificatori staticamente dichiarati, dovete assegnare abbastanza memoria per memorizzare i valori che sono copiati. Usi le funzioni di manipolazione di memoria, che permettono che specifichiate la lunghezza.
Punta
Nell'assegnare la memoria per i dati della stringa, non si dimentichi di aggiungere 1 alla lunghezza totale, per accomodare per il carattere terminante NULLO. Senza un terminale NULLO, i dati nella memoria direttamente dopo che l'ultimo carattere della stringa potrebbe essere considerato parte della stringa.
Queste funzioni non sono gli unici posti in cui i trabocchi dell'amplificatore accadano. Sia sicuro controllare che le informazioni abbiano letto, copiato, o scritto a tutta la posizione di memoria o assegnato ad una variabile si adattare, o che la destinazione assegnata ha abbastanza spazio di immagazzinaggio.
Punta
Per evitare i trabocchi dell'amplificatore nel vostro codice, sia sicuro convalidare l'input. Controlli il formato dei dati e della posizione di immagazzinaggio ed usi le funzioni di manipolazione che generano arbitrariamente lungamente le quantità di informazioni sviluppatore-specificate anziché i pezzi dei dati.
Gli stati della corsa aggiungono un livello di complessità a usando il codice di C. Gli stati della corsa possono essere sfruttati in due funzioni ordinare e di protezione—della creazione di codice di C.
Ordinare si riferisce all'ordine in cui gli eventi si presentano in un'applicazione. Gli stati della corsa possono derivare dall'ordinare le variazioni in serie fra gli eventi dipendenti, quando nessun controllo è fatto fra gli eventi. Ciò indica spesso un'imperfezione in tutte le procedure di convalida ed error-checking usate. Se due funzioni funzionano normalmente in sequenza e la seconda funzione suppone che i risultati del primi sono validi, allora la possibilità per uno stato della corsa esiste. I privilegi elevati sono spesso obiettivi dell'attacco. L'organizzazione, unita con la verifica degli errori ed ordinare, minimizza la possibilità per gli stati della corsa.
Ciò è un'esecuzione difettosa che genera uno stato della corsa:
increase_privs();...valore = special_app_function(); / * richiede */ di privilegiother_unreleted_function(); / * non richiede */ di privilegiother_unreleated_function2(); / * idem */special_dependent_function(value); / * richiede */ di privilegi...exit();
Qui, una coppia delle pratiche pericolose accade. I privilegi dell'applicazione sono elevati presto nell'applicazione, ma non sono usati fino a più successivamente. Inoltre non sono ceduti mai, così la maggior parte della funzionalità eseguono con i livelli alto-che-necessari di privilegio. Per concludere, lo stato della corsa è generato con la povera organizzazione che—le funzioni dipendenti non si presentano vicino a vicenda. Un esempio che risolve questi problemi è
increase_privs();valore = special_app_function; / * richiede */ di privilegise (!validate_function(value)/* assicuri la sicurezza del */ di valore{do_error_processing(value); / * faccia qualche cosa di intelligente con */ di errore}special_dependent_function(value); / * richiede */ di privilegidecrease_privs(); / * più non abbia bisogno del */ di privilegiother_unreleted_function(); / * non richiede */ di privilegiother_unreleated_function2(); / * idem */
Noti le procedure speciali di elaborazione di errori e di convalida che sono usate prima di passare il valore ad un'altra funzione.
Punta
Organizzi la funzionalità ed uniscala con la convalida per accertarsi che le informazioni previste non si compromettano fra gli eventi dipendenti.
Molti stati della corsa esistono come il risultato di povero uso della lima provvisoria. Quando queste lime sono generate, dovrebbero essere protette dall'attacco esterno durante il funzionamento. UNIX e Windows permettono che lo sviluppatore regoli le punte di permesso e le bandierine operative quando genera una lima. Permessi se respinga l'accesso a chiunque ma il proprietario del processo. Nel generare la lima usando la chiamata del open(), regoli le bandierine di O_CREAT e di O_EXCL, che inducono la funzione a restituire un errore se la lima che state tentando di generare già esiste. Poiché è una lima provvisoria, non dovrebbe esistere prima dell'esigenza di esso. Se la lima esiste, questo è un segno possibile dell'attacco. Nel usando questi metodi, è inoltre importante da controllare i valori di ritorno delle funzioni e da pulire tutte le lime in caso di le condizioni di errore. Il seguente esempio mostra la sintassi per aprire una lima—o generare uno, se già non esiste—con i permessi che permettono che soltanto il creatore legga, scrivalo ed esegua che usando la macro di modo di S_IRWXU.
open("filename", O_CREAT | O_EXCL | O_WRONLY, S_IRWXU);
La chiamata verrà a mancare nel caso in cui la lima esista già a causa della bandierina di O_EXCL. Inoltre, noti il nome di schedario di unsecure. La convenzione chiamante statica usata aumenta drammaticamente il rischio di attacco perché un componente dell'attacco già è fornito.
dovuto la presenza aumentata degli stati della corsa della lima provvisoria e delle insicurezze collegate, parecchi sistemi operativi hanno funzioni specifiche per generare le lime provvisorie in un modo sicuro.
Gli sviluppatori possono anche usare le possibilità dibloccaggio incorporate del sistema operativo per controllare l'accesso alle lime. Questi metodi controllano l'accesso nei componenti fondamentali del nocciolo.
Punta
Nel usando le lime provvisorie, ripartisca le probabilità sui nomi di schedario, regoli i permessi forti ed organizzi la creazione, l'uso e la rimozione delle lime minimizzare la possibilità di attacco.
Un altro componente che aumenta l'affidabilità e può influenzare la sicurezza di un'applicazione è il valore di ritorno. Mentre potrebbe sembrare evidente, è importante sollecitare la necessità di convalidazione dei valori di ritorno delle funzioni. Le funzioni eseguono spesso in serie e contano sui risultati o sui dati da una funzione precedente. Controllando il valore di ritorno delle funzioni precedenti, la funzione dipendente è protetta dall'esecuzione con i dati non validi. Anche quando gli eventi non sono attacchi, recuperare dalle circostanze anomale aumenta la robustezza dell'applicazione.
Questo esempio dimostra una povera esecuzione che non riesce a controllare i valori di ritorno:
n = do_string_check (stringa, valid_characters); / * la funzione restituisce * interno/se (== GOOD_RETURN di n){process_string(string);}
Qui, l'esecuzione è debole perché il caso negativo, un ritorno difettoso, non è maneggiato mai. Un'esecuzione migliore è
n = do_string_check(string, valid_characters); / * la funzione restituisce * interno/se (n! = GOOD_RETURN){special_error_processing_routine(n); / * il valore difettoso, fa qualcosa */}process_string(string);
Il ritorno negativo è maneggiato dalla procedura d'elaborazione di-ERRORE, che può rimuovere il programma, chiedere una nuova stringa, o convertire il valore di ritorno in parametro valido. Se il valore di ritorno è buono, va alla procedura trattata.
Punta
La creazione delle procedure riutilizzabili di errore e di evento fornisce un meccanismo standard da cui tutte le applicazioni reagiscono ai vari attacchi ed edizioni. Le idee per queste procedure includono i metodi comuni di convalida per stringa e valori, funzioni dell'involucro per effettuare i controlli di integrità e meccanismi numerici di protezione che convalidano le variabili e le posizioni di memoria. Sempre controlli e procedi il valore di ritorno di una funzione.
La punta seguente del particolare coinvolge l'uso delle informazioni sensibili all'interno dell'applicazione, compreso le parole d'accesso, la crittografia, o qualunque altre informazioni riservate. Come accennato precedentemente, tutte le informazioni di programma esistono nelle zone dello stagno comune della memoria che può essere conforme a lettura ed a modifica dalle procedure esterne. È favorevole eliminare la memoria quando le informazioni non sono più in uso, per evitare di rivelare le informazioni durante l'attacco. Il metodo più comune e più sufficiente ai dati liberi, questo si riferisce a tipicamente come azzerando verso l'esterno la memoria. Quando le informazioni memorizzate più non sono necessarie, le posizioni di immagazzinaggio dovrebbero essere scritte sopra con gli zeri o i dati casuali per impedire un attacker recuperare le informazioni via i depositi di nucleo o di memoria. Questa procedura diventa particolarmente importante quando la crittografia è in uso. Le chiavi hanno usato cifrare ed i messaggi di decrypt sono le parti più importanti di un sistema crittografico e di tutto possibile proteggerli necessità di essere fatto.
Questa guida di riferimento esemplifica alcune delle edizioni comuni che presentano nelle applicazioni C-basate. La C è molto un popolare e la lingua potente che permette fornisce la flessibilità grande allo sviluppatore e la cura dovrebbe essere presa con il relativo uso.
Il Perl è una bestia interessante che unisce molti dei benefici di un linguaggio di programmazione strutturato, come la C, con la flessibilità e l'integrazione delle coperture di UNIX. Il Perl permette che lo sviluppatore generi le procedure o i sottoprogrammi, definisca le variabili ed utilizzi le applicazioni e gli ordini disponibili con il sistema operativo. Queste possibilità e la relativa resistenza con le espressioni ed analizzare normali, Perl di give una presenza forte nelle applicazioni di fotoricettore, gestione del sistema ed automazione.
I programmi del Perl non sono generalmente suscettibili dei trabocchi dell'amplificatore a causa della natura debolmente scritta delle relative variabili e dichiarazioni. Diverso della C, in cui le variabili e la memoria devono essere definite come codice categoria particolare di immagazzinaggio e la memoria deve essere assegnata per loro, il Perl fa automaticamente tutto e tratta tutto come dati della stringa. Faccia il seguente esempio:
#!/path/to/perl$one = 1;$one_s = "1"; # nessun differente che $one$two = $one + #; # il risultato è 2, o "2", che sono equivalenti
In C, il $one variabile probabilmente sarebbe dichiarato un numero intero e #, una stringa. L'aggiunta dei due elementi inoltre provocherebbe un valore errato. Il Perl non differenzia fra i tipi differenti, in modo da $two è assegnato 2, o "2"—sono equivalenti in Perl. La lingua inoltre non cade preda ai requisiti di ripartizione di memoria che altre lingue esibiscono. Il seguente esempio è completamente accettabile in Perl:
#!/path/to/perl$var1 = "AAAAA";$var2 = "BBBB";$var2 = #; # $var2 si transforma in "in AAAAA";
$var2 intraprende il nuovo valore di cinque "caratteri di A". Tutte le variabili sono assegnate dinamicamente; non ci è concetto dello spazio di immagazzinaggio prestabilito che non potrebbe essere traboccato.
Il Perl è suscettibile, tuttavia, degli stati della corsa e delle vulnerabilità connesse con l'esecuzione dei programmi esterni. La cura dovrebbe essere data ad ordinare delle funzioni. La convalida dell'input è ugualmente importante in Perl, per impedire lo sfruttamento delle applicazioni esterne.
Il Perl sostiene la possibilità per aprire le lime, similmente alla C e ad altre lingue, quindi l'uso delle lime provvisorie dovrebbe incorporare i permessi adatti e le bandierine della creazione.
L'uso del Perl nei programmi Fotoricettore-basati del cgi è inoltre estremamente popolare. I rischi più grandi si sono associati con il relativo uso in questo ambiente si presentano durante la convalida dell'input e l'esecuzione dei programmi di sistema esterni da dentro. Per proteggere l'applicazione, parecchie precauzioni possono essere prese. Usando segno-controlla i meccanismi del Perl, qualunque insieme variabile fuori del programma non sarà passato a tutto il programma funzionato dall'applicazione. Tutte le variabili si sono regolate dalla variabile alterata sono alterate. Segno-controlli il modo è particolarmente utile per evitare le vulnerabilità, in cui le variabili incontrollate dell'utente sono passate surreptitiously ai programmi denominati dall'applicazione del Perl. Per inizializzare la versione 5 del Perl in segno-controlli il modo, usano la seguente intestazione dello scritto:
#!/path/to/perl –T # funzionano in segno-controllano il modo
La precauzione seguente deve analizzare i valori dell'input per rimuovere i meta-characters ed i valori indesiderabili. Ciò contribuisce a proteggere dagli attacchi che sfruttano parametro-passare alle coperture e ad altre applicazioni. Il seguente esempio mostra una procedura semplice che esplora una stringa dell'input per tutti i meta-characters che potrebbero essere interpretati da un programma:
$unclean_input = &get_HTML_forms_response();if($unclean_input = ~ TR /;|`!$&*()[]{} :'"//){# stampa verso l'esterno un certo HTML qui che indica guasto&do_some_error_reporting();}
In questo caso, la procedura segnala un errore se un meta-character è trovato. I metodi alternativi sostituiscono i meta-characters, o soltanto continuano se nessun meta-character è trovato.
Una precauzione finale è l'uso delle coperture fare funzionare altre applicazioni. Come con la chiamata dello system() di UNIX e la chiamata del exec() di Windows, la chiamata dello system() in Perl permette che lo sviluppatore faccia funzionare un'altra applicazione. La chiamata del exec() in Perl funziona come quella chiamata in UNIX che—il processo corrente è sostituito dal programma ha indicato. Queste funzioni possono essere particolarmente pericolose una volta usate in ambienti che permettono che l'utente immetta, quali il cgi si programma o i programmi di utilità di sistema. Se la convalida dell'input non accade, l'applicazione può essere sfruttata per eseguire i programmi arbitrari che possono interessare il sistema. Il seguente esempio dimostra le insicurezze di usando lo system() con nonvalidated l'input. Presupponga che l'utente ha fornito il username;/bin/rm rf –della stringa/che è stato assegnato al variabile #:
system("ecommerce_app # ");
Ciò traduce efficacemente al username del ecommerce_app di /bin/sh; /bin/rm –rf/. supponendo che il programma sta funzionando con i privilegi, il programma eseguirà lle coperture per fare funzionare l'applicazione di e-commercio; colpisca il punto e virgola delle coperture, che è il segno di separazione dei comandi nelle coperture; e rm allora funzionato –rf, che cancella l'intero sistema di lima.
Java è un'invenzione relativamente recente nel mondo di computazione distribuita del Internet. Porta a compimento il concetto del codice piattaforma-indipendente. Java funziona scrivendo il codice e compilandolo in una disposizione speciale che allora è fatta funzionare sulle macchine virtuali del Java. La macchina virtuale (VM) è piattaforma specifica, ma il codice che i funzionamenti su esso non è. Java permette che i browsers di fotoricettore ed i sistemi a distanza facciano funzionare le applicazioni più complesse e più interattive. Il web browser accede ad un Web site e riceve un Java applet Dall'assistente. Questo applet allora funziona nel web browser e può comunicare con il web server iniziante. Una volta introdotto, Java ha trasformato i Web pagi statici nelle applicazioni dinamiche e fluenti. Dai giorni in anticipo, l'uso di Java si è espanso in molti campi di applicazione distribuiti differenti quali l'amministrazione di rete, gli apparecchi incastonati del Internet ed altre funzioni pratiche.
Java è un esempio fine di una lingua di cui gli sviluppatori hanno considerato la sicurezza nelle fasi di progetto iniziali. Le versioni iniziali di Java hanno avute un'architettura ben documentata di sicurezza, denominata il sandbox, che ha impedito il Java applet o l'applicazione Le risorse di sistema d'accesso. Mentre l'uso di Java ha cominciato a espandersi, il bisogno ha presentato per accesso alle risorse di sistema fuori del sandbox. La prima versione del corredo di sviluppo del Java ha fornito l'uso dei applet firmati. Il modello descrive un applet che digitalmente è firmato per verificare il relativo creatore. Quando la firma digitale è verificata, il applet allora si fida di dal sistema locale, che permette l'accesso del applet ad altre risorse di sistema. Questo metodo digitale della firma coinvolge una quantità ingente di complesso che si programma per funzionare correttamente. È inoltre importante notare che questo modello di sicurezza di un Java applet Digitalmente firmato è difettoso. Chiunque può firmare un applet. Un applet cattivo può essere firmato dal attacker ed essere trasferito dal web browser. Il web browser verifica efficacemente che il applet cattivo effettivamente è scritto dal attacker ed allora felicemente lo esegue, a che cosa risultato è programmato in esso.
La ripetizione corrente e seconda dell'architettura di sicurezza del Java è più presto molto più potente e flessibile che le versioni. Ciò permette che Java fornisca precedentemente molte zone di sviluppo di applicazione oltre le relative possibilità. La nuova architettura di sicurezza del Java usa facilmente le politiche di sicurezza ed i metodi di controllo definibili di accesso che permettono che un applet o un'applicazione accedi alle risorse specifiche ai gradi di variazione. Rispetto alla guida di riferimento si è presentato qui, i progettisti del Java hanno analizzato le varie interazioni e vulnerabilità presenti con le applicazioni distribuite del Internet e sono arrivato ad un modello che fornisce l'alta sicurezza flessibilità estrema. Per documentazione completa su Java e sul relativo APIs, veda http://java.sun.com.
UNIX sgrana la forma la base di interazione dell'utente con un sistema di UNIX. Le coperture sono ordine-linea interpretatori che sostengono un certo livello di automazione e di programmazione sotto forma di gli scritti di coperture. Questi scritti sono usati spesso per automatizzare le mansioni del sistema, effettuare i funzionamenti ripetuti e le applicazioni funzionate di fotoricettore del cgi. Come con il Perl, le zone del rischio potenziale sono convalida immessa, termini della corsa, interazione con le lime esterne ed i programmi e l'organizzazione di funzionalità.
In UNIX, i funzionamenti privilegiati possono essere fatti funzionare da un utente privilegiato, o possono essere regolati al funzionamento come utente privilegiato. Ci sono differenze sottili fra i due metodi. Tutte le lime in un sistema di UNIX, compreso le applicazioni, hanno un insieme degli attributi che includono l'utente e raggruppano la proprietà e un insieme delle bandierine di permessi. Unite, permettono che l'accesso della lima sia controllato rigorosamente. Le applicazioni normali sono possedute da un utente e, secondo i permessi di accesso, potrebbero essere fatte funzionare soltanto dal proprietario, da un gruppo, o da chiunque sul sistema. Le applicazioni ereditano i privilegi dell'utente che li fa funzionare. Un'applicazione che richiede i privilegi della radice può essere fatta funzionare da un utente della non-radice, ma, a quei punti in cui gli più alti privilegi sono richiesti, da esso verrà a mancare. Per sormontare questo e permettere che gli utenti normali accedano a determinate funzioni privilegiate, UNIX fornisce le bandierine di SetGID e di SetUID. Una volta permesse, inducono l'applicazione a funzionare come il proprietario o il gruppo per quell'applicazione che—hanno regolato l'identificazione usuario (UID) dell'applicazione a whomever la possiede.
Molto i programmi di sistema e del cgi richiedono l'accesso alle risorse di sistema e sono radice di SetUID. Ciò si applica ai programmi compilati, quali i programmi in C Ed agli scritti, compreso il Perl e le coperture di UNIX. Gli utenti e gli sviluppatori con esperienza di UNIX avvertono spesso circa i pericoli degli scritti di coperture di SetUID che forniscono i privilegi della radice. Come discusso più presto, la convalida e gli stati immessi della corsa sono sfruttati facilmente quando lo scritto non è protetto correttamente. Nel fare funzionare uno scritto come utente privilegiato, non ci è senso più facile cosegnare le chiavi al castello che uno scritto di coperture debole. Tali scritti sono particolarmente pericolosi una volta programmati senza misure di sicurezza perché lle coperture sono interattive dalla natura. L'input del rifornimento degli utenti e le coperture effettua una funzione. Il Perl ha molti controlli incorporati ed equilibrii che permettono l'uso più sicuro di SetUID.
Gli apparecchi del Internet sono quei sistemi e dispositivi di cui l'intero scopo è computazione del Internet. Tutti i guida di riferimento di disegno, considerazioni di linguaggio di programmazione, vulnerabilità e paradigmi di funzionamento sono direttamente relativi agli apparecchi del Internet. Gli apparecchi del Internet usano spesso i sistemi operativi, le applicazioni ed i metodi comuni per compire i loro obiettivi. Se l'applicazione in via di sviluppo segue questo percorso, attenzione speciale di paga a tutte le informazioni presentate qui. Alcuni apparecchi del Internet sono sviluppati da zero, comprendendo soltanto i disegni e le tecnologie recentemente elaborati. Valutare il rischio di sicurezza per questi sistemi richiede il diligence supplementare. È particolarmente importante integrare la sicurezza in un processo di disegno quando a partire dalla graffiatura.
Online: 665 users browsing the articles directory
|
|