Dominando Scripts com Bash, CMD e PowerShell do zero

Por que você PRECISA aprender a fazer scripts

Se você quer trabalhar com tecnologia - seja como desenvolvedor, sysadmin, ou especialmente na área de segurança - saber criar scripts é obrigatório. Não é opcional. Não é “bom ter”. É necessário.

Pensa comigo: você vai fazer a mesma tarefa manualmente 50 vezes, ou vai escrever um script uma vez e deixar o computador fazer pra você? A resposta é óbvia, mas a quantidade de gente que não sabe automatizar tarefas básicas é assustadora.

E na área de segurança então… cara, é impossível trabalhar sem isso. Red team precisa de scripts pra automatizar reconhecimento, exploração, pós-exploração. Blue team precisa de scripts pra monitoramento, análise de logs, resposta a incidentes. Pentesters precisam de scripts pra praticamente tudo. Até CTFs ficam muito mais fáceis quando você sabe scriptiar.

Esse documento é pra te ensinar o básico do básico de três tipos de script: Shell Script (Bash) pra Linux, Batch (.bat) e PowerShell pra Windows. Não vou fingir que vai te transformar em expert - isso leva tempo e prática. Mas vai te dar a base pra você começar a automatizar coisas e parar de fazer trabalho repetitivo manualmente.

Entendendo os Sistemas Operacionais

Antes de falar de scripts, precisa entender onde eles rodam.

UNIX: O avô de (quase) tudo

Antes de falar de Linux, precisa entender o UNIX. Ele é tipo o avô dos sistemas operacionais modernos - foi criado nos anos 70 nos laboratórios Bell da AT&T e influenciou praticamente tudo que veio depois.

UNIX trouxe conceitos que a gente usa até hoje: a ideia de que “tudo é arquivo” (até dispositivos de hardware são representados como arquivos), o sistema de permissões (rwx), pipes pra conectar comandos, e a filosofia de fazer programas pequenos que fazem uma coisa bem feita e podem ser combinados.

MacOS é baseado em UNIX (mais especificamente no BSD, uma variante). Linux foi inspirado no UNIX mas reescrito do zero. Solaris, AIX, HP-UX - todos são UNIXes ou derivados. Quando você aprende a usar o terminal em qualquer um desses, o conhecimento transfere pros outros porque a base é a mesma.

Por isso quando eu falo “sistemas Unix-like” ou “ambientes UNIX”, tô me referindo a essa família toda que compartilha a mesma filosofia e comandos similares.

Linux em 30 segundos

Linux é um sistema operacional baseado em Unix (Unix-like), open source, usado em servidores do mundo inteiro. Quando você acessa um site, tem uma chance enorme de que o servidor rodando aquele site é Linux. A maioria das ferramentas de hacking roda em Linux. Kali, Parrot, BlackArch - todas são distribuições Linux. Chamamos distribuições o sistema operacional como um todo, visto que tecnicamente Linux é apenas o Kernel (núcleo do sistema).

A interface de linha de comando do Linux (UNIX) é chamada de terminal ou shell. O shell mais comum é o Bash (Bourne Again Shell), apesar de termos outras opções, como zshell por exemplo. Quando você abre o terminal e digita comandos, é o Bash interpretando e executando.

Windows em 30 segundos

Windows domina desktops e é muito usado em ambientes corporativos. Tem duas interfaces de linha de comando principais:

CMD (Prompt de Comando): O antigo, limitado, mas ainda presente em todo Windows. Scripts são arquivos .bat ou .cmd.

PowerShell: O moderno, poderoso, baseado em objetos. Scripts são arquivos .ps1. É muito mais capaz que o CMD e tá se tornando o padrão.

Por que saber os dois?

Porque o mundo real usa os dois. Você vai encontrar servidores Linux e máquinas Windows no mesmo ambiente. Saber navegar e automatizar em ambos te torna muito mais útil e versátil.

E na área de segurança: alvos podem ser qualquer sistema. Você precisa estar confortável em ambos, e estar confortável digo ao menos saber um pouco de cada, navegar entre as pastas, deletar arquivos, criar arquivos, listar diretórios, etc.

Shell Script (Bash) - Linux

O que é e por que importa

Shell Script é basicamente uma lista de comandos que você escreveria no terminal, salvos num arquivo pra executar de uma vez. Simples assim.

