Guia Completo de Markdown

Este guia apresenta todos os elementos de formatação Markdown suportados, com exemplos práticos para cada um. Isso que estou fazendo é um texte

Formatação de Texto

O Markdown oferece diversas formas de formatar texto:

Sintaxe	Resultado
`negrito`	negrito
`itálico`	itálico
`*negrito e itálico*`	negrito e itálico
`~~riscado~~`	~~riscado~~
`código inline`	`código inline`

Texto Subscrito e Sobrescrito

H~2~O (subscrito)
X^2^ (sobrescrito)

Teclas de Atalho

Para copiar, use Ctrl + C. Para colar, use Ctrl + V.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_BUFFER 256

typedef struct {
    char nome[50];
    int idade;
    float salario;
} Funcionario;

void exibir_funcionario(Funcionario *f) {
    printf("Nome: %s\n", f->nome);
    printf("Idade: %d\n", f->idade);
    printf("Salário: R$ %.2f\n", f->salario);
}

int main(int argc, char *argv[]) {
    Funcionario func;
    
    // Inicializa o funcionário
    strcpy(func.nome, "Luan Santos");
    func.idade = 25;
    func.salario = 8500.00;
    
    printf("=== Dados do Funcionário ===\n");
    exibir_funcionario(&func);
    
    // Alocação dinâmica
    Funcionario *ptr = (Funcionario *)malloc(sizeof(Funcionario));
    if (ptr == NULL) {
        fprintf(stderr, "Erro: falha na alocação de memória\n");
        return 1;
    }
    
    strcpy(ptr->nome, "Maria Silva");
    ptr->idade = 30;
    ptr->salario = 9200.50;
    
    printf("\n=== Segundo Funcionário ===\n");
    exibir_funcionario(ptr);
    
    free(ptr);
    return 0;
}

Cabeçalhos

Os cabeçalhos são criados com #. Quanto mais #, menor o nível:

# Título 1
## Título 2
### Título 3
#### Título 4
##### Título 5
###### Título 6

Parágrafos e Quebras de Linha

Para criar um novo parágrafo, deixe uma linha em branco entre os textos.

Para quebrar linha sem novo parágrafo,
adicione dois espaços no final da linha.

Citações (Blockquotes)

“A simplicidade é a sofisticação suprema.”
— Leonardo da Vinci

Citações Aninhadas

Primeiro nível de citação
Segundo nível de citação
Terceiro nível de citação

Citação com Formatação

Dica Importante
Você pode usar negrito, itálico e código dentro de citações.
Item 1
Item 2

Listas

Lista Não Ordenada

Primeiro item
Segundo item
- Sub-item 2.1
- Sub-item 2.2
  - Sub-sub-item 2.2.1
Terceiro item

Lista Ordenada

Primeiro passo
Segundo passo
Terceiro passo
1. Sub-passo 3.1
2. Sub-passo 3.2

Lista de Tarefas

Tarefa concluída
Outra tarefa concluída
Tarefa pendente
Mais uma tarefa pendente

Lista de Definições

Termo 1: Definição do termo 1
Termo 2: Definição do termo 2; Segunda definição do termo 2

Imagens

Imagem com URL Externa

Imagem com Legenda

Imagem de exemplo
Uma imagem aleatória do Lorem Picsum

Imagem com Tamanho Definido

Código

Código Inline

Use console.log() para debug em JavaScript ou print() em Python.

Bloco de Código Simples

Texto sem highlighting
Pode ser usado para logs ou output

Python

#!/usr/bin/env python3
"""
Exemplo de código Python com classes e async.
"""
from dataclasses import dataclass, field
from typing import List, Optional
import asyncio


@dataclass
class Investigacao:
    """Representa uma investigação digital."""
    
    id: str
    titulo: str
    descricao: Optional[str] = None
    evidencias: List[str] = field(default_factory=list)
    status: str = "pendente"
    
    def adicionar_evidencia(self, evidencia: str) -> None:
        """Adiciona uma nova evidência à investigação."""
        self.evidencias.append(evidencia)
        print(f"[+] Evidência adicionada: {evidencia}")
    
    async def analisar(self) -> dict:
        """Executa análise assíncrona."""
        await asyncio.sleep(1)  # Simula processamento
        return {
            "id": self.id,
            "total_evidencias": len(self.evidencias),
            "status": "concluída"
        }


async def main():
    # Criando investigação
    inv = Investigacao(
        id="INV-2026-001",
        titulo="Análise de Logs",
        descricao="Investigação de acesso não autorizado"
    )
    
    # Adicionando evidências
    inv.adicionar_evidencia("auth.log")
    inv.adicionar_evidencia("access.log")
    inv.adicionar_evidencia("syslog")
    
    # Executando análise
    resultado = await inv.analisar()
    print(f"\nResultado: {resultado}")


if __name__ == "__main__":
    asyncio.run(main())

JavaScript / TypeScript

