Waarom softwarebeveiliging een vaardigheid is die alle programmeurs zouden moeten hebben

Als programmeur of ontwikkelaar kan het belang van het maken van veilige applicaties niet genoeg worden benadrukt.

Softwarebeveiliging behandelt het beheer van kwaadwillende aanvallen door potentiële kwetsbaarheden in software te identificeren en de nodige voorzorgsmaatregelen te nemen om daartegen te beschermen.

Software kan nooit 100% veilig zijn omdat een ontwikkelaar een bug over het hoofd kan zien, nieuwe bugs kan creëren in een poging bestaande gevallen op te lossen of nieuwe kwetsbaarheden kan creëren door middel van updates.

Er zijn echter twee belangrijke praktijken die alle softwareontwikkelaars kunnen toepassen om ervoor te zorgen dat ze veilige software maken die in de eerste plaats beveiligde code schrijft en uw code efficiënt test.

Hoe beveiligde code te schrijven

Het schrijven van beveiligde code komt neer op één foutafhandeling. Als u kunt anticiperen op elke potentiële waarde die een gebruiker aan uw applicatie zou kunnen geven en een reactie in uw programma voor die waarde kunt creëren, dan schrijft u beveiligde code.

Dit is veel eenvoudiger dan je misschien denkt, omdat 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 (de goedgekeurde waarden) en begrijpen dat elke andere mogelijke bestaande waarde een niet-goedgekeurde waarde is.

Beveiligde code schrijven

Stel dat u een programma wilt maken dat slechts twee gehele waarden van een gebruiker accepteert en er een optelbewerking op uitvoert. Met die ene zin weet je, net als een goede ontwikkelaar, nu alles over je applicatie. U kent alle waarden die dit programma zal accepteren (gehele getallen) en u weet welke taak dit programma zal voltooien (een optelbewerking).

Het programma maken in Java-voorbeeld

importeer java.util. Scanner;
openbare klas Main {
// De belangrijkste functie die het programma uitvoert en de twee waarden verzamelt
public static void main (String [] args) {
System.out.println ("Geef uw twee gehele getallen op:");
int waarde1;
int waarde2;
Scanneringang = nieuwe scanner (System.in);
waarde1 = input.nextInt ();
waarde2 = input.nextInt ();
toevoeging (waarde1, waarde2);
input.close ();
}
// de functie die de twee waarden verzamelt en hun som weergeeft
private statische ongeldige toevoeging (int waarde1, int waarde2) {
int som;
som = waarde1 + waarde2;
System.out.println ("De som van de twee gehele getallen die je hebt ingevoerd:" + som);
}
}

Bovenstaande code levert een applicatie op die precies aan de eisen voldoet. Bij uitvoering zal het de volgende regel in de console produceren:

Voer uw twee gehele getallen in:

De toepassing blijft dan gepauzeerd totdat de gebruiker twee gehele getallen invoert in de console (dat betekent dat u de eerste waarde typt, op de Enter-toets drukt en herhaalt).

Als de gebruiker de waarden invoert 5 en 4 in de console zal het programma de volgende uitvoer produceren:

De som van de twee gehele getallen die u heeft ingevoerd: 9

Dit is geweldig; het programma doet precies wat het moet doen. Als er echter een snode gebruiker langskomt en een niet-geheel getal, zoals 'g', in uw toepassing invoert, zullen er problemen zijn. Dit komt doordat geen enkele code in de applicatie bescherming biedt tegen niet-goedgekeurde waarden.

Op dit punt crasht uw applicatie, waardoor een potentiële toegangspoort tot uw applicatie wordt gecreëerd voor de hacker die precies weet wat hij vervolgens moet doen.

Uw programmavoorbeeld beveiligen

importeer java.util. InputMismatchException;
importeer java.util. Scanner;
openbare klas Main {
// De belangrijkste functie die het programma uitvoert en de twee waarden verzamelt
public static void main (String [] args) {
proberen {
System.out.println ("Geef uw twee gehele getallen op:");
int waarde1;
int waarde2;
// de scannerklasse gebruiken om elke invoer van de gebruiker te lezen,
// en wijs het toe aan de respectievelijke variabele (genereert een uitzondering als de waarden geen gehele getallen zijn)
Scanneringang = nieuwe scanner (System.in);
waarde1 = input.nextInt ();
waarde2 = input.nextInt ();
// roept de optelfunctie aan en geeft de twee waarden eraan
toevoeging (waarde1, waarde2);
// sluit de invoerstroom nadat deze aan het einde van zijn gebruik is gekomen
input.close ();
// behandel alle fouten die in het try-blok worden gegenereerd
} catch (InputMismatchException e) {
System.out.println ("Voer een geldige gehele waarde in.");
} catch (uitzondering e) {
System.out.println (e.getMessage ());
}
}
// de functie die de twee waarden verzamelt en hun som weergeeft
private statische ongeldige toevoeging (int waarde1, int waarde2) {
int som;
som = waarde1 + waarde2;
System.out.println ("De som van de twee gehele getallen die je hebt ingevoerd:" + som);
}
}

