Desenvolvimento Seguro de Software se tornará em breve pauta n° 1 no mercado de TI

Alcyon Junior em 03/09/2018 no site Profissionais TI

Em 2017 ocorreram diversas ações de grupos de hackers que impactaram o cenário das grandes empresas diretamente. O melhor exemplo disso foi o famoso Ransomware Wannacry, que atingiu mais de 230.000 sistemas corporativos deixando o negócio dessas empresas totalmente paralisados.

Os dados são um dos ativos mais valiosos que uma empresa tem a sua disposição, abrangendo desde transações financeiras até detalhes importantes de clientes e clientes em potencial.

Com a LGDP – Lei de Proteção de Dados Pessoais – prestes a entrar em vigor no Brasil, é vital para as empresas começarem a reavaliar seus sistemas “pra ontem”. As empresas precisam planejar como minimizar os riscos, manter os dados seguros e implementar os processos de Desenvolvimento Seguro de Software caso precisem lidar com qualquer uma das ameaças à segurança de dados.

Observando esse cenário, as empresas estão cada vez mais contratando profissionais que tenham conhecimento em segurança da informação. Esse perfil não é exatamente a de um profissional de segurança da informação efetivo, mas sim a de um profissional de TI especialista em segurança da informação dentro da sua área.

Dentre as diversas áreas da tecnologia da informação, a área que está com a maior lacuna é a de profissionais de desenvolvimento com especialidade em desenvolvimento seguro de software. Essa lacuna, está fazendo com que esta temática eleve seu grau de importância cada vez mais e, até o final de 2019, será o profissional mais requisitado do mercado.

Agora que você entendeu que esse é um tópico de fundamental importância com muitos aspectos a serem considerados, inicialmente pode ser confuso saber por onde começar, então, aqui vão 4 dicas vitais para você que deseja ser um profissional qualificado na área de desenvolvimento seguro de software.

1. Analise o código-fonte linha a linha – Testes Unitários

A próxima metodologia de que falaremos é o teste unitário. Dependendo da sua experiência, você pode ou não ter ouvido algo sobre testes de unidade, desenvolvimento orientado a testes ou algum outro tipo de metodologia de teste. Normalmente, essas metodologias são aplicadas no contexto de grandes sistemas de software e, às vezes, no contexto de sites simples.

Na programação de computadores, o teste de unidade é um processo de desenvolvimento de software no qual a menor parte testável de um código-fonte, denominada unidade, é testada individualmente e de forma independente para examinar se estão funcionando conforme o esperado. Isso ajuda você a identificar falhas nos algoritmos e / ou lógica antes que o código seja liberado.

Um dos benefícios que você adquire ao criar testes de unidade é que sua equipe estará motivada a escrever código testável. Como o teste de unidade requer a estrutura apropriada do seu código, isso significa que o código deve ser dividido em funções menores e mais focadas. Cada um dos quais é responsável por uma única operação em um conjunto de dados, em vez de em grandes funções que executam várias operações diferentes.

2. Integração contínua

A Integração Contínua (CI) é uma prática de desenvolvimento que exige que os desenvolvedores integrem o código em um repositório compartilhado várias vezes ao dia (SVN, Subversion ou Git). Cada check-in é verificado pelos testes automatizados. Embora os testes automatizados não sejam estritamente parte do IC, eles geralmente são previstos. Essa abordagem permite que os desenvolvedores detectem problemas mais cedo e, como resultado, os resolvam mais rapidamente.

Esta é uma prática valiosa por si só. Você deve se concentrar em configurar um processo simples de Integração Contínua o mais cedo possível. Existem muitas ferramentas que podem ajudá-lo a configurar esse processo e as mais conhecidas são Jenkins , Bamboo e Teamcity . Eles permitem que você automatize sua implantação de software e permita que você se concentre na criação de seu produto.

3. Sessão de demonstração

A reunião de revisão de demonstração geralmente ocorre perto do final do Sprint. O objetivo desta reunião é mostrar os outros membros da equipe, clientes e partes interessadas que os resultados da equipe de trabalho realizaram durante a Sprint.

Pode não ser imediatamente visível por que isso leva a um código melhor, mas o fará. Ao mostrar regularmente o código-fonte, os desenvolvedores precisam mantê-lo próximo ao estado de lançamento. Com reuniões de demonstração regularmente, você terá um processo bem organizado de receber feedbacks. E isso lhe dará uma melhor compreensão do que foi feito corretamente e indicará quando algo foi na direção errada.