interface User {
  id: string;
  name: string;
  email: string;
  createdAt: Date;
}

class AuthService {
  private users: Map<string, User> = new Map();

  async authenticate(email: string, password: string): Promise<User | null> {
    // Simula autenticação
    const user = Array.from(this.users.values())
      .find(u => u.email === email);
    
    if (!user) {
      console.error(`[AUTH] Usuário não encontrado: ${email}`);
      return null;
    }

    console.log(`[AUTH] Login bem-sucedido: ${user.name}`);
    return user;
  }

  createUser(name: string, email: string): User {
    const user: User = {
      id: crypto.randomUUID(),
      name,
      email,
      createdAt: new Date()
    };
    
    this.users.set(user.id, user);
    return user;
  }
}

// Uso
const auth = new AuthService();
const user = auth.createUser("Luan Santos", "luan@exemplo.com");
console.log("Usuário criado:", user);

Bash / Shell

#!/bin/bash
#
# Script de coleta de evidências forenses
# Autor: Luan Santos
#

set -euo pipefail

# Variáveis
DATA_DIR="/forensics/coleta_$(date +%Y%m%d_%H%M%S)"
LOG_FILE="${DATA_DIR}/coleta.log"

# Cores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

log() {
    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')]${NC} $1" | tee -a "$LOG_FILE"
}

error() {
    echo -e "${RED}[ERRO]${NC} $1" >&2
    exit 1
}

# Criar diretório de coleta
mkdir -p "$DATA_DIR" || error "Falha ao criar diretório"
log "Iniciando coleta em: $DATA_DIR"

# Coletar informações do sistema
log "Coletando informações do sistema..."
uname -a > "${DATA_DIR}/uname.txt"
cat /etc/os-release > "${DATA_DIR}/os-release.txt" 2>/dev/null || true

# Coletar logs
log "Coletando logs..."
for logfile in /var/log/{auth,syslog,messages}.log; do
    if [[ -f "$logfile" ]]; then
        cp "$logfile" "${DATA_DIR}/" && log "Copiado: $logfile"
    fi
done

# Coletar conexões de rede
log "Coletando conexões de rede..."
ss -tunapl > "${DATA_DIR}/conexoes.txt" 2>/dev/null

# Finalizar
log "Coleta concluída!"
echo -e "${YELLOW}Arquivos salvos em: ${DATA_DIR}${NC}"

SQL

-- Consulta de análise de logs de acesso
WITH login_attempts AS (
    SELECT 
        user_id,
        ip_address,
        attempt_time,
        success,
        LAG(attempt_time) OVER (
            PARTITION BY user_id 
            ORDER BY attempt_time
        ) AS previous_attempt
    FROM auth_logs
    WHERE attempt_time >= CURRENT_DATE - INTERVAL '7 days'
),
suspicious_activity AS (
    SELECT 
        user_id,
        ip_address,
        COUNT(*) AS failed_attempts,
        MIN(attempt_time) AS first_attempt,
        MAX(attempt_time) AS last_attempt
    FROM login_attempts
    WHERE success = FALSE
    GROUP BY user_id, ip_address
    HAVING COUNT(*) >= 5
)
SELECT 
    u.name,
    u.email,
    s.ip_address,
    s.failed_attempts,
    s.first_attempt,
    s.last_attempt,
    EXTRACT(EPOCH FROM (s.last_attempt - s.first_attempt)) / 60 AS duration_minutes
FROM suspicious_activity s
JOIN users u ON u.id = s.user_id
ORDER BY s.failed_attempts DESC;

Go

package main

import (
	"context"
	"fmt"
	"log"
	"sync"
	"time"
)

type Scanner struct {
	targets []string
	results chan ScanResult
	wg      sync.WaitGroup
}

type ScanResult struct {
	Target   string
	Port     int
	Open     bool
	Duration time.Duration
}

func NewScanner(targets []string) *Scanner {
	return &Scanner{
		targets: targets,
		results: make(chan ScanResult, 100),
	}
}

func (s *Scanner) Scan(ctx context.Context, ports []int) <-chan ScanResult {
	for _, target := range s.targets {
		for _, port := range ports {
			s.wg.Add(1)
			go func(t string, p int) {
				defer s.wg.Done()
				
				start := time.Now()
				// Simula scan de porta
				time.Sleep(50 * time.Millisecond)
				
				s.results <- ScanResult{
					Target:   t,
					Port:     p,
					Open:     p == 80 || p == 443,
					Duration: time.Since(start),
				}
			}(target, port)
		}
	}

	go func() {
		s.wg.Wait()
		close(s.results)
	}()

	return s.results
}

func main() {
	ctx := context.Background()
	scanner := NewScanner([]string{"192.168.1.1", "192.168.1.2"})
	
	ports := []int{22, 80, 443, 8080}
	
	for result := range scanner.Scan(ctx, ports) {
		if result.Open {
			log.Printf("[OPEN] %s:%d (%v)\n", 
				result.Target, result.Port, result.Duration)
		}
	}
	
	fmt.Println("Scan concluído!")
}

