0Pricing
Security+ Academy · Aula

Segurança de Dependências e Análise de Composição de Software

Audite bibliotecas de terceiros com ferramentas de SCA, imponha o versionamento fixo de dependências e integre alertas automatizados de vulnerabilidades ao fluxo de CI/CD.

Segurança de Dependências e Análise de Composição de Software é uma aula grátis de Security+ Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Security+ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Security+ Academy inclui 4 aulas no total.

O risco das dependencies de código aberto

As aplicações modernas são compostas em grande parte por bibliotecas e frameworks de código aberto de terceiros. Uma aplicação típica em Node.js pode ter mais de 1.000 dependencies transitivas; um projeto Java pode incorporar centenas de artefatos Maven. Cada dependency é uma possível superfície de ataque. A vulnerabilidade Log4Shell (CVE-2021-44228) na biblioteca Log4j demonstrou que uma única dependency poderia tornar milhões de aplicações imediatamente exploráveis em todo o mundo poucos dias após sua divulgação.

O que é a análise de composição de software?

As ferramentas de Software Composition Analysis (SCA) fazem automaticamente o inventário de todos os componentes de código aberto de uma aplicação — incluindo dependencies transitivas (as dependencies das suas dependencies) — e verificam continuamente esses componentes em bancos de dados de vulnerabilidades em busca de CVEs conhecidos. A SCA produz uma Software Bill of Materials (SBOM) que lista cada componente e sua versão, permitindo identificar rapidamente os sistemas afetados quando novas vulnerabilidades são divulgadas.

# SCA tool usage examples:

# npm audit (Node.js):
# npm audit
# -> Reports vulnerabilities in package.json dependencies
# -> Shows severity, CVE ID, affected package, fix version

# OWASP Dependency-Check (Java/Python/etc.):
# dependency-check --project 'MyApp' --scan ./lib/
# -> Generates HTML/XML report with CVE findings

# Snyk scan:
# snyk test
# -> Reports vulns + 'snyk fix' applies patches automatically

Dependencies transitivas: o risco oculto

Dependencies transitivas são bibliotecas das quais suas dependencies diretas dependem, mas que você não escolheu explicitamente. Você pode depender diretamente do Package A, que depende do Package B (versão 1.2), que depende do Package C (versão 3.0 — uma versão vulnerável). Você não tem conhecimento do Package C, mas sua aplicação o executa. As ferramentas de SCA percorrem toda a árvore de dependencies para revelar essas vulnerabilidades ocultas, que não são diretamente visíveis aos desenvolvedores.

# Dependency tree example:
# Your package.json:
#   'express': '^4.18.0'     (direct dependency)
#   'lodash':  '^4.17.21'   (direct dependency)

# Transitive dependencies (you didn't choose these):
#   express -> 'qs' 6.11.0       (URL parsing)
#   express -> 'body-parser' 1.20 -> 'qs' 6.11.0
#   lodash (self-contained in this case)

# If 'qs' 6.10.x had a prototype pollution CVE,
# you are vulnerable via express even though
# you never directly imported 'qs'.

A Software Bill of Materials (SBOM)

Uma Software Bill of Materials (SBOM) é um inventário formal e legível por máquina de todos os componentes de um produto de software — semelhante à lista de ingredientes de um alimento. Os formatos de SBOM incluem SPDX (Linux Foundation) e CycloneDX (OWASP). A Ordem Executiva 14028 (2021) dos US determinou o uso de SBOMs para softwares vendidos ao governo federal. Com uma SBOM, as equipes de segurança podem consultar imediatamente: "quais dos nossos produtos contêm Log4j?" e obter respostas em minutos, em vez de passar dias fazendo buscas manuais.

# Generate SBOM with syft:
# syft packages . -o spdx-json > sbom.spdx.json

# SBOM content example (SPDX JSON):
# {
#   'packages': [
#     { 'name': 'express',  'version': '4.18.2', 'license': 'MIT' },
#     { 'name': 'lodash',   'version': '4.17.21','license': 'MIT' },
#     { 'name': 'log4j-core','version': '2.14.0','license': 'Apache-2.0'}
#   ]
# }

# When Log4Shell announced, query SBOM:
# grep -i 'log4j-core' sbom.spdx.json -> FOUND in 3 projects