Agora, vamos seguir em frente e verificar quais são algumas ferramentas de qualidade de código recomendadas para aperfeiçoar o processo. Você deve realizar avaliações de risco regulares para identificar quaisquer perigos potenciais para os dados da sua organização. Isso deve analisar todas as ameaças que você pode identificar, desde uma violação de dados on-line até ameaças mais físicas, como cortes de energia. Isso permitirá identificar quaisquer pontos fracos no sistema de segurança de dados atual da organização e, a partir daqui você pode formular um plano de como remediar isso e priorizar ações para reduzir o risco de uma violação de dados cara.

4. Revisão de código

A próxima melhor coisa para emparelhar a programação é a revisão de código. Se você não praticar a programação em pares, recomenda-se considerar pelo menos a revisão de código. É um processo leve que deve ser aplicado o mais rápido possível depois que o código é escrito.

Ao longo dos anos trabalhando em diferentes projetos de desenvolvimento de software, acumulamos nossa própria experiência de tornar o bom código melhor. E aqui estão as coisas que recomendamos fazer durante todo o processo para melhorar a qualidade do código:

• Siga o guia de estilo da linguagem de programação;
• Aderir aos princípios do STRIDE no seu design;
• Dê nomes descritivos para métodos e variáveis;
• Use padrões de design;
• Não reinvente a roda ou utilize estruturas de terceiros;
• Use estruturas de dados e algoritmos eficientes;
• Crie testes unitários;
• Documente todos os aspectos do seu projeto;
• Mantenha todos os elementos do seu projeto sob o sistema de controle de versão.

Em conjunto com a metodologia de desenvolvimento seguro e suas práticas de programação diárias, você acabará desenvolvendo de forma mais legível, mais segura e tornando a revisão do código mais simples. Você também vai poupar seu trabalho, sua equipe e seus clientes de muitas dores de cabeça, tempo e, portanto, dinheiro.

Seguindo todas essas dicas você estará mitigando os riscos mais comuns. Caso queira se aprofundar no tema, você pode fazer o curso Gratuito “Desenvolvimento Seguro de Software” CLICANDO AQUI. Com esse curso gratuito você estará totalmente preparado para esse novo nicho de mercado de trabalho.

C# 7.0: Tuplas – Como simplificar a manipulação de agrupamentos de dados

PorRenato Groffe em 12/09/2017 no site iMasters

Manipular conjuntos de valores constitui um tipo de ocorrência extremamente comum no desenvolvimento de aplicações, existindo inclusive inúmeras formas de se realizar este tipo de tarefa.

Dentre as abordagens disponíveis é possível destacar:

• A criação de classes, com propriedades representando cada um dos diferentes elementos que compõem um agrupamento de dados. Em tais situações há uma certa tendência de crescimento desenfreado no número de tipos que integram um projeto, sobretudo se considerarmos o escopo de utilização reduzido para muitas das estruturas geradas (simples retornos de métodos)
• No caso de específico de métodos, a necessidade de retornar múltiplos valores pode levar ao uso de parâmetros associados aos modificadores out e ref (com a passagem de valores por referência). Embora funcional, a opção frequente por esta prática pode resultar em uma codificação mais extensa e nem sempre tão elegante.
• Uma alternativa seria a utilização de uma instância baseada em um tipo anônimo, em conjunto com o modificador dynamic. Ao empregar esta técnica o desenvolvedor abrirá mão da checagem estática de tipos. Importante ressaltar que esta solução também acarreta custos adicionais em termos de performance.

O C# 7.0 conta agora com as tuplas (em inglês tuples), um novo tipo de estrutura concebido com o intuito de simplificar a manipulação de agrupamentos de dados nos cenários aqui descritos. Para ativar este recurso será necessário adicionar o package System.ValueTuplea um projeto:

A próxima listagem possui 3 exemplos envolvendo o uso de tuplas:

• Uma tupla pode ser formada por 1, 2, 3 ou mais itens, com os tipos de suas diferentes propriedades e seus respectivos valores sendo declarados entre parênteses;
• As tuplas parValores e dezenas contam com campos cujo nomes não foram declarados explicitamente. Por convenção, serão assumidos como identificadores Item1, Item2, Item3 e assim por diante (levando em conta a ordem de declaração e a quantidade de elementos presentes);
• Já a tupla coordenadas foi declarada empregando o modificador var. Os nomes de suas diferentes propriedades também foram especificados, de forma a facilitar o acesso aos dados que as mesmas representam.

using System;

namespace ExemploTuplas01

