Lab 17 — Upload sem passar pela aplicação

// O que /api/laudos/assinatura devolve ao navegador. Repare no que NÃO está
// aqui: nenhum byte do arquivo, nenhuma credencial de longa duração — só uma
// política que o navegador reproduz de volta ao fazer o POST ao S3.
{
  "url": "https://ffv-lab-laudos-quarentena.s3.sa-east-1.amazonaws.com/",
  "campos": {
    "key": "lojas/lj_0231/laudos/2026/6f1a9e2c8b0d4a3e.pdf",
    "policy": "eyJleHBpcmF0aW9uIjoiMjAyNi0wOC0wN1QxNTozMjowMFoiLCJjb25kaXRpb25zIjpb...",
    "x-amz-algorithm": "AWS4-HMAC-SHA256",
    "x-amz-credential": "ASIAEXAMPLE.../20260807/sa-east-1/s3/aws4_request",
    "x-amz-date": "20260807T151700Z",
    "x-amz-signature": "6d6c9e1f...",
    "x-amz-meta-loja-id": "lj_0231",
    "x-amz-security-token": "IQoJb3JpZ2luX2VjEA...(token da task role)"
  },
  // O que o navegador NÃO recebe e não precisa saber: o teto de 220 MB está
  // DENTRO de "policy" (base64), assinado — mexer nele invalida "x-amz-signature".
  "validoAte": "2026-08-07T15:32:00Z"
}

# buckets.tf — quarentena, publicado, CORS, e o ciclo de vida que paga a
# multipart abandonada se ninguem configurar isto

resource "aws_kms_key" "laudos" {
  description         = "Cifra os buckets de laudos da Cadencia"
  enable_key_rotation = true
}

resource "aws_s3_bucket" "quarentena" {
  bucket = "${var.projeto}-laudos-quarentena"
}

resource "aws_s3_bucket_public_access_block" "quarentena" {
  bucket                  = aws_s3_bucket.quarentena.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

resource "aws_s3_bucket_server_side_encryption_configuration" "quarentena" {
  bucket = aws_s3_bucket.quarentena.id
  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm     = "aws:kms"
      kms_master_key_id = aws_kms_key.laudos.arn
    }
  }
}

# CORS e' o que faz o NAVEGADOR aceitar ler a resposta de um host diferente do
# seu. Sem isto, o formulario nao "falha bonito": o upload pode ate ter sido
# aceito pelo S3, e o navegador ainda assim reporta erro de rede generico —
# e' a seccao de seguranca que detalha por que o sintoma engana tanto.
resource "aws_s3_bucket_cors_configuration" "quarentena" {
  bucket = aws_s3_bucket.quarentena.id
  cors_rule {
    allowed_methods = ["POST", "PUT"]
    allowed_origins = ["https://${var.dominio}"] # o mesmo dominio resolvido no L05; nunca "*"
    allowed_headers = ["*"]
    expose_headers  = ["ETag"] # sem isto o JS nao le o ETag da resposta do S3
    max_age_seconds = 3000
  }
}

resource "aws_s3_bucket_lifecycle_configuration" "quarentena" {
  bucket = aws_s3_bucket.quarentena.id

  rule {
    id     = "aborta-multipart-incompleto"
    status = "Enabled"
    # Uma parte enviada e nunca concluida (aba fechada, rede caiu na loja)
    # continua ocupando armazenamento e sendo cobrada — o S3 NAO a apaga
    # sozinho. E' o achado de custo mais caro deste laboratorio, e sem esta
    # regra ele nasce sem protecao nenhuma.
    abort_incomplete_multipart_upload {
      days_after_initiation = 1
    }
  }

  rule {
    id     = "remove-quarentena-orfa"
    status = "Enabled"
    # Se o verificador falhar em laco e a mensagem esgotar as tentativas ate
    # a DLQ, o objeto fica em quarentena sem veredito para sempre. Este prazo
    # e' o backstop de TEMPO; a DLQ e' o backstop de ALARME — sao proteccoes
    # diferentes, e a tabela de seguranca cobre as duas.
    expiration {
      days = 3
    }
  }
}