Fixação de versões de dependencies e arquivos de bloqueio

A fixação de versões de dependencies especifica versões exatas das dependencies, em vez de intervalos flexíveis (^1.2.3 ou *). Os arquivos de bloqueio (package-lock.json, yarn.lock, Pipfile.lock, Gemfile.lock) registram a versão exata resolvida de cada dependency no momento da instalação. Esses arquivos devem ser enviados ao controle de código-fonte para garantir que todos os membros da equipe e todos os pipelines de CI/CD usem versões idênticas das dependencies, evitando ataques à cadeia de suprimentos que envenenem as versões dos pacotes entre instalações.

# Version range vs pinned versions:

# FLEXIBLE (can pull different versions each install):
# 'express': '^4.0.0'   -> installs latest 4.x.x
# 'lodash': '*'         -> installs any version!

# PINNED (always same version):
# 'express': '4.18.2'   -> always exactly 4.18.2

# Lock file (package-lock.json):
# Records EXACT resolved version of every transitive dep.
# Commit this file! It ensures reproducible builds.
# Never .gitignore lock files (security anti-pattern).

Ataques à cadeia de suprimentos: typosquatting e Dependency Confusion

Os ataques à cadeia de suprimentos têm como alvo o ecossistema de dependencies. Typosquatting consiste em publicar pacotes maliciosos com nomes semelhantes aos de pacotes populares (por exemplo, lodahs em vez de lodash), na esperança de que os desenvolvedores digitem o nome incorretamente. Ataques de Dependency Confusion exploram a ordem em que os gerenciadores de pacotes pesquisam os registros — um atacante publica um pacote malicioso com o mesmo nome de um pacote privado interno, mas com um número de versão maior, fazendo o gerenciador de pacotes instalar a versão pública maliciosa.

# Dependency Confusion Attack (Alex Birsan 2021):
# Company uses internal package 'company-utils' v1.0.0
# Hosted on: internal.registry.company.com

# Attacker publishes 'company-utils' v9.9.9 to npmjs.com
# (public registry with higher version number)

# npm install resolves: 'find highest version across ALL registries'
# -> Installs v9.9.9 from public npm (attacker's malicious package!)
# -> Instead of v1.0.0 from internal registry

# Defense: use namespace scoping (@company/utils)
# or configure npm to ONLY use internal registry for private packages

Ferramentas de SCA disponíveis no mercado

Várias ferramentas de SCA são amplamente usadas no setor. A Snyk fornece verificação de dependencies voltada para desenvolvedores, com solicitações de pull automáticas para correção. O OWASP Dependency-Check é uma ferramenta gratuita e amplamente adotada para Java, .NET, Python e Ruby. O GitHub Dependabot abre automaticamente solicitações de pull para atualizar dependencies vulneráveis em repositórios do GitHub. O JFrog Xray e o Sonatype Nexus IQ integram a SCA aos repositórios de artefatos para impedir que compilações vulneráveis cheguem à produção.

Integração da SCA aos pipelines de CI/CD

A SCA é mais eficaz quando integrada como um gate de qualidade no pipeline de CI/CD. A cada solicitação de pull e compilação, o pipeline executa a ferramenta de SCA e interrompe a compilação se forem encontrados CVEs de severidade crítica ou alta nas dependencies. Essa abordagem de "shift left" detecta dependencies vulneráveis antes que cheguem à produção — e não meses depois, durante uma revisão manual de segurança ou após uma violação. As equipes devem definir limites claros de severidade de vulnerabilidades para determinar quais bloqueiam a implantação e quais geram apenas avisos.

# GitHub Actions SCA pipeline step:
# - name: Run Snyk SCA scan
#   uses: snyk/actions/node@master
#   env:
#     SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
#   with:
#     args: --severity-threshold=high
#             --fail-on=upgradable
# # Build fails if any HIGH or CRITICAL vuln found
# # that has an available fix (--fail-on=upgradable)
# # No fix available? Generates warning, doesn't block
# # (acknowledging risk explicitly is better than blocking forever)

Avaliação da saúde de pacotes de código aberto

