Lab 1.2: Utilizando linters e ferramenta de segurança

Analisando código com ruff

Ao implementar projetos em Python, é fundamental garantirmos um código legível e seguindo os padrões da linguagem, como indicado no lab anterior, para garantir qualidade, segurança e legibilidade ao código. Atualmente, existem diversas ferramentas que podem ser aplicadas durante o processo de implantação de automações em Python, que realizam as análises de qualidade do código, indicando pontos que estejam foram dos padrões das PEPs Python e até mesmo corrigindo-os automaticamente.

Ruff

Ruff é um linter rápido e eficiente para Python. Ele foi projetado para ser altamente configurável e rápido, realizando verificações de estilo e erros de código. Ele é mais rápido que outros linters populares (como o pylint e flake8) devido ao seu design otimizado e ao uso de técnicas de compilação.

Benefícios do Ruff:

Desempenho: O Ruff é significativamente mais rápido do que linters tradicionais como o - pylint e flake8.
Facilidade de Uso: Requer pouca configuração e é fácil de integrar em seu fluxo de trabalho.
Alta Configuração: Você pode configurar quais regras deseja aplicar, ou até mesmo desativar certas verificações.
Compatibilidade: O Ruff oferece compatibilidade com diversas regras de linters populares, como flake8, black, isort, etc.
Análise de Segurança: Além de verificar o estilo do código, ele também verifica problemas de segurança, como importações não utilizadas e práticas arriscadas.

Como Integrar o Ruff no Seu Projeto Python localmente?

1 - Instalando o Ruff o primeiro passo é instalar o Ruff no seu ambiente de desenvolvimento. Você pode instalá-lo com o pip:

pip install ruff

2 - Rodando o Ruff no Código: Para rodar o Ruff em um diretório (onde seu projeto Python está localizado, por exemplo), rode o seguinte comando:

ruff check .

Isso irá verificar todo o código no diretório atual e subdiretórios. O Ruff então irá mostrar qualquer problema encontrado, como problemas de formatação ou uso incorreto de importações. Como podemos ver abaixo:

O Ruff identificou 3 erros, onde:

Na linha 14 do arquivo csv_functions erro de indentação, em decorrência do avanço da doc string.
Na linha 16 do arquivo csv_functions erro de indentação, em decorrência do avanço da doc string.
Na linha 6 do arquivo email_functions erro gerado por estar usando uma classe sem o devido import.

Após corrigir esses erros, ao rodar novamente ruff check . todas as verificações finalizaram sem problemas.

Buscando vulnerabilidades de dependências com Snyk

O Snyk é uma ferramenta de segurança para desenvolvedores, focada principalmente em detectar e corrigir vulnerabilidades de segurança em dependências de código, infraestrutura e pipelines de CI/CD.

O Snyk ajuda a proteger as aplicações contra problemas de segurança que podem ser introduzidos por pacotes e bibliotecas externas, além de oferecer monitoramento contínuo da segurança.

Como o Snyk atua na segurança de dependências

Análise de Dependências

O Snyk realiza a análise automática das dependências de um projeto. Ele escaneia tanto as dependências diretas (pacotes explicitamente incluídos no projeto) quanto as dependências transitivas (pacotes que essas dependências diretas exigem).
Ao escanear o projeto, o Snyk identifica as bibliotecas e versões usadas, e compara essas versões com uma base de dados de vulnerabilidades conhecidas, que contém informações sobre falhas de segurança já documentadas em várias bibliotecas populares.

Identificação de Vulnerabilidades:

Após realizar a análise, o Snyk identifica vulnerabilidades conhecidas nas dependências do projeto. Ele pode detectar problemas como:
- CVE (Common Vulnerabilities and Exposures): O Snyk utiliza bancos de dados de CVEs para identificar falhas já publicadas na segurança de software.
- Vulnerabilidades específicas de pacotes: O Snyk não se limita apenas a problemas CVE, ele também verifica por falhas específicas em pacotes e versões populares.
O Snyk também considera vulnerabilidades em tempo de execução e problemas relacionados a permissões de pacotes, garantindo que não haja riscos durante a execução do software.

Recomendações de Correção:

Para cada vulnerabilidade detectada, o Snyk fornece recomendações claras de como corrigi-las. Isso pode incluir:
- Atualizar para uma versão segura da dependência.
- Substituir uma dependência vulnerável por uma alternativa mais segura.
- Aplicar patches (em alguns casos, se disponível).

Pre-commit

O Pre-commit é uma ferramenta que configura verificações de qualidade de código e vulnerabilidades antes de um commit ser feito e publicar um código no repositório. Sua vantagem consiste em configuração simplificada e mitigação de riscos ao apontar falhas e problemas no seu código antes mesmo dele ser publicado.

Abaixo, veja como configurar o Pre-commit e realizar as verificações de qualidade e segurança no código:

Pré-requisitos:

Para utilizar a ferramenta, é necessário ter:

Git instalado no ambiente
Uma conta no Github
Recomendamos também a utilização de um projeto Python para inicializar um repositório Git e checar os recursos do pre-commit.

Projeto de exemplo

Você pode utilizar o projeto de exemplo que disponibilizamos clicando aqui

Setup do Pre-commit

Inicialmente, o Pre-commit pode ser instalado no seu ambiente como um pacote Python. Execute o comando abaixo no seu terminal:

Inicialize o git na pasta raíz do seu projeto:

