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 que eles criem código seguro de software seguro em primeiro lugar e testando seu código de forma eficiente.

Como escrever um código seguro

Escrever código seguro se resume a uma coisa: lidar com 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 {
// A função principal que executa o programa e coleta os dois valores
public static void main (String [] args) {
System.out.println ("Por favor, insira seus dois valores inteiros:");
int value1;
int value2;
Entrada do scanner = novo Scanner (System.in);
valor1 = entrada.nextInt ();
valor2 = entrada.nextInt ();
adição (valor1, valor2);
input.close ();
}
// a função que coleta os dois valores e exibe sua soma
adição de vazio estático privado (int value1, int value2) {
int sum;
soma = valor1 + valor2;
System.out.println ("A soma dos dois valores inteiros inseridos:" + soma);
}
}

O código acima produz um aplicativo que corresponde aos requisitos com precisão. Na execução, ele produzirá a seguinte linha no console:

Insira seus dois valores inteiros:

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:

A soma dos dois valores inteiros que você inseriu: 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 {
// A função principal que executa o programa e coleta os dois valores
public static void main (String [] args) {
tentar {
System.out.println ("Por favor, insira seus dois valores inteiros:");
int value1;
int value2;
// usando a classe scanner para ler cada entrada do usuário,
// e atribuí-lo a sua respectiva variável (lança uma exceção se os valores não forem inteiros)
Entrada do scanner = novo Scanner (System.in);
valor1 = entrada.nextInt ();
valor2 = entrada.nextInt ();
// chama a função de adição e passa os dois valores para ela
adição (valor1, valor2);
// fecha o fluxo de entrada depois que ele chega ao fim de seu uso
input.close ();
// lida com todos os erros lançados no bloco try
} catch (InputMismatchException e) {
System.out.println ("Insira um valor inteiro válido.");
} catch (exceção e) {
System.out.println (e.getMessage ());
}
}
// a função que coleta os dois valores e exibe sua soma
adição de vazio estático privado (int value1, int value2) {
int sum;
soma = valor1 + valor2;
System.out.println ("A soma dos dois valores inteiros inseridos:" + soma);
}
}

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:

Insira um valor inteiro válido.

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 tentar bloco, e todo o código de tratamento de erros está dentro pega blocos.

Se você der uma olhada no exemplo acima, verá que há dois blocos de captura. O primeiro leva um InputMismatchException argumento; este é o nome da exceção que é lançada se um valor não inteiro for inserido. O segundo leva um Exceção argumento, e isso é importante porque seu objetivo é capturar qualquer exceção dentro do código que o desenvolvedor não encontrou durante o teste.

Relacionado: Exceções Java: você está lidando com elas da maneira certa?

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 permite que você proteja seu aplicativo de violações de dados.

Relacionado: Como conseguir seu primeiro trabalho de teste de software

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 sucesso 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 algum outro erro que não apareceu durante o teste existir, o segundo bloco catch no código acima irá tratá-lo.

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 de controle de acesso.

Controle de acesso

O controle de acesso busca 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.

6 etapas de desenvolvimento de software que todos os programadores devem saber

Preparando-se para codificar seu primeiro programa? Certifique-se de seguir estas etapas principais de desenvolvimento de software.

Leia a seguir

Sobre o autor