{

class Program

{

static void Main(string[] args)

{

(int, int) parValores = (7, 49);

Console.WriteLine($"Valor = {parValores.Item1} ----- " +

$"Quadrado = {parValores.Item2}");

(int, int, int) dezenas = (10, 20, 30);

Console.WriteLine($"Valor 1 = {dezenas.Item1} ----- " +

$"Valor 2 = {dezenas.Item2} ----- " +

$"Valor 3 = {dezenas.Item3}");

var coordenadas = (latitude: "23.5505° S", longitude: "46.6333° W");

Console.WriteLine($"São Paulo - " +

$"Latitude = {coordenadas.latitude} - " +

$"Longitude = {coordenadas.longitude}");

Console.ReadKey();

}

}

}

Uma das grandes vantagens do uso de tuplas, quando comparadas a referências dinâmicas, está no suporte do IntelliSense a esse novo tipo de recurso. Isto pode ser observado na imagem a seguir:

A execução deste conjunto de instruções produzirá o seguinte resultado:

A tendência é que tuplas sejam utilizadas como retorno de métodos, como no caso da operação ConverterTemperaturas (cuja implementação está na listagem a seguir):

• O retorno de ConverterTemperaturas pode ser associado a uma referência declarada com o modificador var, conforme indicado na declaração da variável resultado1;
• É possível também consumir resultados baseados em tuplas através de uma técnica conhecida como desconstrução (deconstruction), como especificado nos outros 3 exemplos de uso do método ConverterTemperaturas;
• A declaração das variáveis resFahrenheit2, resCelsius2 e resKelvin2 entre parênteses permitirá que os valores da tupla produzida ao invocar ConverterTemperaturas sejam associados a estas referências;
• O segundo exemplo de desconstrução é bastante similar ao primeiro, exceto pela presença de um discard representado pelo caracter “_” (underline). Este ajuste dispensa a declaração de uma variável que receberia o valor armazenado pela propriedade tempFahrenheit da tupla;
• No terceiro caso de desconstrução as variáveis resFahrenheit4, resCelsius4 e resKelvin4foram declaradas da forma convencional e, num segundo momento, associadas em sequência ao retorno do método ConverterTemperaturas.

using System;

namespace ExemploTuplas02

{

class Program

{

private static (double tempFahrenheit, double tempCelsius, double tempKelvin)

ConverterTemperaturas(double valorFahrenheit)

{

double retCelsius = Math.Round((valorFahrenheit - 32) / 1.8, 2);

double retKelvin = retCelsius + +273.15;

return (valorFahrenheit, retCelsius, retKelvin);

}

static void Main(string[] args)

{

Console.WriteLine("Conversão de temperaturas");

// Exemplo simples

var resultado1 = ConverterTemperaturas(86);

Console.WriteLine($"Fahrenheit = {resultado1.tempFahrenheit} - " +

$"Celsius = {resultado1.tempCelsius} - " +

$"Kelvin = {resultado1.tempKelvin}");

// Exemplo 1 - Desconstrução

(double resFahrenheit2, double resCelsius2, double resKelvin2) =

ConverterTemperaturas(32);

Console.WriteLine($"Fahrenheit = {resFahrenheit2} - " +

$"Celsius = {resCelsius2} - " +

$"Kelvin = {resKelvin2}");

// Exemplo 2 - Desconstrução

double valorFahrenheit3 = 212;

(_, double resCelsius3, double resKelvin3) =

ConverterTemperaturas(valorFahrenheit3);

Console.WriteLine($"Fahrenheit = {valorFahrenheit3} - " +

$"Celsius = {resCelsius3} - " +

$"Kelvin = {resKelvin3}");

// Exemplo 3 - Desconstrução

double resFahrenheit4;

double resCelsius4;

double resKelvin4;

(resFahrenheit4, resCelsius4, resKelvin4) =

ConverterTemperaturas(86);

Console.WriteLine($"Fahrenheit = {resFahrenheit4} - " +

$"Celsius = {resCelsius4} - " +

$"Kelvin = {resKelvin4}");

Console.ReadKey();

}

}

}

O resultado ao processar este conjunto de instruções pode ser observado na próxima imagem:

E para finalizar, gostaria de saber mais sobre as novidades do C# 7.0? Não deixem de assistir então a gravação de um hangout realizado recentemente pelo Canal .NET sobre este assunto:

Disponibilizei também no GitHub os diferentes exemplos apresentados durante a transmissão:

https://github.com/renatogroffe/CSharp7_VS2017

Referências

• New Features in C# 7.0
• Conteúdos gratuitos sobre ASP.NET Core, .NET Core e C# 7.0