DeepSeek Harness: Programação Defensiva e Revisão de…

// ❌ API Key hardcoded
const apiKey = 'sk-abc123def456'

// ❌ API Key escrita em logs
ctx.logger.info(`connecting with key: ${apiKey}`)

// ❌ API Key na URL
const url = `https://api.example.com?key=${apiKey}`

// ❌ API Key na mensagem de erro
throw new Error(`Authentication failed for key: ${apiKey}`)

// ✅ Ler da configuração
export const Config = Schema.object({
  apiKey: Schema.string().required().hidden()
})

export function apply(ctx: Context) {
  const apiKey = ctx.config.apiKey
  // apiKey usada apenas dentro de apply, não vazada externamente
}

// ✅ Usar variáveis de ambiente
const apiKey = process.env.MY_PLUGIN_API_KEY

// ✅ Passar via header da requisição (não na URL)
const response = await fetch(url, {
  headers: { 'Authorization': `Bearer ${apiKey}` }
})

// ✅ Ocultar informações sensíveis em logs
ctx.logger.info(`connecting to ${endpoint}`)  // Não logar a key

// ✅ Filtro de log personalizado
function sanitize(obj: any): any {
  const sanitized = { ...obj }
  if (sanitized.apiKey) sanitized.apiKey = '***'
  if (sanitized.authorization) sanitized.authorization = '***'
  return sanitized
}

ctx.logger.info('request:', sanitize(request))

export const Config = Schema.object({
  apiKey: Schema.string().required().hidden(),
  keyRotationDays: Schema.number().default(90)
})

export function apply(ctx: Context) {
  ctx.setInterval(() => {
    const age = getKeyAge()
    if (age > ctx.config.keyRotationDays * 86400000) {
      ctx.logger.warn('API key is overdue for rotation')
    }
  }, 86400000)
}

// ❌ Não validar resultados de tools
async execute({ path }, ctx) {
  const result = await ctx.shell.execute(`ls ${path}`)
  return result.stdout  // Pode estar vazio ou malformado
}

// ✅ Validar resultados de tools
async execute({ path }, ctx) {
  const result = await ctx.shell.execute(`ls ${path}`)
  
  if (result.exitCode !== 0) {
    return {
      error: true,
      message: `ls failed: ${result.stderr}`,
      exitCode: result.exitCode
    }
  }
  
  if (!result.stdout || result.stdout.trim().length === 0) {
    return {
      error: true,
      message: 'Directory is empty or does not exist'
    }
  }
  
  const files = result.stdout.trim().split('\n')
  return { count: files.length, files }
}

// ❌ Não validar respostas de API
const data = await response.json()
return data.result

