Por que a segurança de software é uma habilidade que todos os programadores deveriam ter
Como programador ou desenvolvedor, a importância de criar aplicativos seguros não pode ser exagerada.
A segurança de software lida com o gerenciamento de ataques maliciosos, identificando vulnerabilidades potenciais no software e tomando as precauções necessárias para protegê-los.
O software nunca pode ser 100% seguro porque um desenvolvedor pode ignorar um bug, criar novos bugs na tentativa de corrigir casos existentes ou criar novas vulnerabilidades por meio de atualizações.
No entanto, existem duas práticas principais que todos os desenvolvedores de software podem empregar para garantir a criação de software seguro — escrever código seguro em primeiro lugar e testar seu código com eficiência.
Como escrever um código seguro
Escrever código seguro se resume a uma coisa — tratamento de erros. Se você puder antecipar cada valor potencial que um usuário pode alimentar em seu aplicativo e criar uma resposta em seu programa para esse valor, então você está escrevendo um código seguro.
Isso é muito mais simples do que você imagina, porque todos os bons desenvolvedores sabem quase tudo sobre os aplicativos que desenvolvem. Portanto, você deve saber todos os valores que seu aplicativo requer para realizar uma tarefa (os valores aprovados) e entender que todos os outros valores possíveis existentes são um valor não aprovado.
Escrevendo código seguro
Digamos que você queira criar um programa que aceite apenas dois valores inteiros de um usuário e execute uma operação de adição neles. Com essa única frase, como um bom desenvolvedor, agora você sabe tudo sobre seu aplicativo. Você conhece todos os valores que este programa aceitará (valores inteiros) e sabe a tarefa que este programa completará (uma operação de adição).
Criando o programa em exemplo de 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);
}
}
O código acima produz um aplicativo que corresponde aos requisitos com precisão. Na execução, ele produzirá a seguinte linha no console:
Please enter your two integer values:
O aplicativo permanecerá pausado até que o usuário insira dois valores inteiros no console (isso significa digitar o primeiro valor, pressionar a tecla Enter e repetir).
Se o usuário inserir os valores 5 e 4 no console, o programa produzirá a seguinte saída:
The sum of the two integer values you entered: 9
Isso é ótimo; o programa faz exatamente o que deve fazer. No entanto, se um usuário perverso aparecer e inserir um valor não inteiro, como “g”, em seu aplicativo, haverá problemas. Isso ocorre porque nenhum código no aplicativo protege contra valores não aprovados.
Nesse ponto, seu aplicativo irá travar, criando um gateway potencial em seu aplicativo para o hacker que sabe exatamente o que fazer a seguir.
Protegendo Seu Exemplo de Programa
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);
}
}
O código acima é seguro porque executa o tratamento de exceções. Portanto, se você inserir um valor não inteiro, o programa será encerrado corretamente ao produzir a seguinte linha de código:
Please enter a valid integer value.
O que é tratamento de exceções?
Essencialmente, o tratamento de exceções é a versão moderna do tratamento de erros, onde você separa o código de tratamento de erros do código de processamento normal. No exemplo acima, todo o código de processamento normal (ou código que pode potencialmente lançar uma exceção) está dentro de um bloco try e todo o código de tratamento de erros está dentro de blocos catch .
Se você der uma olhada no exemplo acima, verá que há dois blocos de captura. O primeiro leva um argumento InputMismatchException ; este é o nome da exceção que é lançada se um valor não inteiro for inserido. O segundo recebe um argumento Exception , e isso é importante porque seu propósito é capturar qualquer exceção dentro do código que o desenvolvedor não encontrou durante o teste.
Testando Seu Código
Você nunca deve subestimar o poder de testar e retestar seu código antes de empacotar. Muitos desenvolvedores (e usuários de seus aplicativos) encontram novos bugs depois que o software é disponibilizado ao público.
O teste completo de seu código garantirá que você saiba o que seu aplicativo fará em todos os cenários concebíveis, e isso permitirá que você proteja seu aplicativo de violações de dados.
Considere o exemplo acima. E se, após a conclusão, você testar o aplicativo apenas com valores inteiros? Você pode sair do aplicativo pensando que identificou com êxito todos os erros em potencial, quando esse não é o caso.
O fato é que você pode não ser capaz de identificar todos os erros potenciais; é por isso que o tratamento de erros trabalha lado a lado com o teste de seu código. O teste do programa acima mostra que um erro potencial ocorrerá em um cenário específico.
No entanto, se houver algum outro erro que não apareceu durante o teste, o segundo bloco catch no código acima o tratará.
Protegendo seu banco de dados
Se seu aplicativo se conecta a um banco de dados, a melhor maneira de impedir o acesso a esse banco de dados é garantir que todos os aspectos de seu aplicativo estejam seguros. No entanto, e se o seu aplicativo for projetado com o único propósito de fornecer uma interface para o referido banco de dados?
É aqui que as coisas ficam um pouco mais interessantes. Em sua forma mais básica, um banco de dados permite que um usuário adicione, recupere, atualize e exclua dados. Um sistema de gerenciamento de banco de dados é um aplicativo que permite ao usuário interagir diretamente com um banco de dados.
A maioria dos bancos de dados contém dados confidenciais, portanto, para manter a integridade e limitar o acesso a esses dados, há um requisito — controle de acesso.
Controle de acesso
O controle de acesso visa manter a integridade de um banco de dados, definindo o tipo de pessoas que podem acessar um banco de dados e restringindo o tipo de acesso que têm. Portanto, um bom sistema de gerenciamento de banco de dados deve ser capaz de registrar quem acessou o banco de dados, em que horas e o que eles fizeram.
Também deve ser capaz de impedir que um usuário registrado acesse ou edite dados com os quais não está autorizado a interagir.
Segurança de software é uma habilidade crucial para todos os desenvolvedores
Desenvolver um bom software é sinônimo de garantir que seu software possa resistir a qualquer ataque malicioso. Isso só é possível por meio da escrita de um código seguro, do teste contínuo de um aplicativo e da manutenção do controle de quem tem acesso aos seus dados.
Agora que você sabe como proteger seu software, talvez queira aprender sobre algumas etapas de desenvolvimento de software.