YAML (Configuração)

# Configuração do servidor
server:
  host: 0.0.0.0
  port: 8080
  tls:
    enabled: true
    cert: /etc/ssl/certs/server.crt
    key: /etc/ssl/private/server.key

# Banco de dados
database:
  driver: postgres
  host: localhost
  port: 5432
  name: forensics_db
  credentials:
    username: ${DB_USER}
    password: ${DB_PASS}
  pool:
    max_connections: 20
    idle_timeout: 300s

# Logging
logging:
  level: info
  format: json
  outputs:
    - stdout
    - file:///var/log/app.log

# Features
features:
  - name: real_time_analysis
    enabled: true
  - name: auto_backup
    enabled: true
    config:
      interval: 6h
      retention: 30d

JSON

{
  "investigacao": {
    "id": "INV-2026-001",
    "titulo": "Análise de Incidente",
    "prioridade": "alta",
    "status": "em_andamento",
    "criado_em": "2026-01-18T10:30:00Z",
    "investigador": {
      "nome": "Luan Santos",
      "email": "luan@exemplo.com"
    },
    "evidencias": [
      {
        "tipo": "log",
        "arquivo": "auth.log",
        "hash_sha256": "e3b0c44298fc1c149afbf4c8996fb924..."
      },
      {
        "tipo": "imagem",
        "arquivo": "disk.dd",
        "tamanho_gb": 256
      }
    ],
    "tags": ["malware", "acesso-nao-autorizado", "exfiltracao"]
  }
}

Diff

--- a/config/settings.py
+++ b/config/settings.py
@@ -12,7 +12,9 @@ class Settings:
     DEBUG = False
     
     # Database
-    DATABASE_URL = "sqlite:///./app.db"
+    DATABASE_URL = os.getenv(
+        "DATABASE_URL", 
+        "postgresql://user:pass@localhost/db"
+    )
     
     # Security
-    SECRET_KEY = "change-me"
+    SECRET_KEY = os.getenv("SECRET_KEY")

```javascriptfunction hello(name) { console.log(`Hello, ${name}!`);}```

Tabelas

Tabela Simples

Ferramenta	Categoria	Descrição
Nmap	Scanning	Descoberta de rede e auditoria de segurança
Wireshark	Análise	Captura e análise de pacotes de rede
Volatility	Memória	Análise forense de memória RAM
Autopsy	Disco	Análise forense de discos e imagens

Tabela com Alinhamento

Esquerda	Centro	Direita
Texto	Texto	Texto
Alinhado	Alinhado	Alinhado
À esquerda	Ao centro	À direita

Tabela Complexa

Porta	Protocolo	Serviço	Status	Observação
22	TCP	SSH	✅	Acesso remoto seguro
80	TCP	HTTP	⚠️	Redireciona para HTTPS
443	TCP	HTTPS	✅	Conexão segura
3306	TCP	MySQL	❌	Bloqueado externamente
5432	TCP	PostgreSQL	❌	Apenas localhost

Linha Horizontal

Use três ou mais hífens, asteriscos ou underscores:

Notas de Rodapé

Aqui está uma frase com uma nota de rodapé¹.

Outra referência importante².

E uma nota com label personalizado³.

Emojis

Hugo suporta emojis nativamente! Alguns exemplos:

Categoria	Emojis
Expressões	😄 😆 🤔 😎
Gestos	👍 👎 👏 👋
Símbolos	✅ ❌ ⚠️ ⭐
Objetos	🚀 🔥 ⚡ 💡
Tech	💻 ⌨️ 🔒 🔑

Matemática (KaTeX)

Inline

A fórmula de Euler: $e^{i\pi} + 1 = 0$

Bloco

$$ \int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi} $$

$$ \sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6} $$

HTML Inline

Você pode usar HTML diretamente quando necessário:

Clique para expandir

Este conteúdo está oculto por padrão.

Item 1
Item 2
Item 3

print("Código dentro de details!")

Texto destacado com marcador

HTML é a linguagem de marcação da web.

Alertas / Callouts

[!NOTE] Esta é uma nota informativa.
[!TIP] Dica: Use atalhos de teclado para maior produtividade.
[!IMPORTANT] Informação importante que não deve ser ignorada.
[!WARNING] Atenção: Esta ação pode ter consequências.
[!CAUTION] Cuidado: Operação potencialmente perigosa.

Conclusão

Este guia cobriu todos os principais elementos de Markdown suportados pelo Hugo. Use-o como referência para criar conteúdo rico e bem formatado.

Para mais informações, consulte:

Esta é a primeira nota de rodapé. ↩︎
Esta é a segunda nota de rodapé com mais detalhes. ↩︎
Notas de rodapé podem ter qualquer identificador. ↩︎