git init

A seguir, iremos configurar o arquivo e ativar o pre-commit:

Configuração das verificações executadas no pre-commit:

Iremos indicar as verificações a serem feitas no código a partir de um arquivo chamado .pre-commit-config.yaml

Crie este arquivo na pasta-raíz de seu projeto, e em seguida, iremos configurar as seguintes verificações no arquivo:

Checagem de espaços em branco desnecessários
Checagem da ordem dos imports seguindo as práticas recomendadas do PEP
Indicador de linhas de código fora do padrão de formatação Python
Verificações de formatação de código com ruff
Checagem de código vulnerável com bandit

O arquivo configurado ficará assim:

repos:
-   repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.5.0
    hooks:
    -   id: trailing-whitespace
    -   id: end-of-file-fixer
    -   id: check-yaml
-   repo: https://github.com/pycqa/isort
    rev: 5.13.2
    hooks:
    -   id: isort
-   repo: https://github.com/pycqa/flake8
    rev: 7.0.0
    hooks:
    -   id: flake8


- repo: https://github.com/astral-sh/ruff-pre-commit
  rev: v0.15.2
  hooks:
    - id: ruff-check
      args: [ --fix ]
    - id: ruff-format

-   repo: https://github.com/pycqa/bandit
    rev: 1.7.7
    hooks:
    -   id: bandit
        args: [ "-ll" ]
        files: .py$

Entendendo o arquivo .pre-commit-config.yaml

Este arquivo é a "receita" que o pre-commit utiliza para garantir que o seu código siga padrões de qualidade e segurança antes mesmo de ser enviado ao repositório (Git).

Aqui está o que cada parte faz:

1. pre-commit-hooks (Ferramentas de Limpeza Básica)

trailing-whitespace: Remove automaticamente espaços em branco inúteis no final das linhas de texto.
end-of-file-fixer: Garante que todos os arquivos terminem com uma linha vazia (padrão de sistemas Unix para evitar problemas de leitura de arquivos).
check-yaml: Verifica se a sintaxe de todos os arquivos .yaml ou .yml do projeto está correta.

2. isort (Organização de Importações)

isort: Organiza os seus imports no Python de forma alfabética e separada por seções (bibliotecas padrão, bibliotecas de terceiros e módulos locais). Isso evita bagunça no topo do código.

3. flake8 (Guia de Estilo e Erros)

flake8: É um linter que verifica se o seu código segue a PEP 8 (o manual de estilo do Python). Ele aponta variáveis não utilizadas, linhas muito longas e outros erros de formatação.

4. Ruff

Como vimos anteriormente, O Ruff é o responsável por ser um linter e formatter do seu projeto, conferindo adequamento do seu projeto aos padrões da Linguagem Python.

O Ruff será configurado da seguinte forma:

a. Rodando o ruff como linter e habilitando os ajustes automáticos com a flag --fix:

- id: ruff-check
    args: [ --fix ]

b. Executando o formatador para corrigir problemas de formatação com o - id: ruff-format

5. Bandit (Análise de Segurança)

Este é um ponto crítico para projetos profissionais e de IA:

bandit: Faz uma análise estática focada em segurança.
- args: [ "-ll" ]: Configura o Bandit para reportar apenas problemas de nível de severidade Médio e Alto (ignorando os Baixos para evitar ruído).
- files: .py$: Garante que o Bandit analise especificamente arquivos com extensão .py.

Por que isso é importante?

Ao rodar o git commit, o pre-commit executará todas essas ferramentas. Se o Bandit encontrar uma vulnerabilidade ou o Flake8 encontrar um erro de estilo, o commit será bloqueado, forçando você a corrigir o problema antes de seguir adiante.

Aplicando verificações na prática com pre-commit:

Com o arquivo .pre-commit-config.yaml devidamente configurado, iremos testar e acompanhar as verificações retornadas pelo pre-commit:

Siga estes passos para instalar e ativar os hooks no seu repositório local.

Passo 1: Instalação da Ferramenta

Instale a ferramenta no seu ambiente virtual (é crucial instalá-la no seu venv ou conda).

# Garanta que seu ambiente virtual esteja ativo
pip install pre-commit

Passo 2: Configuração e Download dos Hooks

Certifique-se de que o arquivo .pre-commit-config.yaml (gerado acima) esteja na raiz do seu projeto.

Ao rodar este comando, o pre-commit lê o arquivo YAML e baixa todas as ferramentas (black, isort, etc.) para o ambiente de cache local:

pre-commit install

Você deve ver uma mensagem de sucesso como: pre-commit installed at .git/hooks/pre-commit.

Passo 3: Uso e Teste

O pre-commit agora está ativo. Não é necessário fazer mais nada; ele será acionado automaticamente em cada git commit.

Faça uma alteração de teste: Deixe um import fora de ordem ou insira um espaço em branco no final de uma linha.

Adicione e Comite:

git add .
git commit -m "feat: configurando pre-commit"

O que vai acontecer no commit?

Se houver correção automática (Black/isort): O pre-commit corrigirá o arquivo e o commit falhará com uma mensagem dizendo: Files were modified by the hooks. Re-run commit..
- Você deve rodar git add . novamente (para incluir as correções) e, em seguida, git commit de novo.
Se houver erro de linting (Flake8): O commit falhará e você verá a linha exata do erro. Você deve corrigir o código manualmente, e realizar a tualização do código no git novamente.