Waarom is softwarebeveiliging een vaardigheid die alle programmeurs zouden moeten hebben?

Als programmeur of ontwikkelaar kan het belang van het creëren van veilige applicaties niet over het hoofd worden gezien.

Softwarebeveiliging richt zich op het beheer van kwaadaardige aanvallen door potentiële kwetsbaarheden in software te identificeren en de nodige voorzorgsmaatregelen te nemen om deze te beschermen.

Software kan nooit 100% veilig zijn, omdat ontwikkelaars een bug kunnen negeren, nieuwe bugs kunnen introduceren terwijl ze bestaande repareren, of nieuwe kwetsbaarheden kunnen introduceren via updates.

Er zijn echter twee belangrijke methoden die alle softwareontwikkelaars kunnen gebruiken om ervoor te zorgen dat ze veilige software maken. Het gaat erom vanaf het begin veilige code te schrijven en de code effectief te testen.

Softwarebeveiliging speelt een uiterst belangrijke rol

Hoe veilige code te schrijven

Het schrijven van veilige code heeft maar één ding te doen: foutafhandeling. Als u kunt anticiperen op elke potentiële waarde die de gebruiker aan de applicatie kan leveren en in het programma een reactie voor die waarde kan genereren, dan schrijft u veilige code.

Dit is veel eenvoudiger dan je zou denken, aangezien alle goede ontwikkelaars bijna alles weten over de applicaties die ze ontwikkelen. Daarom moet u elke waarde kennen die uw toepassing nodig heeft om een ​​taak uit te voeren (goedgekeurde waarden) en begrijpen dat alle andere waarden die mogelijk bestaan, niet-goedgekeurde waarden zijn.

Schrijf veilige code

Stel dat u een programma wilt maken dat slechts twee gehele waarden van de gebruiker accepteert en daarop een optelbewerking uitvoert. Als goede ontwikkelaar weet u nu alles over uw applicatie. Je kent alle waarden die dit programma accepteert (gehele waarden) en je weet welke taak dit programma zal uitvoeren (een optelbewerking).

Voorbeeld van het maken van een programma in Java

import java.util.Scanner;
public class Main {
//The main function that executes the program and collects the two values
public static void main(String[] args) {
System.out.println("Please enter your two integer values: ");
int value1;
int value2;
Scanner input = new Scanner(System.in);
value1 = input.nextInt();
value2 = input.nextInt();
addition(value1, value2);
input.close();
}
//the function that collects the two values and displays their sum
private static void addition(int value1, int value2) {
int sum;
sum = value1 + value2;
System.out.println("The sum of the two integer values you entered: "+ sum);
}
}

Met de bovenstaande code wordt een applicatie gemaakt die precies aan de vereisten voldoet. Wanneer het wordt uitgevoerd, zal het de volgende regel in de console produceren:

Please enter your two integer values:

De applicatie blijft dan gepauzeerd totdat de gebruiker twee gehele waarden in de console invoert (dit betekent: voer de eerste waarde in, druk op de Enter- toets en herhaal).

Als de gebruiker de waarden 5 en 4 in de console invoert, produceert het programma de volgende uitvoer:

The sum of the two integer values you entered: 9

Dat is geweldig. Het programma doet precies wat het moet doen. Als een snode gebruiker echter binnenkomt en een niet-gehele waarde, zoals 'g', in uw toepassing invoert, zal er een probleem zijn. Dit komt omdat er geen code in de applicatie zit die bescherming biedt tegen niet-goedgekeurde waarden.

Op dit punt crasht uw applicatie, waardoor een potentiële toegangspoort tot uw applicatie ontstaat, zodat hackers precies weten wat ze vervolgens moeten doen.

Voorbeeld van programmabeveiliging