resource "aws_s3_bucket" "publicado" {
  bucket = "${var.projeto}-laudos-publicados"
}

resource "aws_s3_bucket_public_access_block" "publicado" {
  bucket                  = aws_s3_bucket.publicado.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

resource "aws_s3_bucket_server_side_encryption_configuration" "publicado" {
  bucket = aws_s3_bucket.publicado.id
  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm     = "aws:kms"
      kms_master_key_id = aws_kms_key.laudos.arn
    }
  }
}

# O bucket publicado tambem recebe multipart em tese (copia grande do
# verificador), entao a mesma protecao de custo se aplica aqui.
resource "aws_s3_bucket_lifecycle_configuration" "publicado" {
  bucket = aws_s3_bucket.publicado.id
  rule {
    id     = "aborta-multipart-incompleto"
    status = "Enabled"
    abort_incomplete_multipart_upload {
      days_after_initiation = 1
    }
  }
}

# eventos.tf — o gatilho que desacopla o S3 de quem consome

resource "aws_s3_bucket_notification" "quarentena_para_eventbridge" {
  bucket      = aws_s3_bucket.quarentena.id
  eventbridge = true # delega ao EventBridge em vez de assinar SNS/SQS direto na notificacao
}

resource "aws_cloudwatch_event_rule" "laudo_criado" {
  name = "${var.projeto}-laudo-criado"
  event_pattern = jsonencode({
    source        = ["aws.s3"]
    detail-type   = ["Object Created"]
    detail = {
      bucket = { name = [aws_s3_bucket.quarentena.id] }
      object = { key = [{ prefix = "lojas/" }] }
    }
  })
}

resource "aws_cloudwatch_event_target" "para_fila" {
  rule = aws_cloudwatch_event_rule.laudo_criado.name
  arn  = aws_sqs_queue.verificacao.arn
}

resource "aws_sqs_queue" "verificacao_dlq" {
  name                      = "${var.projeto}-laudos-verificacao-dlq"
  message_retention_seconds = 1209600 # 14 dias — tempo de sobra para investigar antes de perder o evento
}

resource "aws_sqs_queue" "verificacao" {
  name = "${var.projeto}-laudos-verificacao"
  # >= tempo que o worker leva para ler o cabecalho, rodar o antivirus e
  # copiar. Curto demais reentrega a MESMA mensagem enquanto ainda esta sendo
  # processada, e dois workers competem pelo mesmo laudo.
  visibility_timeout_seconds = 120

  redrive_policy = jsonencode({
    deadLetterTargetArn = aws_sqs_queue.verificacao_dlq.arn
    maxReceiveCount      = 5
  })
}

resource "aws_sqs_queue_policy" "permite_eventbridge" {
  queue_url = aws_sqs_queue.verificacao.id
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [{
      Effect    = "Allow"
      Principal = { Service = "events.amazonaws.com" }
      Action    = "sqs:SendMessage"
      Resource  = aws_sqs_queue.verificacao.arn
      Condition = {
        ArnEquals = { "aws:SourceArn" = aws_cloudwatch_event_rule.laudo_criado.arn }
      }
    }]
  })
}

# O alarme que fecha o laco: mensagem parada na DLQ e' um laudo que ninguem
# vai processar sozinho. Sem isto, a fila 3 desta seccao vira um cemiterio
# silencioso.
resource "aws_cloudwatch_metric_alarm" "dlq_com_mensagem" {
  alarm_name          = "${var.projeto}-laudos-dlq-com-mensagem"
  namespace           = "AWS/SQS"
  metric_name         = "ApproximateNumberOfMessagesVisible"
  statistic           = "Maximum"
  period              = 300
  evaluation_periods  = 1
  threshold           = 0
  comparison_operator = "GreaterThanThreshold"
  dimensions          = { QueueName = aws_sqs_queue.verificacao_dlq.name }
  alarm_actions       = [aws_sns_topic.alertas.arn]
}

