A Importância dos Lockfiles para a Segurança da Cadeia de Suprimentos

Lockfiles desempenham um papel vital na segurança da cadeia de suprimentos de software através de um gerenciamento consistente de dependências. Eles especificam as versões exatas das dependências utilizadas, garantindo a reprodutibilidade e evitando mudanças inesperadas.

Num ambiente de desenvolvimento acelerado, repleto de bibliotecas de código aberto e pacotes de terceiros, os ficheiros de bloqueio atuam como uma defesa contra ataques à Supply chain. Ao bloquear dependências em versões específicas, eles impedem atualizações automáticas para versões potencialmente comprometidas.

Muitas equipes de desenvolvimento ignoram os lockfiles, falhando em utilizar todo o seu potencial. Este artigo destaca a importância dos lockfiles para garantir a integridade e segurança de projetos de software.

Entendendo os Lockfiles

Lockfiles são arquivos que registram as versões exatas de cada dependência e suas sub-dependências em um projeto. Eles garantem a uniformidade nas versões das dependências em todas as instâncias de um projeto, prevenindo o "dependency hell" e potenciais riscos de segurança.

Arquivos de lock são diferentes para cada linguagem e podem variar dependendo dos frameworks, mas geralmente seguem formatos semelhantes.

Javascript - yarn.lock

lodash@^4.17.15:
  version "4.17.21"
  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#acfcd7438b5d260f06a1d052c2a3b32ddc91c6b8"
  integrity sha512-v2kDE6syb5rK+X8bykjh3W7n4P3NV8axFypa8DwO8DK+RVZk9vft6xEhjxzIlc6DCwCPkMKSk4eQF6QNHOu9pw==

react@^17.0.1:
  version "17.0.2"
  resolved "https://registry.yarnpkg.com/react/-/react-17.0.2.tgz#cdc8d94b0d7091f440c51d1427ff2a3d6e14e664"
  integrity sha512-y8vQ43+qMOpbD/3k1Vw4E4i4UgFqxMwI0AZc5fxyIfZK4kHRZ5Klg5zh/5Nq1Nk3JZqf6byFAkyoGZkbSnYt9w==

Python - poetry.lock

[[package]]
name = "requests"
version = "2.25.1"
description = "Python HTTP for Humans."
category = "main"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4"

[package.dependencies]
certifi = ">=2017.4.17"
chardet = ">=3.0.2,<5"
idna = ">=2.5,<3"
urllib3 = ">=1.21.1,<1.27"

Esta entrada especifica o nome do pacote (click), os hashes aceitos e a versão exata (8.0.3). Tal especificidade garante instalações consistentes em ambientes de desenvolvimento, teste e produção.

Gerenciadores de pacotes geram lockfiles durante a instalação ou atualização de dependências. É essencial commitar esses arquivos para o controle de versão junto com o código-fonte do projeto. Essa prática garante que todos os colaboradores do projeto utilizem dependências idênticas, reduzindo inconsistências e tornando as builds mais previsíveis.

Diferentes linguagens e gerenciadores de pacotes possuem seus próprios formatos de lockfile: Node.js utiliza package-lock.json para npm, Python utiliza Pipfile.lock para Pipenv, e Ruby utiliza Gemfile.lock para Bundler. O uso de lockfiles ajuda a manter uma base de projeto consistente e segura, reduzindo os riscos associados ao gerenciamento de dependências.

Defesa contra ataques à Supply chain

ataques à Supply chain dependências de código aberto estão se tornando cada vez mais comuns. Os invasores podem comprometer uma biblioteca popular, injetando código malicioso que se espalha para projetos dependentes. Os arquivos de bloqueio fornecem uma defesa forte contra esses ataques.

Ao especificar versões exatas de dependências, os lockfiles previnem atualizações automáticas para versões potencialmente comprometidas. Isso é crucial quando vulnerabilidades são identificadas em dependências. Com os lockfiles, os projetos permanecem estáveis com versões seguras conhecidas até que a equipe decida atualizar após testes completos.

Abaixo está um exemplo de um package-lock.json arquivo usado em projetos Node.js para fixar versões específicas de dependências. Isso garante que todos que trabalham no projeto instalem exatamente as mesmas versões, promovendo consistência e segurança.

{
  "name": "my-project",
  "version": "1.0.0",
  "lockfileVersion": 2,
  "requires": true,
  "packages": {
    "": {
      "name": "my-project",
      "version": "1.0.0",
      "dependencies": {
        "lodash": "4.17.21",
        "axios": "0.21.1"
      }
    },
    "node_modules/lodash": {
      "version": "4.17.21",
      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
      "integrity": "sha512-v2kDE6syb5rK+X8bykjh3W7n4P3NV8axFypa8DwO8DK+RVZk9vft6xEhjxzIlc6DCwCPkMKSk4eQF6QNHOu9pw=="
    },
    "node_modules/axios": {
      "version": "0.21.1",
      "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.1.tgz",
      "integrity": "sha512-pbkHfFgC6F4ltGeoyTeHRtUkZo/FZ9EoElV3MzDLeO2uYxLqGm6Qcbx93jUOJISyYSC/tzjK4NHH3MAYsDKUTA==",
      "dependencies": {
        "follow-redirects": "^1.10.0"
      }
    },
    "node_modules/follow-redirects": {
      "version": "1.14.1",
      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz",
      "integrity": "sha512-0gh4nEbdUdDra9mJKpAB+Y4gG61sQiKsbiqS8c5LEnFOh8fbov3/xp0FnWE2+IxKTozhJSdEV8ujvQjU+Ub3dg=="
    }
  },
  "dependencies": {
    "lodash": {
      "version": "4.17.21",
      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
      "integrity": "sha512-v2kDE6syb5rK+X8bykjh3W7n4P3NV8axFypa8DwO8DK+RVZk9vft6xEhjxzIlc6DCwCPkMKSk4eQF6QNHOu9pw=="
    },
    "axios": {
      "version": "0.21.1",
      "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.1.tgz",
      "integrity": "sha512-pbkHfFgC6F4ltGeoyTeHRtUkZo/FZ9EoElV3MzDLeO2uYxLqGm6Qcbx93jUOJISyYSC/tzjK4NHH3MAYsDKUTA==",
      "requires": {
        "follow-redirects": "^1.10.0"
      }
    },
    "follow-redirects": {
      "version": "1.14.1",
      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz",
      "integrity": "sha512-0gh4nEbdUdDra9mJKpAB+Y4gG61sQiKsbiqS8c5LEnFOh8fbov3/xp0FnWE2+IxKTozhJSdEV8ujvQjU+Ub3dg=="
    }
  }
}