De bovenstaande code is veilig omdat deze de afhandeling van uitzonderingen uitvoert. Daarom, als u een niet-geheel getal invoert, wordt het programma correct beëindigd terwijl de volgende regel code wordt geproduceerd:

Voer een geldig geheel getal in.

Wat is het afhandelen van uitzonderingen?

In wezen is het afhandelen van uitzonderingen de moderne versie van foutafhandeling, waarbij u foutafhandelingscode scheidt van normale verwerkingscode. In het bovenstaande voorbeeld bevindt alle normale verwerkingscode (of code die mogelijk een uitzondering kan genereren) zich binnen een proberen block, en alle foutafhandelingscode is binnen vangst blokken.

Als je het bovenstaande voorbeeld nader bekijkt, zul je zien dat er twee catch-blokken zijn. De eerste neemt een InputMismatchException argument; dit is de naam van de uitzondering die wordt gegenereerd als een niet-geheel getal wordt ingevoerd. De tweede neemt een Uitzondering argument, en dit is belangrijk omdat het doel is om elke uitzondering binnen de code op te vangen die de ontwikkelaar tijdens het testen niet heeft gevonden.

Verwant: Java-uitzonderingen: gaat u er goed mee om?

Uw code testen

U mag de kracht van het testen en opnieuw testen van uw code voordat u deze verpakt, nooit onderschatten. Veel ontwikkelaars (en gebruikers van hun applicaties) ontdekken nieuwe bugs nadat de software voor het publiek beschikbaar is.

Door uw code grondig te testen, weet u zeker wat uw applicatie zal doen in elk denkbaar scenario, en dat stelt u in staat uw applicatie te beschermen tegen datalekken.

Verwant: Hoe u uw eerste softwaretestopdracht krijgt

Beschouw het bovenstaande voorbeeld eens. Wat als u de applicatie na voltooiing alleen test met gehele getallen? U zou de applicatie kunnen verlaten met de gedachte dat u alle mogelijke fouten met succes heeft geïdentificeerd als dat niet het geval is.

Het is een feit dat u mogelijk niet alle mogelijke fouten kunt identificeren; dit is de reden waarom foutafhandeling hand in hand gaat met het testen van uw code. Het testen van het bovenstaande programma laat zien dat er een mogelijke fout zal optreden in een specifiek scenario.

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

Beveiliging van uw database

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

Dit is waar dingen een beetje interessanter worden. In de meest eenvoudige vorm stelt een database een gebruiker in staat om gegevens toe te voegen, op te halen, bij te werken en te verwijderen. Een databasebeheersysteem is een applicatie waarmee een gebruiker rechtstreeks met een database kan communiceren.

De meeste databases bevatten gevoelige gegevens, daarom is er één vereiste toegangscontrole om de integriteit van en toegang tot deze gegevens te beperken.

Toegangscontrole

Toegangscontrole tracht de integriteit van een database te behouden door het type mensen te definiëren dat toegang heeft tot een database en het type toegang dat ze hebben te beperken. Daarom moet een goed databasebeheersysteem kunnen loggen wie op welk tijdstip toegang heeft tot de database en wat ze hebben gedaan.

Het moet ook kunnen voorkomen dat een geregistreerde gebruiker toegang krijgt tot of gegevens bewerkt waarvoor hij niet geautoriseerd is om mee te werken.

Softwarebeveiliging is een cruciale vaardigheid voor alle ontwikkelaars

Het ontwikkelen van goede software staat gelijk aan ervoor zorgen dat uw software bestand is tegen elke kwaadaardige aanval. Dit is alleen mogelijk door het schrijven van beveiligde code, het continu testen van een applicatie en het behouden van controle over wie toegang heeft tot uw gegevens.

Nu u weet hoe u uw software moet beveiligen, wilt u wellicht meer weten over enkele stappen voor softwareontwikkeling.

6 Stappen voor softwareontwikkeling die alle programmeurs moeten weten

Bereid je je voor om je eerste programma te coderen? Zorg ervoor dat u deze belangrijke stappen voor softwareontwikkeling volgt.

Lees Volgende

Over de auteur