Perché la sicurezza del software è un'abilità che tutti i programmatori dovrebbero avere

Come programmatore o sviluppatore, l'importanza di creare applicazioni sicure non può essere sopravvalutata.

La sicurezza del software si occupa della gestione degli attacchi dannosi identificando potenziali vulnerabilità nel software e adottando le precauzioni necessarie per proteggerle.

Il software non può mai essere sicuro al 100% perché uno sviluppatore può trascurare un bug, creare nuovi bug nel tentativo di risolvere casi esistenti o creare nuove vulnerabilità tramite aggiornamenti.

Tuttavia, ci sono due pratiche chiave che tutti gli sviluppatori di software possono impiegare per assicurarsi di creare in primo luogo codice protetto per la scrittura di software e testare in modo efficiente il codice.

Come scrivere un codice protetto

La scrittura di codice sicuro si riduce a una cosa: gestione degli errori. Se puoi anticipare ogni valore potenziale che un utente potrebbe fornire alla tua applicazione e creare una risposta nel tuo programma per quel valore, allora stai scrivendo un codice sicuro.

Questo è molto più semplice di quanto potresti pensare perché tutti i bravi sviluppatori sanno quasi tutto delle applicazioni che sviluppano. Pertanto, è necessario conoscere ogni valore richiesto dalla propria applicazione per eseguire un'attività (i valori approvati) e comprendere che ogni altro valore possibile esistente è un valore non approvato.

Scrittura di codice protetto

Supponiamo che tu voglia creare un programma che accetti solo due valori interi da un utente ed esegua un'operazione di addizione su di essi. Con quella singola frase, come un buon sviluppatore, ora sai tutto sulla tua applicazione. Conosci tutti i valori che questo programma accetterà (valori interi) e conosci l'attività che questo programma completerà (un'operazione di addizione).

Esempio di creazione del programma in Java

importare java.util. Scanner;
public class Main {
// La funzione principale che esegue il programma e raccoglie i due valori
public static void main (String [] args) {
System.out.println ("Inserisci i tuoi due valori interi:");
int value1;
int value2;
Input scanner = nuovo scanner (System.in);
valore1 = input.nextInt ();
valore2 = input.nextInt ();
addizione (valore1, valore2);
input.close ();
}
// la funzione che raccoglie i due valori e ne visualizza la somma
private static void addition (int value1, int value2) {
int sum;
somma = valore1 + valore2;
System.out.println ("La somma dei due valori interi immessi:" + sum);
}
}

Il codice precedente produce un'applicazione che corrisponde esattamente ai requisiti. All'esecuzione, produrrà la seguente riga nella console:

Inserisci i tuoi due valori interi:

L'applicazione rimarrà quindi in pausa fino a quando l'utente non immette due valori interi nella console (ciò significa digitare il primo valore, premere il tasto Invio e ripetere).

Se l'utente inserisce i valori 5 e 4 nella console, il programma produrrà il seguente output:

La somma dei due valori interi immessi: 9

Questo è fantastico; il programma fa esattamente quello che dovrebbe fare. Tuttavia, se un utente malvagio si presenta e inserisce un valore non intero, come "g", nella tua applicazione si verificheranno problemi. Questo perché nessun codice nell'applicazione protegge da valori non approvati.

A questo punto la tua applicazione andrà in crash, creando un potenziale gateway nella tua applicazione per l'hacker che sa esattamente cosa fare dopo.

Esempio di protezione del programma

importare java.util. InputMismatchException;
importare java.util. Scanner;
public class Main {
// La funzione principale che esegue il programma e raccoglie i due valori
public static void main (String [] args) {
provare {
System.out.println ("Inserisci i tuoi due valori interi:");
int value1;
int value2;
// utilizzando la classe scanner per leggere ogni input dell'utente,
// e assegnarlo alla rispettiva variabile (genera un'eccezione se i valori non sono numeri interi)
Input scanner = nuovo scanner (System.in);
valore1 = input.nextInt ();
valore2 = input.nextInt ();
// chiama la funzione di addizione e le passa i due valori
addizione (valore1, valore2);
// chiude il flusso di input al termine del suo utilizzo
input.close ();
// gestisce tutti gli errori generati nel blocco try
} catch (InputMismatchException e) {
System.out.println ("Immettere un valore intero valido.");
} catch (eccezione e) {
System.out.println (e.getMessage ());
}
}
// la funzione che raccoglie i due valori e ne visualizza la somma
private static void addition (int value1, int value2) {
int sum;
somma = valore1 + valore2;
System.out.println ("La somma dei due valori interi immessi:" + sum);
}
}

Il codice precedente è sicuro perché esegue la gestione delle eccezioni. Pertanto, se si immette un valore non intero, il programma terminerà correttamente producendo la seguente riga di codice:

Inserisci un valore intero valido.

Che cos'è la gestione delle eccezioni?

In sostanza, la gestione delle eccezioni è la versione moderna della gestione degli errori, in cui si separa il codice di gestione degli errori dal normale codice di elaborazione. Nell'esempio sopra, tutto il normale codice di elaborazione (o codice che può potenzialmente generare un'eccezione) si trova all'interno di un file provare block e tutto il codice di gestione degli errori si trova all'interno di catturare blocchi.

