Por que a segurança de software é uma habilidade que todos os programadores deveriam ter?

Como programador ou desenvolvedor, a importância de criar aplicações seguras não pode ser negligenciada.

A segurança de software aborda o gerenciamento de ataques maliciosos, identificando vulnerabilidades potenciais no software e tomando as precauções necessárias para protegê-las.

O software nunca pode ser 100% seguro porque os desenvolvedores podem ignorar um bug, introduzir novos bugs enquanto corrigem os existentes ou introduzir novas vulnerabilidades por meio de atualizações.

No entanto, existem dois métodos principais que todos os desenvolvedores de software podem usar para garantir a criação de software seguro. Trata-se de escrever código seguro desde o início e testá-lo de maneira eficaz.

A segurança do software desempenha um papel extremamente importante

Como escrever código seguro

Escrever código seguro tem apenas uma coisa a fazer: tratamento de erros. Se você puder antecipar cada valor potencial que o usuário pode fornecer ao aplicativo e gerar uma resposta no programa para esse valor, então você estará escrevendo um código seguro.

Isso é muito mais simples do que você imagina, pois todos os bons desenvolvedores sabem quase tudo sobre os aplicativos que desenvolvem. Portanto, você deve conhecer todos os valores que sua aplicação necessita para executar uma tarefa (valores aprovados) e entender que quaisquer outros valores que possam existir são valores não aprovados.

Escreva código seguro

Suponha que você queira criar um programa que aceite apenas dois valores inteiros do usuário e execute uma operação de adição sobre eles. 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 realizará (uma operação de adição).

Exemplo de criação de um programa em 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 cria um aplicativo que atende exatamente aos requisitos. Quando executado, 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 (ou seja, insira o primeiro valor, pressione a tecla Enter e repita).

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 deveria fazer. No entanto, se um usuário nefasto entrar e inserir um valor não inteiro, como “g”, em seu aplicativo, haverá um problema. Isso ocorre porque não há código no aplicativo que proteja contra valores não aprovados.

Nesse ponto, seu aplicativo irá travar, criando um gateway potencial para seu aplicativo, para que os hackers saibam exatamente o que fazer a seguir.

Exemplo de segurança do 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 realiza tratamento de exceções. Portanto, se você inserir um valor não inteiro, o programa irá gerar a seguinte linha de código:

Please enter a valid integer value.

O que é tratamento de exceções?

Manipulação de exceção

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 tratamento regular. No exemplo acima, todo o código de tratamento normal (ou código potencialmente causador de exceção) está no bloco try e todo o código de tratamento de erros está no bloco catch.

Se você olhar mais de perto o exemplo acima, verá que existem dois blocos catch. O primeiro recebe um argumento InputMismatchException - este é o nome da exceção lançada se um valor não inteiro for inserido. O segundo recebe o argumento Exception , e isso é importante porque seu objetivo é encontrar quaisquer exceções no código que o desenvolvedor não encontrou durante o teste.

• Como proteger os dados ao trabalhar em casa

Verifique o código

Você nunca deve subestimar o poder de testar e retestar o código. Muitos desenvolvedores (e usuários de aplicativos) encontram novos bugs depois que o software é disponibilizado ao público.

Testes completos do seu código garantem que você saiba o que seu aplicativo fará em todas as situações concebíveis e isso permite protegê-lo contra violações de dados.

Considere o exemplo acima. E se, depois de concluído, você testar o aplicativo apenas com valores inteiros? Você pode sair do aplicativo pensando que identificou com êxito todos os possíveis erros, quando na verdade não o fez.

A realidade é que talvez você não consiga identificar todos os erros potenciais. É por isso que o tratamento de erros funciona em conjunto com o teste do seu código. Testar o programa acima revela um erro potencial que ocorrerá em uma situação específica.

No entanto, se existir algum outro erro que não apareceu durante o teste, o segundo bloco catch no código acima irá lidar com isso.

Segurança do banco de dados

Se o seu aplicativo se conectar a um banco de dados, a melhor maneira de impedir o acesso a esse banco de dados é garantir que todos os aspectos do aplicativo estejam seguros. Porém, e se a sua aplicação for projetada com o único propósito de fornecer uma interface para esse banco de dados?

É aqui que as coisas ficam um pouco mais interessantes. Na sua forma mais básica, os bancos de dados permitem aos usuários adicionar, recuperar, atualizar e excluir dados. Um sistema de gerenciamento de banco de dados é um aplicativo que permite aos usuários 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, existe um requisito - controle de acesso.

Controle de acesso

O controle de acesso busca manter a integridade do banco de dados determinando os tipos de pessoas que podem acessar o banco de dados e restringindo o tipo de acesso que possuem. Portanto, um bom sistema de gerenciamento de banco de dados deve ser capaz de registrar quem acessou o banco de dados, quando e o que fez.

Também pode impedir que usuários registrados acessem ou editem dados com os quais não estão autorizados a interagir.