O que Este Arquivo Faz

• Bloqueia Versões Específicas:
  Ele trava lodash na versão 4.17.21 e axios em 0.21.1. Não importa quando ou onde você instalar este projeto, estas versões exatas serão usadas—evitando atualizações acidentais para versões que possam conter breaking changes ou problemas de segurança.
• Captura Árvore de Dependências:
  Inclui dependências aninhadas, como seguir redirecionamentos, que é usado internamente por axios.
• Suporta Ferramentas de Segurança:
  Ferramentas como Aikido Use este lockfile para escanear vulnerabilidades conhecidas. Como o arquivo contém URLs resolvidas e hashes de versão, os scanners podem:
  • Identificar pacotes de risco com precisão.
  • Recomenda alternativas corrigidas ou seguras.
  • Rastrear alterações nas dependências ao longo do tempo.

Riscos de Ignorar Lockfiles

Negligenciar lockfiles pode desestabilizar e comprometer projetos de software. Sem lockfiles, as versões das dependências podem variar entre os ambientes, levando a inconsistências que complicam a depuração. Essas variações podem causar bugs difíceis de rastrear, atrasando projetos e aumentando os encargos de manutenção.

Sem um lockfile, o rastreamento de dependências se torna desafiador. A ausência de um registro claro dificulta a determinação de quais versões são usadas, complicando o gerenciamento da cadeia de suprimentos. No caso de uma vulnerabilidade, os desenvolvedores têm dificuldade em identificar dependências de risco rapidamente, atrasando os tempos de resposta.

Atualizações automáticas representam riscos significativos quando os lockfiles estão ausentes. Atualizações descontroladas podem introduzir pacotes comprometidos, expondo projetos a violações de segurança. Mesmo bibliotecas renomadas podem abrigar ameaças ocultas, tornando a supervisão de lockfiles crucial para manter uma base de código segura.

Melhores Práticas para Usar Lockfiles

Integre os lockfiles em seu fluxo de trabalho de desenvolvimento para se beneficiar totalmente deles. Incluir lockfiles no controle de versão estabelece uma única fonte de verdade para as dependências, promovendo um ambiente de desenvolvimento consistente. Essa abordagem reduz variações indesejadas e aumenta a confiabilidade da produção.

Atualizar e rever regularmente os ficheiros de bloqueio é vital para detecção de ameaças precoce detecção de ameaças. Esta estratégia proativa ajuda as equipas a resolver vulnerabilidades rapidamente, mantendo uma postura de segurança forte. Utilize ferramentas para avaliação contínua de dependências para automatizar a deteção de riscos na cadeia de fornecimento de software.

Ancorar dependências a versões específicas em arquivos de manifesto adiciona segurança. Essa prática complementa os lockfiles e serve como uma rede de segurança em caso de discrepâncias. Educar as equipes de desenvolvimento sobre a importância dos lockfiles reforça o gerenciamento diligente de dependências, aprimorando a segurança geral.

Mantendo as Dependências Atualizadas com Lockfiles

Manter as dependências atualizadas requer a combinação de automação com uma revisão minuciosa. Atualizações rotineiras de lockfile devem fazer parte dos ciclos de desenvolvimento, incorporando as últimas melhorias e correções de segurança, ao mesmo tempo em que preservam a consistência. Atualizações regulares minimizam interrupções inesperadas e fortalecem a segurança.

Ferramentas automatizadas como Dependabot gerir atualizações, gerando pull requests para novas versões de dependências. Essas ferramentas fornecem monitoramento contínuo, permitindo atualizações oportunas e possibilitando que as equipas se concentrem em outras tarefas. No entanto, é crucial revisar as alterações para garantir que elas atendam às necessidades do projeto e evitar problemas.

Desenvolver um processo manual de atualização de lockfile também é essencial. Implante dependências atualizadas em um ambiente de teste para avaliar o impacto e a compatibilidade. Essa abordagem previne interrupções e mantém a coerência, minimizando riscos de mudanças frequentes de versão.

Incorporar ficheiros de bloqueio ao seu processo de desenvolvimento fortalece a sua cadeia de fornecimento de software contra ameaças de segurança em constante evolução. Adotar as melhores práticas e promover a consciência sobre dependências dentro da sua equipa são fundamentais para manter uma base de código robusta. Pronto para melhorar a segurança da sua cadeia de fornecimento? Comece gratuitamente com Aikido e simplifique a sua jornada de segurança.