Se você sabe usar o terminal Linux, você já sabe 80% do que precisa pra fazer scripts. O resto é aprender estruturas de controle (if, for, while) e algumas sintaxes específicas.

Criando seu primeiro script

Abre um editor de texto (pode ser nano, vim, ou qualquer um) e cria um arquivo. A convenção é usar extensão .sh, mas tecnicamente não é obrigatório.

#!/bin/bash
# Meu primeiro script
echo "Fala, mundo!"

Vamos entender linha por linha:

#!/bin/bash - Isso é o shebang (sim, esse é o nome). Diz pro sistema qual interpretador você quer usar para executar o script. Sem isso, teoricamente o sistema não saberia que é pra usar o Bash.

# Meu primeiro script - Comentário. Tudo depois do # é ignorado. Use pra documentar seu código.

echo "Fala, mundo!" - O comando echo imprime texto na tela. É o equivalente ao print de outras linguagens.

Executando o script

Salva o arquivo como primeiro.sh. Agora você precisa dar permissão de execução:

chmod +x primeiro.sh

O chmod +x adiciona permissão de execução ao arquivo. Sem isso, o Linux não deixa rodar.

Agora executa:

./primeiro.sh

O ./ indica “execute o arquivo que tá nesse diretório”. Sem isso, o sistema vai procurar o comando nos diretórios do PATH e não vai achar.

Variáveis

Variáveis guardam valores pra você usar depois. Em Bash, você cria assim:

#!/bin/bash
nome="Matheus"
idade=25

echo "Meu nome é $nome"
echo "Tenho $idade anos"

Importante: NÃO coloque espaços ao redor do =. nome = "Matheus" dá erro. Tem que ser nome="Matheus".

Pra usar a variável, coloca $ na frente do nome.

Recebendo input do usuário

#!/bin/bash
echo "Qual seu nome?"
read nome
echo "Fala, $nome!"

O comando read espera o usuário digitar algo e guarda na variável especificada.

Argumentos de linha de comando

Você pode passar informações pro script quando executa ele:

#!/bin/bash
echo "Primeiro argumento: $1"
echo "Segundo argumento: $2"
echo "Todos os argumentos: $@"
echo "Quantidade de argumentos: $#"

Se você rodar ./script.sh banana maçã, vai imprimir:

Primeiro argumento: banana
Segundo argumento: maçã
Todos os argumentos: banana maçã
Quantidade de argumentos: 2

Isso é muito útil pra criar ferramentas que recebem parâmetros.

Condicionais (if/else)

#!/bin/bash
echo "Digite um número:"
read numero

if [ $numero -gt 10 ]; then
    echo "Maior que 10"
elif [ $numero -eq 10 ]; then
    echo "Igual a 10"
else
    echo "Menor que 10"
fi

Sintaxe importante:

• [ ] - Os colchetes são o comando de teste. Precisa de espaço depois de [ e antes de ]
• -gt - Greater than (maior que)
• -lt - Less than (menor que)
• -eq - Equal (igual)
• -ne - Not equal (diferente)
• -ge - Greater or equal (maior ou igual)
• -le - Less or equal (menor ou igual)
• then - Vem depois da condição
• fi - Fecha o if (é “if” ao contrário)

Testes de arquivo (muito útil):

• -f arquivo - Verdadeiro se arquivo existe e é arquivo regular
• -d diretorio - Verdadeiro se diretório existe
• -e caminho - Verdadeiro se existe (arquivo ou diretório)
• -r arquivo - Verdadeiro se arquivo é legível
• -w arquivo - Verdadeiro se arquivo é gravável
• -x arquivo - Verdadeiro se arquivo é executável
• -s arquivo - Verdadeiro se arquivo existe e não está vazio

Exemplo prático:

#!/bin/bash
if [ -f "/etc/passwd" ]; then
    echo "Arquivo passwd existe!"
fi

if [ -d "$HOME/Downloads" ]; then
    echo "Pasta Downloads existe!"
fi

Pra comparar strings:

if [ "$nome" = "Matheus" ]; then
    echo "Opa, xará!"
fi

Dica: Sempre coloque variáveis entre aspas duplas em comparações. Se a variável estiver vazia, sem aspas dá erro de sintaxe.

Condicionais (case)

Quando você tem muitas opções pra comparar, usar vários elif fica feio e difícil de ler. Pra isso existe o case, que é tipo o switch de outras linguagens:

#!/bin/bash
echo "Escolha uma opção:"
echo "1) Listar arquivos"
echo "2) Ver data"
echo "3) Ver usuário atual"
read opcao