import java.util.InputMismatchException;
import java.util.Scanner;
public class Main {
//The main function that executes the program and collects the two values
public static void main(String[] args) {
try {
System.out.println("Please enter your two integer values: ");
int value1;
int value2;
//using the scanner class to read each input from the user,
//and assign it to is respective variable (throws an exception if the values are not integers)
Scanner input = new Scanner(System.in);
value1 = input.nextInt();
value2 = input.nextInt();
//calls the addition function and passes the two values to it
addition(value1, value2);
//closes the input stream after it has come to the end of its use
input.close();
//handle all the errors thrown in the try block
}catch(InputMismatchException e){
System.out.println("Please enter a valid integer value.");
}catch(Exception e) {
System.out.println(e.getMessage());
}
}
//the function that collects the two values and displays their sum
private static void addition(int value1, int value2) {
int sum;
sum = value1 + value2;
System.out.println("The sum of the two integer values you entered: "+ sum);
}
}

De bovenstaande code is veilig omdat deze uitzonderingen afhandelt. Als u daarom een ​​niet-gehele waarde invoert, genereert het programma de volgende coderegel:

Please enter a valid integer value.

Wat is de afhandeling van uitzonderingen?

Afhandeling van uitzonderingen

In wezen is uitzonderingsafhandeling de moderne versie van foutafhandeling, waarbij u de foutafhandelingscode scheidt van de reguliere afhandelingscode. In het bovenstaande voorbeeld bevindt alle normale afhandelingscode (of mogelijk code die uitzonderingen veroorzaakt) zich in het try -blok en bevindt alle foutafhandelingscode zich in het catch-blok.

Als je het bovenstaande voorbeeld nader bekijkt, zie je dat er twee vangblokken zijn. De eerste gebruikt een InputMismatchException- argument : dit is de naam van de uitzondering die wordt gegenereerd als een niet-geheel getal wordt ingevoerd. De tweede gebruikt het Exception- argument en dit is belangrijk omdat het doel ervan is om eventuele uitzonderingen in de code te vinden die de ontwikkelaar tijdens het testen niet heeft gevonden.

• Hoe u gegevens kunt beveiligen tijdens het thuiswerken

Controleer de code

Onderschat nooit de kracht van het testen en opnieuw testen van code. Veel ontwikkelaars (en app-gebruikers) ontdekken nieuwe bugs nadat de software voor het publiek beschikbaar is gesteld.

Door uw code grondig te testen weet u wat uw applicatie in elke denkbare situatie doet en kunt u deze beschermen tegen datalekken.

Beschouw het bovenstaande voorbeeld. Wat als u, eenmaal voltooid, de applicatie alleen test met gehele waarden? U kunt de toepassing verlaten met de gedachte dat u alle potentiële fouten met succes hebt geïdentificeerd, terwijl dat in werkelijkheid niet het geval is.

De realiteit is dat u mogelijk niet alle potentiële fouten kunt identificeren. Dit is de reden waarom foutafhandeling samenwerkt met het testen van uw code. Als u het bovenstaande programma test, wordt een mogelijke fout ontdekt die in een bepaalde situatie kan optreden.

Als er echter een andere fout optreedt die niet tijdens het testen is opgetreden, zal het tweede catch-blok in de bovenstaande code deze afhandelen.

Databasebeveiliging

Als uw applicatie verbinding maakt met een database, kunt u de toegang tot die database het beste voorkomen door ervoor te zorgen dat alle aspecten van de applicatie veilig zijn. Maar wat als uw applicatie is ontworpen met als enige doel het bieden van een interface met de genoemde database?

Dit is waar de dingen een beetje interessanter worden. In de meest basale vorm stellen databases gebruikers in staat gegevens toe te voegen, op te halen, bij te werken en te verwijderen. Een databasebeheersysteem is een applicatie waarmee gebruikers rechtstreeks met een database kunnen communiceren.

De meeste databases bevatten gevoelige gegevens. Om de integriteit te behouden en de toegang tot deze gegevens te beperken, is er daarom een ​​vereiste: toegangscontrole.

Toegangscontrole

Toegangscontrole heeft tot doel de integriteit van de database te behouden door te bepalen welke typen mensen toegang hebben tot de database en door het type toegang dat zij hebben te beperken. Daarom moet een goed databasebeheersysteem kunnen vastleggen wie de database heeft geopend, wanneer en wat ze hebben gedaan.

Het kan ook voorkomen dat geregistreerde gebruikers gegevens openen of bewerken waarmee ze niet bevoegd zijn om te communiceren.