# iam.tf — dois papeis, dois raciocinios de menor privilegio

# A API SO PRECISA poder assinar o que a propria credencial autoriza — porque
# a assinatura HERDA exatamente essa permissao (e' o que a documentacao de
# presigned URL confirma: "limited by the permissions of the user who
# creates it"). Escopar ao prefixo "lojas/" e' o que garante que um bug na
# aplicacao que esqueca o `starts-with` na politica nao alcance o bucket
# inteiro — so alcancaria a arvore de prefixos que a IAM ja autoriza.
data "aws_iam_policy_document" "api_assina" {
  statement {
    effect    = "Allow"
    actions   = ["s3:PutObject"]
    resources = ["${aws_s3_bucket.quarentena.arn}/lojas/*"]
  }
  statement {
    effect    = "Allow"
    actions   = ["dynamodb:GetItem", "dynamodb:Query"]
    resources = [aws_dynamodb_table.laudos.arn, "${aws_dynamodb_table.laudos.arn}/index/*"]
  }
}

resource "aws_iam_role_policy" "api_assina" {
  role   = aws_iam_role.api_task.id
  policy = data.aws_iam_policy_document.api_assina.json
}

# O verificador le e apaga da quarentena, escreve no publicado, consome a
# fila e grava o veredito. Nenhuma dessas quatro acoes precisa da OUTRA
# permissao — e' a mesma logica de execution role vs task role do L03,
# aplicada a um segundo servico com responsabilidade diferente.
data "aws_iam_policy_document" "worker_verifica" {
  statement {
    effect    = "Allow"
    actions   = ["s3:GetObject", "s3:DeleteObject"]
    resources = ["${aws_s3_bucket.quarentena.arn}/*"]
  }
  statement {
    effect    = "Allow"
    actions   = ["s3:PutObject"]
    resources = ["${aws_s3_bucket.publicado.arn}/*"]
  }
  statement {
    effect    = "Allow"
    actions   = ["sqs:ReceiveMessage", "sqs:DeleteMessage", "sqs:GetQueueAttributes"]
    resources = [aws_sqs_queue.verificacao.arn]
  }
  statement {
    effect    = "Allow"
    actions   = ["dynamodb:PutItem", "dynamodb:UpdateItem"]
    resources = [aws_dynamodb_table.laudos.arn]
  }
  statement {
    effect    = "Allow"
    actions   = ["kms:Decrypt", "kms:GenerateDataKey"]
    resources = [aws_kms_key.laudos.arn]
  }
}

resource "aws_iam_role_policy" "worker_verifica" {
  role   = aws_iam_role.worker_task.id
  policy = data.aws_iam_policy_document.worker_verifica.json
}

// AssinadorPostS3.cs — a API decide e assina; nunca ve o corpo do arquivo

using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using Amazon.Runtime;

namespace Cadencia.Api.Laudos;

public sealed record PostAssinado(string Url, Dictionary<string, string> Campos, DateTimeOffset ValidoAte);

public sealed class AssinadorPostS3
{
    // 220 MiB: o laudo declarado nunca passa de 200 MB, e a folga cobre o
    // overhead do multipart/form-data (campos, boundary) sem abrir mao do
    // teto. O numero vem da hipotese declarada na abertura do modulo — se a
    // sua maior peca do laudo mudar (por exemplo, video em resolucao maior),
    // este valor tem de ser revisado, nao herdado.
    public const long TamanhoMaximoLaudoBytes = 230_686_720;
    private const long TamanhoMinimoBytes = 1024; // barra so o POST vazio ou de teste

    private readonly string _bucket;
    private readonly string _regiao;

    public AssinadorPostS3(string bucket, string regiao) => (_bucket, _regiao) = (bucket, regiao);

