Carreira em Segurança e Criptografia com Rust

use sha2::{Sha256, Sha512, Digest};
use hmac::{Hmac, Mac};
use hex;

/// Funções de hashing seguro
mod hashing {
    use super::*;

    /// Hash SHA-256 de dados arbitrários
    pub fn sha256(dados: &[u8]) -> String {
        let mut hasher = Sha256::new();
        hasher.update(dados);
        let resultado = hasher.finalize();
        hex::encode(resultado)
    }

    /// Hash SHA-512 de dados arbitrários
    pub fn sha512(dados: &[u8]) -> String {
        let mut hasher = Sha512::new();
        hasher.update(dados);
        let resultado = hasher.finalize();
        hex::encode(resultado)
    }

    /// HMAC-SHA256 para autenticação de mensagens
    pub fn hmac_sha256(chave: &[u8], mensagem: &[u8]) -> String {
        type HmacSha256 = Hmac<Sha256>;

        let mut mac = HmacSha256::new_from_slice(chave)
            .expect("HMAC aceita chaves de qualquer tamanho");
        mac.update(mensagem);
        let resultado = mac.finalize();
        hex::encode(resultado.into_bytes())
    }

    /// Verificação de HMAC em tempo constante
    pub fn verificar_hmac(
        chave: &[u8],
        mensagem: &[u8],
        mac_esperado: &str,
    ) -> bool {
        type HmacSha256 = Hmac<Sha256>;

        let mut mac = HmacSha256::new_from_slice(chave)
            .expect("HMAC aceita chaves de qualquer tamanho");
        mac.update(mensagem);

        let mac_bytes = hex::decode(mac_esperado).unwrap_or_default();
        mac.verify_slice(&mac_bytes).is_ok()
    }
}

/// Funções de hashing de senhas
mod senhas {
    use argon2::{
        password_hash::{
            rand_core::OsRng, PasswordHash, PasswordHasher,
            PasswordVerifier, SaltString,
        },
        Argon2,
    };

    /// Hash de senha com Argon2id (vencedor do PHC)
    pub fn hash_senha(senha: &str) -> Result<String, String> {
        let salt = SaltString::generate(&mut OsRng);
        let argon2 = Argon2::default();

        argon2
            .hash_password(senha.as_bytes(), &salt)
            .map(|hash| hash.to_string())
            .map_err(|e| format!("Erro ao gerar hash: {}", e))
    }

    /// Verificação de senha contra hash armazenado
    pub fn verificar_senha(
        senha: &str,
        hash: &str,
    ) -> Result<bool, String> {
        let parsed_hash = PasswordHash::new(hash)
            .map_err(|e| format!("Hash inválido: {}", e))?;

        Ok(Argon2::default()
            .verify_password(senha.as_bytes(), &parsed_hash)
            .is_ok())
    }
}

fn main() {
    println!("=== Demonstração de Hashing Seguro ===\n");

    // SHA-256
    let mensagem = "Rust é seguro por design";
    let hash = hashing::sha256(mensagem.as_bytes());
    println!("SHA-256('{}'):", mensagem);
    println!("  {}\n", hash);

    // SHA-512
    let hash512 = hashing::sha512(mensagem.as_bytes());
    println!("SHA-512('{}'):", mensagem);
    println!("  {}\n", hash512);

    // HMAC-SHA256
    let chave = b"chave-secreta-muito-segura";
    let mac = hashing::hmac_sha256(chave, mensagem.as_bytes());
    println!("HMAC-SHA256:");
    println!("  {}\n", mac);

    // Verificação de HMAC
    let valido = hashing::verificar_hmac(chave, mensagem.as_bytes(), &mac);
    println!("HMAC válido: {}", valido);

    let invalido = hashing::verificar_hmac(
        chave,
        b"mensagem alterada",
        &mac,
    );
    println!("HMAC de mensagem alterada: {}\n", invalido);

    // Hash de senha
    println!("=== Hashing de Senhas (Argon2id) ===\n");
    let senha = "MinhaS3nha$egura!";
    let hash = senhas::hash_senha(senha).unwrap();
    println!("Senha: {}", senha);
    println!("Hash: {}\n", hash);

    let correto = senhas::verificar_senha(senha, &hash).unwrap();
    println!("Senha correta: {}", correto);

    let incorreto = senhas::verificar_senha("SenhaErrada", &hash).unwrap();
    println!("Senha incorreta: {}", incorreto);
}