case $opcao in
    1)
        ls -la
        ;;
    2)
        date
        ;;
    3)
        whoami
        ;;
    *)
        echo "Opção inválida!"
        ;;
esac

Sintaxe importante:

• case $variavel in - Começa o case
• padrão) - O padrão a ser comparado, seguido de )
• ;; - Termina cada bloco (equivalente ao break de outras linguagens)
• *) - O padrão “default”, pega tudo que não bateu com nenhum outro
• esac - Fecha o case (é “case” ao contrário, igual fi pro if)

Você pode combinar múltiplos padrões com |:

#!/bin/bash
echo "Digite s para sim ou n para não:"
read resposta

case $resposta in
    s | S | sim | SIM | Sim)
        echo "Você disse sim!"
        ;;
    n | N | nao | NAO | Nao)
        echo "Você disse não!"
        ;;
    *)
        echo "Não entendi..."
        ;;
esac

O case também aceita wildcards. Por exemplo, *.txt) bateria com qualquer string terminada em .txt. É muito útil pra fazer menus interativos ou parsear argumentos de linha de comando.

Loops

For loop - iterando numa lista:

#!/bin/bash
for fruta in banana maçã laranja; do
    echo "Eu gosto de $fruta"
done

For loop - iterando em arquivos:

#!/bin/bash
for arquivo in *.txt; do
    echo "Encontrei: $arquivo"
done

For loop - estilo C (com números):

#!/bin/bash
for ((i=1; i<=5; i++)); do
    echo "Número: $i"
done

While loop:

#!/bin/bash
contador=1
while [ $contador -le 5 ]; do
    echo "Contagem: $contador"
    ((contador++))
done

Funções

Funções permitem reutilizar código. Em vez de copiar e colar o mesmo bloco várias vezes, você define uma função e chama ela quando precisar:

#!/bin/bash

# Definindo uma função
saudar() {
    echo "Olá, $1!"
}

# Chamando a função
saudar "Matheus"
saudar "Maria"

O $1 dentro da função é o primeiro argumento passado pra ela (não confunde com os argumentos do script - dentro da função, $1, $2, etc. são os argumentos da função).

Funções podem retornar valores com return, mas só números de 0-255 (código de saída). Pra retornar strings ou outros valores, use echo e capture com $(...):

#!/bin/bash

somar() {
    local resultado=$(( $1 + $2 ))
    echo $resultado
}

# Captura o resultado
total=$(somar 5 3)
echo "5 + 3 = $total"

O local declara uma variável que só existe dentro da função. Sem ele, a variável seria global e poderia bagunçar outras partes do script.

Exemplo prático: Scanner de portas básico

Vamos fazer algo útil - um scanner de portas simples:

#!/bin/bash

if [ -z "$1" ]; then
    echo "Uso: $0 <ip>"
    exit 1
fi

alvo=$1

echo "Escaneando portas em $alvo..."

for porta in 21 22 23 25 80 443 445 3306 3389 8080; do
    timeout 1 bash -c "echo >/dev/tcp/$alvo/$porta" 2>/dev/null && echo "Porta $porta: ABERTA"
done

echo "Scan finalizado!"

Esse script:

1. Verifica se você passou um IP como argumento (-z testa se a string tá vazia)
2. Itera por uma lista de portas comuns
3. Tenta conectar em cada uma usando o recurso /dev/tcp do Bash
4. Se conectar (timeout de 1 segundo), mostra que tá aberta

Salva como scanner.sh, dá chmod +x scanner.sh, e roda com ./scanner.sh 192.168.1.1.

Exemplo prático: Backup automatizado

#!/bin/bash

# Configurações
origem="/home/usuario/documentos"
destino="/home/usuario/backups"
data=$(date +%Y-%m-%d_%H-%M-%S)
arquivo_backup="backup_$data.tar.gz"

# Cria pasta de destino se não existir
mkdir -p "$destino"

# Faz o backup
echo "Iniciando backup..."
tar -czf "$destino/$arquivo_backup" "$origem"

if [ $? -eq 0 ]; then
    echo "Backup criado com sucesso: $arquivo_backup"
else
    echo "Erro ao criar backup!"
    exit 1
fi

# Remove backups com mais de 7 dias
find "$destino" -name "backup_*.tar.gz" -mtime +7 -delete
echo "Backups antigos removidos."