    // O SDK da AWS para .NET NAO tem um `generate_presigned_post` pronto
    // como o boto3 tem em Python — por isso a cadeia de HMAC abaixo e'
    // montada a mao, seguindo o MESMO processo de assinatura que qualquer
    // requisicao SigV4 usa. Aqui o "corpo" assinado e' a politica JSON, nao
    // uma requisicao HTTP inteira.
    public async Task<PostAssinado> AssinarAsync(string chaveObjeto, string lojaId, TimeSpan validade)
    {
        var credenciais = await ObterCredenciaisDaTaskAsync();

        var agora = DateTimeOffset.UtcNow;
        var dataCurta = agora.ToString("yyyyMMdd");
        var dataCompleta = agora.ToString("yyyyMMddTHHmmssZ");
        var escopo = $"{dataCurta}/{_regiao}/s3/aws4_request";
        var credencial = $"{credenciais.AccessKey}/{escopo}";

        // Cada condicao aqui e' uma fronteira que o CLIENTE nao pode mover:
        // a politica inteira e' o que se assina, entao mexer em qualquer
        // campo — inclusive o teto de tamanho — invalida a assinatura.
        var condicoes = new List<object>
        {
            new Dictionary<string, string> { ["bucket"] = _bucket },
            new object[] { "starts-with", "$key", chaveObjeto },
            new object[] { "content-length-range", TamanhoMinimoBytes, TamanhoMaximoLaudoBytes },
            new Dictionary<string, string> { ["x-amz-meta-loja-id"] = lojaId },
            new Dictionary<string, string> { ["x-amz-algorithm"] = "AWS4-HMAC-SHA256" },
            new Dictionary<string, string> { ["x-amz-credential"] = credencial },
            new Dictionary<string, string> { ["x-amz-date"] = dataCompleta },
        };
        if (!string.IsNullOrEmpty(credenciais.Token))
            condicoes.Add(new Dictionary<string, string> { ["x-amz-security-token"] = credenciais.Token });

        var politica = new Dictionary<string, object>
        {
            // O prazo e' curto de proposito: 10 min cobre o tempo de UM
            // upload na banda mais lenta que a Cadencia suporta hoje (8
            // Mbit/s de subida, ~200 s para 200 MB), com folga — nao
            // verifiquei se a AWS reavalia a expiracao so no INICIO da
            // requisicao ou durante toda a transferencia, entao a folga e'
            // deliberada, nao um numero decorado.
            ["expiration"] = agora.Add(validade).ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
            ["conditions"] = condicoes,
        };
        var politicaJson = JsonSerializer.Serialize(politica);
        var politicaBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(politicaJson));

        static byte[] Hmac(byte[] chave, string dado) =>
            new HMACSHA256(chave).ComputeHash(Encoding.UTF8.GetBytes(dado));

        // A cadeia de derivacao do SigV4: quatro HMACs encadeados, cada um
        // amarrando a assinatura a uma dimensao (dia, regiao, servico, tipo
        // de request) sem nunca reusar a chave secreta diretamente.
        var kData = Hmac(Encoding.UTF8.GetBytes("AWS4" + credenciais.SecretKey), dataCurta);
        var kRegiao = Hmac(kData, _regiao);
        var kServico = Hmac(kRegiao, "s3");
        var kAssinatura = Hmac(kServico, "aws4_request");
        var assinatura = Convert.ToHexString(Hmac(kAssinatura, politicaBase64)).ToLowerInvariant();

        var campos = new Dictionary<string, string>
        {
            ["key"] = chaveObjeto,
            ["policy"] = politicaBase64,
            ["x-amz-algorithm"] = "AWS4-HMAC-SHA256",
            ["x-amz-credential"] = credencial,
            ["x-amz-date"] = dataCompleta,
            ["x-amz-signature"] = assinatura,
            ["x-amz-meta-loja-id"] = lojaId,
        };
        if (!string.IsNullOrEmpty(credenciais.Token))
            campos["x-amz-security-token"] = credenciais.Token;