use aes_gcm::{
    aead::{Aead, KeyInit, OsRng},
    Aes256Gcm, Nonce,
};
use rand::RngCore;
use ed25519_dalek::{
    SigningKey, VerifyingKey, Signer, Verifier, Signature,
};

/// Criptografia simétrica AES-256-GCM
mod simetrica {
    use super::*;

    pub struct CryptoBox {
        cipher: Aes256Gcm,
    }

    impl CryptoBox {
        /// Cria uma nova instância com chave aleatória
        pub fn new() -> (Self, Vec<u8>) {
            let chave = Aes256Gcm::generate_key(&mut OsRng);
            let cipher = Aes256Gcm::new(&chave);
            let chave_bytes = chave.to_vec();
            (CryptoBox { cipher }, chave_bytes)
        }

        /// Cria instância a partir de chave existente
        pub fn from_key(chave: &[u8]) -> Result<Self, String> {
            if chave.len() != 32 {
                return Err("Chave deve ter 32 bytes".to_string());
            }
            let key = aes_gcm::Key::<Aes256Gcm>::from_slice(chave);
            Ok(CryptoBox {
                cipher: Aes256Gcm::new(key),
            })
        }

        /// Criptografa dados com nonce aleatório
        pub fn criptografar(
            &self,
            dados: &[u8],
        ) -> Result<Vec<u8>, String> {
            let mut nonce_bytes = [0u8; 12];
            OsRng.fill_bytes(&mut nonce_bytes);
            let nonce = Nonce::from_slice(&nonce_bytes);

            let ciphertext = self
                .cipher
                .encrypt(nonce, dados)
                .map_err(|e| format!("Erro de criptografia: {}", e))?;

            // Prepend nonce ao ciphertext para uso na decriptação
            let mut resultado = nonce_bytes.to_vec();
            resultado.extend(ciphertext);
            Ok(resultado)
        }

        /// Decriptografa dados
        pub fn decriptografar(
            &self,
            dados: &[u8],
        ) -> Result<Vec<u8>, String> {
            if dados.len() < 12 {
                return Err("Dados muito curtos".to_string());
            }

            let (nonce_bytes, ciphertext) = dados.split_at(12);
            let nonce = Nonce::from_slice(nonce_bytes);

            self.cipher
                .decrypt(nonce, ciphertext)
                .map_err(|e| format!("Erro de decriptografia: {}", e))
        }
    }
}

/// Assinatura digital Ed25519
mod assinatura {
    use super::*;

    pub struct Assinador {
        signing_key: SigningKey,
    }

    impl Assinador {
        /// Gera um novo par de chaves
        pub fn novo() -> Self {
            let signing_key = SigningKey::generate(&mut OsRng);
            Assinador { signing_key }
        }

        /// Retorna a chave pública (para verificação)
        pub fn chave_publica(&self) -> VerifyingKey {
            self.signing_key.verifying_key()
        }

        /// Assina uma mensagem
        pub fn assinar(&self, mensagem: &[u8]) -> Signature {
            self.signing_key.sign(mensagem)
        }

        /// Exporta a chave pública como bytes
        pub fn chave_publica_bytes(&self) -> Vec<u8> {
            self.chave_publica().to_bytes().to_vec()
        }
    }

    /// Verifica uma assinatura com chave pública
    pub fn verificar(
        chave_publica: &[u8],
        mensagem: &[u8],
        assinatura: &[u8],
    ) -> Result<bool, String> {
        let vk = VerifyingKey::from_bytes(
            chave_publica
                .try_into()
                .map_err(|_| "Chave pública inválida")?,
        )
        .map_err(|e| format!("Erro na chave: {}", e))?;

        let sig = Signature::from_bytes(
            assinatura
                .try_into()
                .map_err(|_| "Assinatura inválida")?,
        );

        Ok(vk.verify(mensagem, &sig).is_ok())
    }
}