O $? contém o código de saída do último comando. Se for 0, deu certo.

Batch Script (CMD) - Windows

O velho guerreiro

Batch é antigo. Tipo, muito antigo. Vem desde o MS-DOS. É limitado comparado com Bash ou PowerShell, mas ainda funciona em qualquer Windows e às vezes é tudo que você tem disponível.

Scripts Batch são arquivos .bat ou .cmd.

Primeiro script Batch

Abre o Bloco de Notas e escreve:

@echo off
echo Fala, mundo!
pause

Salva como primeiro.bat e dá dois cliques pra executar.

@echo off - Desliga a exibição dos comandos enquanto executam. Sem isso, cada linha do script aparece na tela antes de executar.

echo - Imprime texto, igual no Bash.

pause - Espera o usuário apertar uma tecla. Útil pra janela não fechar imediatamente.

Variáveis

@echo off
set nome=Matheus
set idade=25

echo Meu nome é %nome%
echo Tenho %idade% anos
pause

Em Batch, variáveis são definidas com set e acessadas com %nome% (porcentagem dos dois lados).

Recebendo input

@echo off
set /p nome=Qual seu nome? 
echo Fala, %nome%!
pause

O /p no set faz ele esperar input do usuário.

Argumentos de linha de comando

@echo off
echo Primeiro argumento: %1
echo Segundo argumento: %2
echo Todos: %*
pause

Funciona parecido com Bash: %1, %2, etc.

Condicionais

@echo off
set /p numero=Digite um numero: 

if %numero% GTR 10 (
    echo Maior que 10
) else if %numero% EQU 10 (
    echo Igual a 10
) else (
    echo Menor que 10
)
pause

Operadores de comparação em Batch:

• EQU - Igual
• NEQ - Diferente
• GTR - Maior que
• LSS - Menor que
• GEQ - Maior ou igual
• LEQ - Menor ou igual

Loops

For com lista:

@echo off
for %%f in (banana maca laranja) do (
    echo Eu gosto de %%f
)
pause

Importante: Dentro de scripts Batch, a variável do for usa %%. No prompt direto, usa só %.

For com números:

@echo off
for /L %%i in (1,1,5) do (
    echo Numero: %%i
)
pause

O /L indica loop numérico. (1,1,5) significa: começa em 1, incrementa 1, vai até 5.

For em arquivos:

@echo off
for %%f in (*.txt) do (
    echo Encontrei: %%f
)
pause

Exemplo prático: Limpeza de arquivos temporários

@echo off
echo Limpando arquivos temporarios...

del /q /s %TEMP%\*.tmp 2>nul
del /q /s %TEMP%\*.log 2>nul

echo Limpeza concluida!
pause

O 2>nul redireciona erros pro nada (ignora erros de arquivos que não existem).

PowerShell - O poder do Windows moderno

Por que PowerShell é diferente

PowerShell não é só uma evolução do CMD - é uma coisa completamente diferente. Enquanto Bash e CMD trabalham com texto, PowerShell trabalha com objetos.

Quando você executa um comando no PowerShell, ele não retorna texto - retorna objetos com propriedades e métodos. Isso é muito mais poderoso pra manipular dados.

Primeiro script PowerShell

Abre o ISE (PowerShell Integrated Scripting Environment) ou qualquer editor e escreve:

Write-Host "Fala, mundo!"

Salva como primeiro.ps1.

Antes de executar: PowerShell tem políticas de execução de scripts por segurança. Você pode precisar rodar isso primeiro (como administrador):

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Isso permite executar scripts locais. Sem isso, o Windows bloqueia por padrão.

Pra executar:

.\primeiro.ps1

Variáveis

$nome = "Matheus"
$idade = 25

Write-Host "Meu nome é $nome"
Write-Host "Tenho $idade anos"

Em PowerShell, variáveis começam com $. Mais intuitivo que Batch, né?

Recebendo input

$nome = Read-Host "Qual seu nome?"
Write-Host "Fala, $nome!"

Argumentos

param(
    [string]$Argumento1,
    [string]$Argumento2
)

Write-Host "Primeiro: $Argumento1"
Write-Host "Segundo: $Argumento2"

Roda com: .\script.ps1 -Argumento1 "valor1" -Argumento2 "valor2"

PowerShell permite parâmetros nomeados, o que é muito mais legível que argumentos posicionais.

Condicionais

$numero = Read-Host "Digite um número"
$numero = [int]$numero  # Converte pra inteiro