        return new PostAssinado($"https://{_bucket}.s3.{_regiao}.amazonaws.com/", campos, agora.Add(validade));
    }

    private static async Task<ImmutableCredentials> ObterCredenciaisDaTaskAsync()
    {
        var credenciais = FallbackCredentialsFactory.GetCredentials();
        return await credenciais.GetCredentialsAsync();
    }
}

// Program.cs (trecho) — a rota que so assina, nunca le o arquivo

app.MapPost("/api/laudos/assinatura", async (
    PedidoAssinatura pedido, ClaimsPrincipal usuario, AppDb db, AssinadorPostS3 assinador) =>
{
    var lojaId = usuario.FindFirstValue("loja_id")
        ?? throw new InvalidOperationException("sessao sem loja associada");

    // A cota impede que uma loja sozinha consuma o orcamento mensal de
    // armazenamento das outras 29 — controle de negocio, nao de bytes.
    var cota = await db.CotasDeLoja.FindAsync(lojaId);
    if (cota is null || cota.LaudosNoMes >= cota.LimiteMensal)
        return Results.Json(new { erro = "cota mensal de laudos atingida" }, statusCode: 429);

    if (pedido.TamanhoDeclaradoBytes is < 1024 or > AssinadorPostS3.TamanhoMaximoLaudoBytes)
        return Results.BadRequest(new { erro = "tamanho declarado fora da faixa aceita" });

    // A extensao vem do TIPO ACEITO pela aplicacao, nunca do nome que o
    // cliente mandou — e' o mesmo raciocinio do L03 para tag de imagem:
    // identidade decidida pelo servidor, nao aceita por confianca no cliente.
    var extensao = ExtensaoParaTipo(pedido.TipoMime)
        ?? throw new ArgumentException($"tipo nao aceito: {pedido.TipoMime}");
    var chave = $"lojas/{lojaId}/laudos/{DateTime.UtcNow:yyyy}/{Guid.NewGuid():N}.{extensao}";

    var assinado = await assinador.AssinarAsync(chave, lojaId, TimeSpan.FromMinutes(10));

    return Results.Ok(new
    {
        url = assinado.Url,
        campos = assinado.Campos,
        validoAte = assinado.ValidoAte,
    });
});

public sealed record PedidoAssinatura(long TamanhoDeclaradoBytes, string TipoMime);

// Multipart.cs — quando o POST simples nao basta, e o teto de tamanho vira
// DECISAO DA APLICACAO, porque o S3 nao oferece condicao nenhuma para isso

using System.Collections.Concurrent;
using Amazon.S3;
using Amazon.S3.Model;

namespace Cadencia.Api.Laudos;

// Em producao isto e' uma linha por upload no DynamoDB com TTL, nao memoria
// do processo — a task pode reiniciar no meio de um upload de 40 minutos, e
// o contador precisa sobreviver a isso.
public sealed class ControleDeAdmissaoMultipart
{
    private readonly ConcurrentDictionary<string, long> _bytesDeclaradosPorUpload = new();

    public bool AutorizarParte(string uploadId, long tamanhoDaParteBytes, long tetoTotalBytes)
    {
        var acumulado = _bytesDeclaradosPorUpload.AddOrUpdate(
            uploadId, tamanhoDaParteBytes, (_, atual) => atual + tamanhoDaParteBytes);

        // O S3 aceitaria a parte de qualquer jeito: multipart nao tem
        // `content-length-range`. Quem recusa aqui e' a aplicacao, ANTES de
        // emitir a URL assinada da parte seguinte — recusar so na conclusao,
        // depois de todos os bytes ja terem subido, nao economiza nada.
        if (acumulado > tetoTotalBytes)
        {
            _bytesDeclaradosPorUpload.TryRemove(uploadId, out _);
            return false;
        }
        return true;
    }

    public void Concluir(string uploadId) => _bytesDeclaradosPorUpload.TryRemove(uploadId, out _);
}