fn main() {
    println!("=== Criptografia Simétrica (AES-256-GCM) ===\n");

    let (crypto, chave) = simetrica::CryptoBox::new();
    println!("Chave gerada: {} bytes", chave.len());

    let mensagem = "Informação confidencial: Rust é incrível!";
    let criptografado = crypto.criptografar(mensagem.as_bytes()).unwrap();
    println!("Texto original: {}", mensagem);
    println!("Criptografado: {} bytes", criptografado.len());

    let decriptografado = crypto.decriptografar(&criptografado).unwrap();
    let texto = String::from_utf8(decriptografado).unwrap();
    println!("Decriptografado: {}\n", texto);

    println!("=== Assinatura Digital (Ed25519) ===\n");

    let assinador = assinatura::Assinador::novo();
    let chave_pub = assinador.chave_publica_bytes();
    println!("Chave pública: {} bytes", chave_pub.len());

    let documento = "Contrato importante que precisa de assinatura digital";
    let sig = assinador.assinar(documento.as_bytes());
    println!("Documento: {}", documento);
    println!("Assinatura: {} bytes", sig.to_bytes().len());

    let valido = assinatura::verificar(
        &chave_pub,
        documento.as_bytes(),
        &sig.to_bytes(),
    )
    .unwrap();
    println!("Assinatura válida: {}", valido);

    let adulterado = assinatura::verificar(
        &chave_pub,
        b"Documento adulterado",
        &sig.to_bytes(),
    )
    .unwrap();
    println!("Documento adulterado: {}", adulterado);
}

use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};

/// Tipos de vulnerabilidade detectáveis
#[derive(Debug, Clone)]
enum TipoVulnerabilidade {
    SegredoExposto,
    DependenciaInsegura,
    PermissaoExcessiva,
    ConfiguracaoInsegura,
    InputNaoValidado,
}

#[derive(Debug, Clone)]
struct Vulnerabilidade {
    tipo: TipoVulnerabilidade,
    severidade: String,
    arquivo: String,
    linha: usize,
    descricao: String,
    recomendacao: String,
}

/// Scanner de segurança para projetos
struct SecurityScanner {
    padroes_segredos: Vec<(&'static str, &'static str)>,
    resultados: Vec<Vulnerabilidade>,
}

impl SecurityScanner {
    fn new() -> Self {
        SecurityScanner {
            padroes_segredos: vec![
                ("password", "Possível senha hardcoded"),
                ("secret", "Possível segredo exposto"),
                ("api_key", "Possível API key exposta"),
                ("token", "Possível token exposto"),
                ("private_key", "Possível chave privada exposta"),
                ("aws_access_key", "Credencial AWS exposta"),
                ("database_url", "URL de banco de dados exposta"),
            ],
            resultados: Vec::new(),
        }
    }

    /// Escaneia um arquivo em busca de segredos expostos
    fn escanear_segredos(&mut self, caminho: &Path) {
        let conteudo = match fs::read_to_string(caminho) {
            Ok(c) => c,
            Err(_) => return,
        };

        let caminho_str = caminho.display().to_string();

        for (numero_linha, linha) in conteudo.lines().enumerate() {
            let linha_lower = linha.to_lowercase();

            for (padrao, descricao) in &self.padroes_segredos {
                if linha_lower.contains(padrao)
                    && (linha_lower.contains("=")
                        || linha_lower.contains(":"))
                {
                    // Verificar se não é um comentário ou definição de variável vazia
                    let trimmed = linha.trim();
                    if trimmed.starts_with("//")
                        || trimmed.starts_with("#")
                        || trimmed.starts_with("/*")
                    {
                        continue;
                    }

                    self.resultados.push(Vulnerabilidade {
                        tipo: TipoVulnerabilidade::SegredoExposto,
                        severidade: "ALTA".to_string(),
                        arquivo: caminho_str.clone(),
                        linha: numero_linha + 1,
                        descricao: descricao.to_string(),
                        recomendacao: format!(
                            "Use variáveis de ambiente ou um vault \
                             para armazenar {}",
                            padrao
                        ),
                    });
                }
            }
        }
    }