if ($numero -gt 10) {
    Write-Host "Maior que 10"
} elseif ($numero -eq 10) {
    Write-Host "Igual a 10"
} else {
    Write-Host "Menor que 10"
}

Operadores de comparação em PowerShell:

• -eq - Igual
• -ne - Diferente
• -gt - Maior que
• -lt - Menor que
• -ge - Maior ou igual
• -le - Menor ou igual

Switch (o case do PowerShell)

PowerShell tem o switch, equivalente ao case do Bash:

$opcao = Read-Host "Escolha: 1-Listar, 2-Data, 3-Usuário"

switch ($opcao) {
    1 { Get-ChildItem }
    2 { Get-Date }
    3 { whoami }
    default { Write-Host "Opção inválida!" }
}

Você pode comparar strings e até usar wildcards:

$resposta = Read-Host "Sim ou Não?"

switch -Wildcard ($resposta) {
    "s*" { Write-Host "Você disse sim!" }
    "n*" { Write-Host "Você disse não!" }
    default { Write-Host "Não entendi..." }
}

O -Wildcard permite usar * e ? como curingas. Também existe -Regex pra usar expressões regulares.

Loops

ForEach:

$frutas = @("banana", "maçã", "laranja")

foreach ($fruta in $frutas) {
    Write-Host "Eu gosto de $fruta"
}

For clássico:

for ($i = 1; $i -le 5; $i++) {
    Write-Host "Número: $i"
}

While:

$contador = 1
while ($contador -le 5) {
    Write-Host "Contagem: $contador"
    $contador++
}

O poder dos objetos

Aqui é onde PowerShell brilha. Olha isso:

# Lista processos e pega só os que usam mais de 100MB de memória
Get-Process | Where-Object { $_.WorkingSet64 -gt 100MB } | Select-Object Name, @{N='Memória(MB)';E={[math]::Round($_.WorkingSet64/1MB,2)}}

Isso seria muito mais complicado em Bash ou Batch porque você teria que parsear texto.

Exemplo prático: Informações do sistema

Write-Host "=== INFORMAÇÕES DO SISTEMA ===" -ForegroundColor Cyan

$os = Get-CimInstance Win32_OperatingSystem
$cpu = Get-CimInstance Win32_Processor
$memoria = Get-CimInstance Win32_PhysicalMemory | Measure-Object -Property Capacity -Sum

Write-Host "`nSistema Operacional: $($os.Caption)"
Write-Host "Versão: $($os.Version)"
Write-Host "Arquitetura: $($os.OSArchitecture)"
Write-Host "`nProcessador: $($cpu.Name)"
Write-Host "Núcleos: $($cpu.NumberOfCores)"
Write-Host "`nMemória Total: $([math]::Round($memoria.Sum/1GB, 2)) GB"

$disco = Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3"
Write-Host "`nDiscos:"
foreach ($d in $disco) {
    $livre = [math]::Round($d.FreeSpace/1GB, 2)
    $total = [math]::Round($d.Size/1GB, 2)
    Write-Host "  $($d.DeviceID) - $livre GB livres de $total GB"
}

Exemplo prático: Scanner de rede local

param(
    [string]$Rede = "192.168.1"
)

Write-Host "Escaneando rede $Rede.0/24..." -ForegroundColor Yellow

$jobs = @()

1..254 | ForEach-Object {
    $ip = "$Rede.$_"
    $jobs += Start-Job -ScriptBlock {
        param($ip)
        $ping = Test-Connection -ComputerName $ip -Count 1 -Quiet -TimeoutSeconds 1
        if ($ping) { $ip }
    } -ArgumentList $ip
}

$resultados = $jobs | Wait-Job | Receive-Job
$jobs | Remove-Job

Write-Host "`nHosts ativos:" -ForegroundColor Green
$resultados | ForEach-Object { Write-Host "  $_" }
Write-Host "`nTotal: $($resultados.Count) hosts encontrados"

Esse script usa jobs paralelos pra escanear mais rápido. PowerShell é poderoso assim.

Comparativo rápido