public static class RotasMultipart
{
    public static void Mapear(WebApplication app)
    {
        app.MapPost("/api/laudos/multipart/iniciar", async (
            PedidoIniciarMultipart pedido, IAmazonS3 s3, ClaimsPrincipal usuario) =>
        {
            var lojaId = usuario.FindFirstValue("loja_id")!;
            var chave = $"lojas/{lojaId}/laudos/{DateTime.UtcNow:yyyy}/{Guid.NewGuid():N}.mp4";

            var resposta = await s3.InitiateMultipartUploadAsync(new InitiateMultipartUploadRequest
            {
                BucketName = ConfigLaudos.BucketQuarentena,
                Key = chave,
                ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS,
            });

            return Results.Ok(new { uploadId = resposta.UploadId, chave });
        });

        app.MapPost("/api/laudos/multipart/parte", (
            PedidoParte pedido, IAmazonS3 s3, ControleDeAdmissaoMultipart controle) =>
        {
            if (!controle.AutorizarParte(pedido.UploadId, pedido.TamanhoDeclaradoBytes,
                    AssinadorPostS3.TamanhoMaximoLaudoBytes))
            {
                // A soma passou do teto: aborta o upload INTEIRO agora, nao so
                // recusa a parte. Uma parte recusada sem abortar deixa as
                // anteriores penduradas, cobrando ate o ciclo de vida
                // alcanca-las em 1 dia — este cancelamento e' o que evita essa
                // espera.
                s3.AbortMultipartUploadAsync(ConfigLaudos.BucketQuarentena, pedido.Chave, pedido.UploadId);
                return Results.BadRequest(new { erro = "soma das partes excede o limite do laudo" });
            }

            var url = s3.GetPreSignedURL(new GetPreSignedUrlRequest
            {
                BucketName = ConfigLaudos.BucketQuarentena,
                Key = pedido.Chave,
                Verb = HttpVerb.PUT,
                Expires = DateTime.UtcNow.AddMinutes(10),
                UploadId = pedido.UploadId,
                PartNumber = pedido.NumeroDaParte,
            });

            return Results.Ok(new { url });
        });

        app.MapPost("/api/laudos/multipart/concluir", async (
            PedidoConcluirMultipart pedido, IAmazonS3 s3, ControleDeAdmissaoMultipart controle) =>
        {
            var req = new CompleteMultipartUploadRequest
            {
                BucketName = ConfigLaudos.BucketQuarentena,
                Key = pedido.Chave,
                UploadId = pedido.UploadId,
                PartETags = pedido.Partes.Select(p => new PartETag(p.NumeroDaParte, p.ETag)).ToList(),
            };
            await s3.CompleteMultipartUploadAsync(req);
            controle.Concluir(pedido.UploadId);
            return Results.Ok();
        });
    }
}

public sealed record PedidoIniciarMultipart(long TamanhoTotalDeclaradoBytes);
public sealed record PedidoParte(string UploadId, string Chave, int NumeroDaParte, long TamanhoDeclaradoBytes);
public sealed record PedidoConcluirMultipart(string UploadId, string Chave, List<ParteConcluida> Partes);
public sealed record ParteConcluida(int NumeroDaParte, string ETag);

// ConsumidorDeLaudos.cs — le a fila, decide, e so entao move o objeto

using System.Text.Json;
using Amazon.S3;
using Amazon.S3.Model;
using Amazon.SQS;
using Amazon.SQS.Model;

namespace Cadencia.Worker.Laudos;