    /// Verifica o Cargo.toml por dependências conhecidamente inseguras
    fn verificar_dependencias(&mut self, cargo_toml: &Path) {
        let conteudo = match fs::read_to_string(cargo_toml) {
            Ok(c) => c,
            Err(_) => return,
        };

        let caminho_str = cargo_toml.display().to_string();

        // Lista simplificada de crates com vulnerabilidades conhecidas
        let crates_inseguros: HashMap<&str, &str> = HashMap::from([
            ("openssl", "Considere usar rustls para TLS nativo em Rust"),
            ("chrono", "Versões < 0.4.20 têm vulnerabilidade de segfault"),
            ("regex", "Versões < 1.5.5 têm vulnerabilidade de ReDoS"),
        ]);

        for (numero_linha, linha) in conteudo.lines().enumerate() {
            for (crate_nome, recomendacao) in &crates_inseguros {
                if linha.contains(crate_nome) && !linha.trim().starts_with("#")
                {
                    self.resultados.push(Vulnerabilidade {
                        tipo: TipoVulnerabilidade::DependenciaInsegura,
                        severidade: "MÉDIA".to_string(),
                        arquivo: caminho_str.clone(),
                        linha: numero_linha + 1,
                        descricao: format!(
                            "Dependência '{}' pode ter vulnerabilidades",
                            crate_nome
                        ),
                        recomendacao: recomendacao.to_string(),
                    });
                }
            }
        }
    }

    /// Gera relatório de segurança
    fn gerar_relatorio(&self) -> String {
        let mut relatorio = String::new();

        relatorio.push_str("╔══════════════════════════════════════╗\n");
        relatorio.push_str("║   RELATÓRIO DE SEGURANÇA - Rust     ║\n");
        relatorio.push_str("╚══════════════════════════════════════╝\n\n");

        let total = self.resultados.len();
        let altas = self
            .resultados
            .iter()
            .filter(|v| v.severidade == "ALTA")
            .count();
        let medias = self
            .resultados
            .iter()
            .filter(|v| v.severidade == "MÉDIA")
            .count();
        let baixas = self
            .resultados
            .iter()
            .filter(|v| v.severidade == "BAIXA")
            .count();

        relatorio.push_str(&format!("Total de vulnerabilidades: {}\n", total));
        relatorio.push_str(&format!("  ALTA: {}\n", altas));
        relatorio.push_str(&format!("  MÉDIA: {}\n", medias));
        relatorio.push_str(&format!("  BAIXA: {}\n\n", baixas));

        for (i, vuln) in self.resultados.iter().enumerate() {
            relatorio.push_str(&format!(
                "--- Vulnerabilidade #{} ---\n",
                i + 1
            ));
            relatorio.push_str(&format!(
                "Severidade: {}\n",
                vuln.severidade
            ));
            relatorio.push_str(&format!(
                "Tipo: {:?}\n",
                vuln.tipo
            ));
            relatorio.push_str(&format!(
                "Arquivo: {}:{}\n",
                vuln.arquivo, vuln.linha
            ));
            relatorio.push_str(&format!(
                "Descrição: {}\n",
                vuln.descricao
            ));
            relatorio.push_str(&format!(
                "Recomendação: {}\n\n",
                vuln.recomendacao
            ));
        }

        relatorio
    }
}

fn main() {
    let mut scanner = SecurityScanner::new();

    // Escanear arquivos de exemplo
    println!("Iniciando scan de segurança...\n");

    // Em um cenário real, escanearia o diretório do projeto
    // scanner.escanear_segredos(Path::new("src/config.rs"));
    // scanner.verificar_dependencias(Path::new("Cargo.toml"));

    println!("{}", scanner.gerar_relatorio());
}