const std = @import("std");

// Zig previne buffer overflow automaticamente
test "bounds checking previne overflow" {
    var buffer: [10]u8 = undefined;
    const indice: usize = 15;

    // Em modo Debug/ReleaseSafe, isso gera um panic
    // em vez de acessar memória inválida
    // buffer[indice] = 42; // panic: index out of bounds

    // A forma segura:
    if (indice < buffer.len) {
        buffer[indice] = 42;
    }
    _ = buffer;
}

// Tipos opcionais eliminam null pointer dereferences
fn buscarUsuario(id: u64) ?*const Usuario {
    // Retorna null explicitamente, sem ponteiros pendentes
    _ = id;
    return null;
}

const std = @import("std");
const crypto = std.crypto;

/// Hash seguro de senha com Argon2
fn hashSenha(senha: []const u8, salt: [16]u8) [32]u8 {
    var hash: [32]u8 = undefined;
    crypto.pwhash.argon2.strHash(senha, .{
        .salt = salt,
    }, &hash) catch unreachable;
    return hash;
}

/// Criptografia AES-256-GCM
fn encriptar(
    plaintext: []const u8,
    chave: [32]u8,
    nonce: [12]u8,
    allocator: std.mem.Allocator,
) ![]u8 {
    const ciphertext = try allocator.alloc(u8, plaintext.len);
    var tag: [16]u8 = undefined;

    crypto.aead.aes_gcm.Aes256Gcm.encrypt(
        ciphertext,
        &tag,
        plaintext,
        &.{},
        nonce,
        chave,
    );

    return ciphertext;
}

/// Comparação em tempo constante (previne timing attacks)
fn comparacaoSegura(a: []const u8, b: []const u8) bool {
    return crypto.utils.timingSafeEql(a, b);
}

const std = @import("std");
const net = std.net;

fn scanPorta(host: []const u8, porta: u16, timeout_ms: u32) bool {
    const endereco = net.Address.resolveIp(host, porta) catch return false;

    const socket = std.posix.socket(
        endereco.any.family,
        std.posix.SOCK.STREAM | std.posix.SOCK.NONBLOCK,
        0,
    ) catch return false;
    defer std.posix.close(socket);

    // Tentar conectar com timeout
    std.posix.connect(socket, &endereco.any, endereco.getOsSockLen()) catch |err| {
        if (err != error.WouldBlock) return false;
    };

    // Esperar conexão com poll
    var fds = [_]std.posix.pollfd{.{
        .fd = socket,
        .events = std.posix.POLL.OUT,
        .revents = 0,
    }};

    const ready = std.posix.poll(&fds, timeout_ms) catch return false;
    return ready > 0 and (fds[0].revents & std.posix.POLL.OUT != 0);
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    const host = "127.0.0.1";

    try stdout.print("Scanning {s}...\n", .{host});

    for (1..1025) |porta| {
        if (scanPorta(host, @intCast(porta), 200)) {
            try stdout.print("Porta {d}: ABERTA\n", .{porta});
        }
    }
}