// ✅ Validar respostas de API
async function callAPI(ctx: Context, endpoint: string): Promise<any> {
  const response = await fetch(endpoint)
  
  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${response.statusText}`)
  }
  
  let data: any
  try {
    data = await response.json()
  } catch {
    throw new Error('API returned invalid JSON')
  }
  
  if (!data || typeof data !== 'object') {
    throw new Error('API returned unexpected format')
  }
  
  return data
}

// ❌ Não validar entrada do usuário
async execute({ command }, ctx) {
  return await ctx.shell.execute(command)  // Risco de injeção de comando
}

// ✅ Validar e sanitizar entrada
async execute({ command }, ctx) {
  if (!command || typeof command !== 'string') {
    return { error: true, message: 'Invalid command' }
  }
  
  if (command.length > 1000) {
    return { error: true, message: 'Command too long' }
  }
  
  // Verificação de whitelist
  const allowed = ['ls', 'cat', 'grep', 'wc', 'head', 'tail']
  const baseCommand = command.split(' ')[0]
  if (!allowed.includes(baseCommand)) {
    return { error: true, message: `Command not allowed: ${baseCommand}` }
  }
  
  return await ctx.shell.execute(command)
}

export function apply(ctx: Context) {
  // Todos os recursos que precisam de limpeza
  const resources: { close: () => void | Promise<void> }[] = []

  // Registrar limpeza imediatamente ao adquirir recurso
  function acquireResource<T extends { close: () => void | Promise<void> }>(
    resource: T
  ): T {
    resources.push(resource)
    return resource
  }

  // Limpeza unificada
  ctx.effect(() => {
    return async () => {
      for (const r of resources.reverse()) {
        try {
          await r.close()
        } catch (e) {
          ctx.logger.warn('cleanup error:', e)
        }
      }
    }
  })

  // Uso
  const db = acquireResource(openDatabase())
  const ws = acquireResource(new WebSocket('ws://localhost:8080'))
}

export function apply(ctx: Context) {
  const tempFiles: string[] = []

  ctx.effect(() => {
    return async () => {
      for (const file of tempFiles.reverse()) {
        try {
          await ctx.fs.unlink(file)
        } catch {}
      }
    }
  })

  async function createTempFile(content: string): Promise<string> {
    const path = `/tmp/dsh-${Date.now()}-${Math.random().toString(36).slice(2)}`
    await ctx.fs.writeFile(path, content)
    tempFiles.push(path)
    return path
  }
}

Princípio 1: Minimizar efeitos colaterais
  → Executar apenas operações necessárias
  → Preferir somente leitura, depois escritas idempotentes

Princípio 2: Efeitos colaterais devem ser reversíveis
  → Salvar estado original antes de escrever
  → Fornecer operações de desfazer

Princípio 3: Efeitos colaterais devem ser auditáveis
  → Registrar detalhes de cada efeito colateral
  → Usuários podem visualizar histórico de operações

Princípio 4: Efeitos colaterais requerem aprovação
  → Operações destrutivas devem ser aprovadas
  → Operações não idempotentes devem ser aprovadas

interface ReversibleAction {
  execute(): Promise<void>
  rollback(): Promise<void>
}

class FileEditAction implements ReversibleAction {
  private originalContent: string | null = null

  constructor(
    private path: string,
    private newContent: string,
    private ctx: Context
  ) {}

  async execute() {
    try {
      this.originalContent = await this.ctx.fs.readFile(this.path)
    } catch {
      this.originalContent = null
    }
    await this.ctx.fs.writeFile(this.path, this.newContent)
  }

  async rollback() {
    if (this.originalContent !== null) {
      await this.ctx.fs.writeFile(this.path, this.originalContent)
    } else {
      await this.ctx.fs.unlink(this.path)
    }
  }
}

const auditLog: AuditEntry[] = []

function audit(action: string, details: any, reversible: boolean) {
  auditLog.push({
    timestamp: Date.now(),
    action,
    details,
    reversible,
    user: 'agent'
  })
  ctx.emit('audit/action', { action, details, reversible })
}

// Uso
audit('file_edit', { path: 'src/app.ts', operation: 'edit' }, true)
audit('email_send', { to: 'alice@example.com' }, false)

# Revisão de Incidente: [Título]

## Informações Básicas
- Data: YYYY-MM-DD
- Impacto: [Funcionalidades/usuários afetados]
- Severidade: P0/P1/P2
- Responsável: [Nome]

## Linha do Tempo
- HH:MM — [Evento 1]
- HH:MM — [Evento 2]
- HH:MM — [Correção]

## Análise de Causa Raiz
[Análise dos 5 Porquês]

## Correção
- Curto prazo: [Correção imediata]
- Longo prazo: [Medida preventiva]

## Lições Aprendidas
- [Lição 1]
- [Lição 2]

Incidente: Agent excluiu arquivos de projeto do usuário

Porquê 1: Agent executou rm -rf /project
  → Porque a tool não tinha validação de caminho

Porquê 2: A tool não tinha validação de caminho
  → Porque o desenvolvedor não implementou verificação de whitelist

Porquê 3: O desenvolvedor não implementou verificação de whitelist
  → Porque não havia um processo de revisão de segurança

Porquê 4: Não havia um processo de revisão de segurança
  → Porque a equipe não havia estabelecido um checklist de segurança

Porquê 5: A equipe não havia estabelecido um checklist de segurança
  → Por causa de treinamento insuficiente em conscientização de segurança

Correção: Estabelecer um checklist de auditoria de segurança; todos os plugins devem ser verificados antes da publicação

# Executar auditoria de segurança
dsh audit my-plugin

# Saída
🔒 Security Audit: my-plugin

✅ No hardcoded credentials
✅ All ctx.effect() have cleanup functions
⚠️ Tool 'db_query' has no input validation
❌ API response not validated in 'fetch_data'
✅ Approval policy configured for destructive operations
⚠️ Permission 'shell.execute' may not be necessary

2 errors, 2 warnings found. Fix before publishing.