Recurso	Bash	Batch	PowerShell
Variável	var="valor"	set var=valor	$var = "valor"
Usar variável	$var	%var%	$var
Comentário	# texto	REM texto ou :: texto	# texto
If	if [ ]; then fi	if () else ()	if () {} else {}
Case/Switch	case in esac	N/A (só if encadeado)	switch () {}
For	for x in lista; do done	for %%x in () do ()	foreach ($x in $lista) {}
While	while [ ]; do done	N/A (goto/label)	while () {}
Função	nome() { }	:nome (label)	function Nome {}
Ler input	read var	set /p var=	Read-Host
Imprimir	echo	echo	Write-Host
Testar arquivo	[ -f arq ]	if exist arq	Test-Path arq

Scripting e a área de segurança

Cara, se você quer trampar com segurança da informação, scripting não é “ah, seria legal saber” - é requisito mesmo. E olha, não tô falando só de shell script não. Quando você domina a lógica de automação, você consegue aplicar em Bash, Python, JavaScript, PowerShell… a linguagem muda mas o raciocínio é o mesmo.

Pensa num pentest: você precisa enumerar hosts, portas, serviços, usuários de uma rede com centenas de máquinas. “Ah, mas o nmap faz isso” - faz, mas e quando você precisa de algo específico que nenhuma ferramenta pronta resolve? Ou quando precisa integrar o resultado do nmap com outra ferramenta automaticamente? Aí você precisa saber scriptar. Quanto mais você depende só de ferramenta de terceiro, mais limitado você fica. Tenta fazer sua própria ferramenta pelo menos uma vez, nem que seja um port scanner básico igual o exemplo que mostrei ali em cima - você vai aprender muito mais do que só rodando nmap.

Outro exemplo mais do dia a dia: imagina que você precisa verificar se os backups estão sendo feitos corretamente. Dá pra criar um script que roda todo dia, verifica a data de modificação dos arquivos de backup, e se tiver desatualizado, dispara o backup automaticamente ou te manda um alerta. Em vez de você ficar checando isso manualmente toda semana, o script faz por você. Isso é automação de verdade.

E quando você baixa um exploit pronto e ele não funciona direto no seu alvo? Precisa adaptar, mudar parâmetros, às vezes encadear várias etapas. Sem saber pelo menos ler e modificar código, você tá na mão. E isso vale pra qualquer linguagem - Bash pra automação de sistema, Python pra exploits e ferramentas, PowerShell pra ambientes Windows.

Falando em Windows, PowerShell é o queridinho em pós-exploração. Conseguiu acesso numa máquina Windows? PowerShell tá lá, instalado por padrão, super poderoso. Por isso você vê tanto PowerShell em relatórios de incidente e análises de malware. Blue team também precisa conhecer pra entender o que tá acontecendo nos logs.

E por falar em logs… já tentou procurar um indicador de comprometimento em gigabytes de log no olho? Pois é. Grep, awk, um script em Python com regex - isso que vai te salvar.

Em CTF então nem se fala. Muitos desafios esperam que você automatize algo. O cara que sabe scriptar resolve em 5 minutos o que outro fica 2 horas tentando fazer na mão.

E não pensa que é só pra red team não. Blue team precisa automatizar monitoramento e resposta a incidente. DevSecOps precisa integrar segurança em pipeline de CI/CD. SysAdmin precisa automatizar hardening, provisionamento, tudo. Não tem como fugir disso.

Antes de ir embora

Umas dicas rápidas: começa pequeno, não tenta fazer um mega script logo de cara. Pega uma tarefa chata que você faz todo dia e automatiza ela. Lê código dos outros no GitHub, copia, adapta, melhora - é assim que a gente aprende.

Você vai errar… vai esquecer alguma coisa… vai fazer loop infinito… vai deletar coisa errada… Faz parte. Cada erro, por mais bizarro que for, te ensina algo que você nunca esquece.

Ninguém decora sintaxe de tudo - “bash como fazer for em arquivos” vai ser sua pesquisa mais frequente no início, e tá tudo bem.

Comenta seu código porque você daqui 6 meses não vai lembrar o que aquela linha faz, confia em mim. Ah e pelo amor, testa em ambiente controlado antes de rodar em produção, principalmente script que deleta coisa. Não queira aprender isso da pior forma possível.

---

Scripting parece intimidador no início mas depois vira segunda natureza. A primeira vez que você automatizar algo chato que levava meia hora e resolver em 2 segundos, você vai entender. Escolhe uma linguagem pra começar - Bash se você usa Linux, PowerShell se usa Windows - fica confortável nela, e depois expande quando precisar.

O computador é muito bom em fazer tarefa repetitiva. Você não. Deixa o trabalho chato pra máquina e usa seu cérebro pra coisa mais interessante.