Se dai un'occhiata più da vicino all'esempio sopra, scoprirai che ci sono due blocchi di cattura. Il primo prende un file InputMismatchException discussione; questo è il nome dell'eccezione generata se viene immesso un valore non intero. Il secondo prende un file Eccezione argomento, e questo è importante perché il suo scopo è catturare qualsiasi eccezione all'interno del codice che lo sviluppatore non ha trovato durante il test.

Relazionato: Eccezioni Java: le stai gestendo bene?

Testare il codice

Non dovresti mai sottovalutare il potere di testare e ripetere il test del tuo codice prima del packaging. Molti sviluppatori (e utenti delle loro applicazioni) trovano nuovi bug dopo che il software è stato reso disponibile al pubblico.

Il test approfondito del codice ti garantirà di sapere cosa farà la tua applicazione in ogni scenario immaginabile e ciò ti consentirà di proteggere la tua applicazione dalle violazioni dei dati.

Relazionato: Come eseguire il tuo primo lavoro di test del software

Considera l'esempio sopra. Cosa succede se, dopo il completamento, si verifica l'applicazione solo con valori interi? Potresti abbandonare l'applicazione pensando di aver identificato con successo tutti i potenziali errori quando non è così.

Il fatto è che potresti non essere in grado di identificare tutti i potenziali errori; questo è il motivo per cui la gestione degli errori funziona di pari passo con il test del codice. Il test del programma sopra mostra che si verificherà un potenziale errore in uno scenario specifico.

Tuttavia, se esiste qualche altro errore che non è apparso durante il test, il secondo blocco catch nel codice sopra lo gestirà.

Protezione del database

Se la tua applicazione si connette a un database, il modo migliore per impedire l'accesso a quel database è assicurarsi che tutti gli aspetti della tua applicazione siano protetti. Tuttavia, cosa succede se la tua applicazione è progettata con l'unico scopo di fornire un'interfaccia a detto database?

È qui che le cose si fanno un po 'più interessanti. Nella sua forma più semplice, un database consente a un utente di aggiungere, recuperare, aggiornare ed eliminare dati. Un sistema di gestione del database è un'applicazione che consente a un utente di interagire direttamente con un database.

La maggior parte dei database contiene dati sensibili, quindi, per mantenere l'integrità e limitare l'accesso a questi dati, esiste un requisito per il controllo dell'accesso.

Controllo di accesso

Il controllo degli accessi cerca di mantenere l'integrità di un database definendo il tipo di persone che possono accedere a un database e limitando il tipo di accesso di cui dispongono. Pertanto, un buon sistema di gestione del database dovrebbe essere in grado di registrare chi accede al database, a che ora e cosa ha fatto.

Dovrebbe anche essere in grado di impedire a un utente registrato di accedere o modificare dati con cui non è autorizzato a interagire.

La sicurezza del software è un'abilità fondamentale per tutti gli sviluppatori

Sviluppare un buon software è sinonimo di garantire che il software sia in grado di resistere a qualsiasi attacco dannoso. Ciò è possibile solo attraverso la scrittura di codice protetto, il test continuo di un'applicazione e il controllo di chi ha accesso ai dati.

Ora che sai come proteggere il tuo software, potresti voler conoscere alcuni passaggi di sviluppo del software.

6 fasi di sviluppo del software che tutti i programmatori dovrebbero conoscere

Ti stai preparando a codificare il tuo primo programma? Assicurati di seguire questi passaggi chiave per lo sviluppo del software.

Leggi Avanti

Circa l'autore