Antes de adicionar uma dependency, avalie sua postura de segurança usando vários indicadores. Atividade de manutenção: o projeto é mantido ativamente? Quando ocorreu o último commit e lançamento? Histórico de vulnerabilidades conhecidas: quantos CVEs ele teve e com que rapidez foram corrigidos? Volume de downloads: pacotes amplamente usados atraem mais atenção de segurança. Quantidade de dependencies: pacotes com menos dependencies introduzem menos riscos transitivos. O OpenSSF Scorecard fornece uma pontuação automatizada das práticas de segurança de projetos de código aberto.

Estratégias de correção de vulnerabilidades

Quando a SCA identifica uma dependency vulnerável, existem várias estratégias de correção. Atualizar para uma versão corrigida — a opção preferencial quando disponível. A aplicação de correções virtuais por meio de regras do WAF pode reduzir o risco de caminhos de exploração conhecidos enquanto uma atualização é preparada. Remover a dependency se ela não for mais necessária. Aceitar o risco, com justificativa documentada, se a vulnerabilidade não for explorável no contexto específico de uso (por exemplo, uma vulnerabilidade do lado do servidor em uma biblioteca do lado do cliente). Nunca deixe vulnerabilidades críticas sem tratamento e sem uma aceitação documentada.

Conformidade de licenças em dependencies

As ferramentas de SCA têm uma finalidade dupla: identificam vulnerabilidades de segurança e sinalizam problemas de conformidade de licenças em dependencies de código aberto. Entre as licenças problemáticas comuns estão a GPL v2/v3 (copyleft — exige que seu produto também seja disponibilizado como código aberto se você o distribuir), a AGPL (estende a GPL aos serviços de rede) e a SSPL. Usar uma biblioteca licenciada sob a GPL em um software comercial proprietário sem uma licença comercial pode gerar sérias responsabilidades jurídicas. Ferramentas de SCA como FOSSA, Black Duck e WhiteSource automatizam a verificação de licenças juntamente com a detecção de vulnerabilidades, garantindo a conformidade com as obrigações relativas ao código aberto.

# License compliance risk levels:
# PERMISSIVE (low risk for commercial use):
#   MIT, Apache 2.0, BSD 2/3-Clause
#   -> Can use in proprietary code, just keep attribution

# WEAK COPYLEFT (medium risk - check usage):
#   LGPL -> can link dynamically without open-sourcing your code
#   MPL 2.0 -> modifications to MPL files must be open-sourced

# STRONG COPYLEFT (high risk for proprietary products):
#   GPL v2, GPL v3 -> if you distribute code using GPL library,
#                     your entire product must also be GPL
#   AGPL -> extends GPL to SaaS/network services

# SCA policy: block AGPL/GPL in commercial product
# -> Review any exception requests manually

Verificação rápida

Teste sua compreensão dos conceitos do CompTIA Security+ (SY0-701) apresentados nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que: as ferramentas de SCA analisam toda a árvore de dependencies, incluindo as dependencies transitivas, em busca de CVEs conhecidos; as SBOMs fornecem um inventário legível por máquina, permitindo uma resposta rápida quando novas vulnerabilidades são divulgadas; e a integração da SCA como um gate de qualidade de CI/CD detecta dependencies vulneráveis antes que cheguem à produção. A seguir, exploraremos o DevSecOps e como deslocar os controles de segurança para o início de todo o pipeline de CI/CD.

Perguntas Frequentes

A aula “Segurança de Dependências e Análise de Composição de Software” é grátis?

Sim — o texto completo de “Segurança de Dependências e Análise de Composição de Software” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Security+ Academy, atualize para CoddyKit PRO. O curso de Security+ Academy inclui 4 aulas no total.

O que vou aprender em “Segurança de Dependências e Análise de Composição de Software”?

Audite bibliotecas de terceiros com ferramentas de SCA, imponha o versionamento fixo de dependências e integre alertas automatizados de vulnerabilidades ao fluxo de CI/CD. Você pratica Security+ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Security+ Academy?

Nenhuma experiência prévia é necessária. Security+ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Segurança de Dependências e Análise de Composição de Software”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Security+ Academy?

Sim. Cada aula de Security+ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Validação de Entrada e Codificação de Saída
  2. Gerenciamento Seguro de Segredos e Variáveis de Ambiente
  3. Segurança de Dependências e Análise de Composição de Software
  4. DevSecOps: Antecipando a Segurança nos Fluxos
← Voltar para Security+ Academy