public sealed class ConsumidorDeLaudos(
    IAmazonSQS sqs, IAmazonS3 s3, ILogger<ConsumidorDeLaudos> log) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            var resposta = await sqs.ReceiveMessageAsync(new ReceiveMessageRequest
            {
                QueueUrl = ConfigLaudos.FilaVerificacaoUrl,
                MaxNumberOfMessages = 5,
                WaitTimeSeconds = 20, // long poll: menos requisicoes vazias, que custam o mesmo
            }, ct);

            foreach (var msg in resposta.Messages)
            {
                try
                {
                    await ProcessarAsync(msg, ct);
                    await sqs.DeleteMessageAsync(ConfigLaudos.FilaVerificacaoUrl, msg.ReceiptHandle, ct);
                }
                catch (Exception ex)
                {
                    // NAO deleta: a mensagem volta a ficar visivel apos o
                    // timeout, e depois de 5 tentativas vai para a DLQ. Sem
                    // essa fila, um erro aqui perde o evento e o laudo fica
                    // orfao em quarentena sem ninguem notar.
                    log.LogError(ex, "falha ao verificar laudo, mensagem retorna a fila");
                }
            }
        }
    }

    private async Task ProcessarAsync(Message msg, CancellationToken ct)
    {
        var evento = JsonSerializer.Deserialize<EventoObjetoCriado>(msg.Body)!;
        var bucketOrigem = evento.Detail.Bucket.Name;
        var chave = evento.Detail.Object.Key;

        // Le so os primeiros 512 bytes: o bastante para conferir a
        // assinatura binaria (numero magico) do arquivo sem baixar 200 MB
        // para decidir se o tipo declarado bate com o tipo real.
        using var cabecalho = await s3.GetObjectAsync(new GetObjectRequest
        {
            BucketName = bucketOrigem,
            Key = chave,
            ByteRange = new ByteRange(0, 511),
        }, ct);

        var tipoReal = SniffarTipo(cabecalho.ResponseStream);
        var tipoOk = TipoEhAceito(tipoReal);
        var antivirusOk = tipoOk && await ChecarAntivirusAsync(bucketOrigem, chave, ct);
        var aprovado = tipoOk && antivirusOk;

        if (aprovado)
        {
            await s3.CopyObjectAsync(new CopyObjectRequest
            {
                SourceBucket = bucketOrigem,
                SourceKey = chave,
                DestinationBucket = ConfigLaudos.BucketPublicado,
                DestinationKey = chave,
                ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS,
            }, ct);
        }

        // O objeto some da quarentena nos dois casos: aprovado, porque ja foi
        // copiado; recusado, porque quarentena nao e' deposito permanente de
        // arquivo malicioso.
        await s3.DeleteObjectAsync(bucketOrigem, chave, ct);

        await GravarVeredictoAsync(chave, aprovado, tipoReal, evento.Detail.Object.Size, ct);
    }
}

#!/usr/bin/env bash
# provas.sh — cinco medicoes; nenhuma conclusao vem de "parece que funcionou"
set -euo pipefail

DOMINIO="$(terraform output -raw dominio)"
BUCKET_QUAR="$(terraform output -raw bucket_quarentena)"
FILA="$(terraform output -raw fila_verificacao_url)"

# ── Prova 1: a memoria da task NAO se move mais com o tamanho do arquivo ────
# Gera um laudo de 200 MB e envia PELA URL ASSINADA. Observe a memoria da
# task da API enquanto o upload roda: ela nao deve variar com o tamanho.
dd if=/dev/urandom of=/tmp/laudo-200mb.pdf bs=1M count=200
ASSINATURA=$(curl -s -X POST "https://${DOMINIO}/api/laudos/assinatura" \
  -H 'Content-Type: application/json' \
  -d '{"tamanhoDeclaradoBytes": 209715200, "tipoMime": "application/pdf"}')
URL=$(echo "$ASSINATURA" | jq -r '.url')
# ... monta o multipart/form-data com os campos de "campos" e faz o POST ...
# Esperado: MemoryUtilized da task da API (CloudWatch Container Insights)
# continua achatada durante o upload inteiro — quem sobe e desce e' o S3.

# ── Prova 2: o teto de tamanho e' recusado pelo S3, nao pela aplicacao ──────
# Um arquivo de 250 MB, acima dos 220 MB assinados, tem de ser recusado ANTES
# de qualquer byte ser gravado.
dd if=/dev/urandom of=/tmp/laudo-250mb.pdf bs=1M count=250
# Reusa a mesma assinatura (que permite ate 220 MB) e tenta enviar o de 250.
# Esperado: HTTP 400 do S3, com <Code>EntityTooLarge</Code> no corpo XML.
# Se isto passar como 200, a condicao content-length-range nao foi aplicada.

# ── Prova 3: PUT assinado SEM Content-Length nao tem teto nenhum ────────────
# A comparacao que sustenta o achado central do modulo.
python3 - <<'PY'
import boto3
s3 = boto3.client("s3")
print(s3.generate_presigned_url("put_object",
      Params={"Bucket": "ffv-lab-laudos-quarentena", "Key": "teste/sem-teto.bin"},
      ExpiresIn=600))
PY
# Envie um arquivo de qualquer tamanho pela URL acima com curl -T. Esperado:
# aceita 500 MB do mesmo jeito que aceitaria 5 KB — nao ha condicao de
# tamanho embutida numa PUT assinada sem cabecalhos adicionais.

# ── Prova 4: o multipart incompleto realmente cobra, e a regra o mata ───────
aws s3api create-multipart-upload --bucket "$BUCKET_QUAR" \
  --key "teste/abandonado.bin" --query 'UploadId' --output text
# NAO conclua o upload. Espere 25h e confira:
aws s3api list-multipart-uploads --bucket "$BUCKET_QUAR" \
  --query 'Uploads[?Key==`teste/abandonado.bin`]'
# Esperado apos 25h: lista vazia — a regra de ciclo de vida de 1 dia abortou.
# Antes das 25h, o upload aparece, e cada parte enviada esta sendo cobrada.

# ── Prova 5: o veredito chega, e o tempo entre upload e aprovacao e' medido ─
INICIO=$(date +%s)
# ... repita o upload da prova 1 ...
aws sqs receive-message --queue-url "$FILA" --wait-time-seconds 20 >/dev/null
FIM=$(date +%s)
echo "latencia de validacao: $((FIM - INICIO))s"
# Nao ha SLA documentado para isto — meca a distribuicao real no seu ambiente
# antes de prometer um numero a quem consome o veredito.

# 1. Derrube o que o Terraform administra.
terraform destroy -auto-approve

# 2. MULTIPART INCOMPLETO: o destroy do bucket falha se houver upload
#    multipart em andamento, a menos que force_destroy esteja ligado.
aws s3api list-multipart-uploads --bucket ffv-lab-laudos-quarentena \
  --query "Uploads[].{Chave:Key,Iniciado:Initiated}" --output table
for upload in $(aws s3api list-multipart-uploads --bucket ffv-lab-laudos-quarentena \
                  --query "Uploads[].UploadId" --output text); do
  aws s3api abort-multipart-upload --bucket ffv-lab-laudos-quarentena \
    --key "$(aws s3api list-multipart-uploads --bucket ffv-lab-laudos-quarentena \
              --query "Uploads[?UploadId=='$upload'].Key | [0]" --output text)" \
    --upload-id "$upload"
done

# 3. OBJETOS RESIDUAIS nos dois buckets: destroy sem force_destroy nao
#    remove bucket com objeto dentro.
aws s3 rm s3://ffv-lab-laudos-quarentena --recursive
aws s3 rm s3://ffv-lab-laudos-publicados --recursive

# 4. FILA E DLQ: nao cobram paradas em valor relevante, mas confirme
#    que sumiram — mensagem presa numa fila orfa nao aparece em nenhum
#    painel depois que o Terraform sair do estado.
aws sqs list-queues --queue-name-prefix ffv-lab-laudos

# 5. Prova final: nada com o nome do projeto de pe.
aws resourcegroupstaggingapi get-resources \
  --tag-filters Key=Projeto,Values=ffv-lab \
  --query "ResourceTagMappingList[].ResourceARN" --output table