Forem: Friedrich Ruiz

¿Cómo apagué la música de una fiesta para poder dormir?

Friedrich Ruiz — Sun, 21 Dec 2025 02:43:51 +0000

Creo que una de las cosas que más me causó indignación este año fue que haya parranda en mi refugio temporal (la casa donde vivo), no estar invitado y tener que calarme la música y la gente cantando karaoke hasta tarde. Todo esto sacrificando mis valiosas horas de sueño por pura obstinación ajena.

Hasta que recordé que soy informático. Me pregunté qué podía hacer con este vasto conocimiento en las artes digitales y recordé que hace tiempo había probado un script para realizar Bluesmack (un ataque de denegación de servicio a dispositivos Bluetooth). Mi primera idea fue imponer mi poder como hacker silenciando el receptor directamente. Sin embargo, encontrar la dirección MAC del radio fue imposible; tras tres horas de búsqueda fallida, escuché un anuncio de YouTube saliendo por las cornetas.

Eso lo cambió todo. Significaba que no dependían solo del Bluetooth, sino que usaban el Wi-Fi para su música mundana. En ese momento entendí que mi objetivo de dormir aún no estaba perdido.

Paso 1: Localización y Reconocimiento de Red

Para atacar, primero necesitaba un mapa de mi red local. El primer paso fue identificar la IP del Router. Utilicé el comando:

ip route show

Este comando devuelve la tabla de enrutamiento del sistema. La línea que nos interesa es la que comienza con default via, que indica la dirección del nodo central:

Ejemplo de salida:
default via 192.168.0.1 dev wlx88947e9b4dab proto dhcp metric 600
Aquí confirmamos que el router es la IP **192.168.0.1.

Con la dirección del router clara, utilicé Nmap para realizar un escaneo de dispositivos activos en el segmento de red (/24 que abarca de la IP .1 a la .254):

sudo nmap -sn 192.168.0.0/24

El parámetro -sn indica un "Ping Scan", que detecta dispositivos encendidos sin realizar un escaneo de puertos profundo, lo que lo hace mucho más rápido.

Intento 1: Inundación por ICMP (Ping Flood)

Con la lista de sospechosos en mano (excluyendo mi PC y el router), identifiqué los teléfonos que estaban haciendo el streaming. Mi primer movimiento fue un Ping Flood.

sudo ping -f <ip_del_dispositivo>

El parámetro -f (flood) envía paquetes ICMP tan rápido como el sistema puede procesarlos o tan pronto como regresan. Ejecuté esto en varias terminales simultáneamente contra distintas IPs sospechosas. Aunque la música presentaba interrupciones, el streaming lograba recuperarse debido a que los routers modernos tienen mecanismos para priorizar o limitar este tipo de tráfico básico.

Intento 2: Ataque Man-In-The-Middle (ARP Spoofing)

Decidí escalar el ataque mediante una técnica de Envenenamiento de Tablas ARP. El objetivo era engañar al router para que pensara que mi PC era el teléfono, y al teléfono para que pensara que mi PC era el router.

Utilicé la herramienta arpspoof en dos terminales:

sudo arpspoof -i interfaz -t 192.168.0.109 192.168.0.1 (Engañando al teléfono).
sudo arpspoof -i interfaz -t 192.168.0.1 192.168.0.109 (Engañando al router).

Al interceptar el tráfico, simplemente desactivé el reenvío de paquetes en mi kernel (ip_forward=0), convirtiendo mi pc en un "agujero negro" para sus datos. Sin embargo, mi tarjeta de red inalámbrica no soportó el volumen de paquetes y el ataque no fue persistente.

Intento 3: Saturación de Capa 4 (TCP SYN Flood), la tercera es la vencida.

Al ver que los métodos anteriores fallaban, utilicé uno mas rudo: hping3. A diferencia del ping común (Capa 3), este ataque se enfoca en la Capa de Transporte (Capa 4), específicamente en el protocolo TCP.

sudo hping3 -S -p 80 --flood 192.168.0.120

¿Por qué funcionó este método?

Modo Flood: Envía paquetes a la máxima velocidad posible sin esperar respuesta, saturando el ancho de banda.
Flag SYN (-S): Envía peticiones de inicio de conexión. El dispositivo de la víctima se ve obligado a reservar memoria para cada conexión falsa que yo inicio. Al recibir millones de estas peticiones, el procesador del teléfono colapsa intentando gestionarlas todas.
Puerto 80: Al atacar el puerto estándar de navegación web, el dispositivo no puede ignorar el tráfico fácilmente.

El resultado fue inmediato: el teléfono de los invitados se quedó sin recursos para mantener la conexión de YouTube. La música se cortó definitivamente y, ante la frustración de no tener conexión, finalmente apagaron el radio. La victoria fue mía. Procede a reírse como un villano.

¿Qué es la Terminal, la Línea de Comandos (CLI) y el Shell?

Friedrich Ruiz — Tue, 18 Nov 2025 02:01:08 +0000

Mucha gente usa los términos "terminal", "línea de comandos" y "shell" como si fueran lo mismo, pero no lo son. Entender la diferencia es clave para saber qué estás haciendo realmente.

Vamos a aclararlo con una analogía simple:

La Terminal es la aplicación que abres. Es la "ventana" (como el Terminal de Windows, iTerm2 en Mac, o GNOME Terminal en Linux).
El Shell es el programa que corre dentro de la terminal. Es el "cerebro" que interpreta tus comandos (ej: bash, zsh, fish).
La Línea de Comandos (CLI) es el método de interactuar. Es la interfaz (la pantalla negra con un cursor) donde escribes texto. Es lo opuesto a una GUI (Interfaz Gráfica de Usuario) donde usas un mouse.

En resumen: Abres la Terminal para usar un Shell a través de su Línea de Comandos.

El Shell: El Intérprete de Comandos

Cuando escribes un comando, la terminal no lo entiende. Simplemente pasa ese texto al Shell. El Shell es el programa que lee el comando, lo interpreta y le dice al sistema operativo (Linux, macOS, etc.) qué hacer.

Bash (Bourne Again SHell)

La terminal que venia por defecto en la mayoría de sistemas Linux y macOS durante décadas. Es el estándar de la industria.

Comandos Básicos de Bash

Aquí tienes los comandos esenciales para moverte.

pwd (Print Working Directory): Imprime el directorio (carpeta) actual donde estás trabajando.
cd (Change Directory): Te permite cambiar de directorio.
- cd nombre_carpeta (Entra a una carpeta)
- cd .. (Sube un nivel, al directorio padre)
- cd ~ o solo cd (Te lleva a tu directorio "Home" o principal)
ls (List): Lista el contenido de la carpeta de trabajo actual.
- ls -a (Muestra todos los archivos, incluyendo los ocultos como .env).
- ls -l (Muestra la "lista larga", con permisos, dueño, tamaño y fecha).
cat vs less: Para ver el contenido de un archivo.
- cat archivo.txt: Imprime todo el contenido del archivo en la terminal. Es rápido, pero inútil si el archivo es muy largo.
- less archivo.txt: Es un "paginador". Te permite ver el contenido de archivos grandes de forma interactiva (puedes subir, bajar y buscar). Es mucho más útil.
mkdir (Make Directory): Permite crear carpetas (ej: mkdir nuevaCarpeta).
touch: Crea un archivo nuevo y vacío (ej: touch readme.md).
mv (Move): Te permite mover un archivo O renombrarlo.
- mv archivo.txt /otra/carpeta/ (Mover)
- mv archivo_viejo.txt archivo_nuevo.txt (Renombrar)
cp (Copy): Copia un archivo o directorio. A diferencia de mv, no elimina el original.
- cp archivo.txt /otra/carpeta/
- cp -r mi_directorio /otra/carpeta/ (Para copiar un directorio, necesitas el argumento -r de "recursivo").
rm (Remove): Elimina un archivo.
- rm -r mi_directorio/ (Elimina una carpeta y todo lo que tiene dentro).
- ¡ADVERTENCIA! rm no tiene "papelera de reciclaje". Una vez que lo usas, la información se pierde. Ten mucho cuidado, especialmente con rm -rf (-f fuerza la eliminación sin preguntar), ya que es un comando muy destructivo.
echo: Toma un argumento de texto (string) y lo imprime en la terminal. Es muy útil para crear o añadir texto a archivos.
- echo "Hola" > readme.md (Crea o sobrescribe el archivo).
- echo "Adios" >> readme.md (Usa >> para agregar al final del archivo).
man (Manual): Muestra el manual de cualquier comando.
- man ls (Te mostrará todas las opciones posibles para ls).

¿Qué son las Opciones y Argumentos?

Puedes pasarle argumentos (parámetros) u opciones (flags) a un comando para afectar la manera en la que actúa.

2 Guiones (Forma Larga o "Human-Readable")

Son fáciles de entender. Por ejemplo, ls --all es lo mismo que ls -a.

1 Guion (Forma Corta o "POSIX")

Usan una sola letra. La gran ventaja es que permite "encadenar" múltiples argumentos.

En lugar de escribir:
ls --all --human-readable --size

Puedes agruparlos de la siguiente manera:
ls -ahs

Control de Procesos

Ctrl+C (Interrumpir): "Mata" o detiene el proceso que se está ejecutando en primer plano (ej: un script).
Ctrl+Z (Suspender): "congela" el proceso actual y lo envía al background (segundo plano). Puedes ver los procesos suspendidos con jobs y traerlos de vuelta con fg (foreground).

Organizador de carpetas hecho en python

Friedrich Ruiz — Fri, 07 Nov 2025 05:02:04 +0000

Seguramente al abrir tu carpeta de descargas o cualquier otra te encuentras con una cantidad incontable de archivos de diferente tipos (imagenes, documentos, instaladores, etc) mezclados y te ha tocado buscar desesperadamente ese pdf que contiene la tarea que te hizo chatgpt, tardando un tiempo considerable y pensando 'que flojera', o teniendo que ordenar 20 pdf, 10 imagenes y 5 instaladores manualmente. Yo tambien habia pasado por esto, y por eso decedí crear un script que me permitiera seguir vagueando mientras mis archivos estan perfectamente ordenados.
Este script que utiliza python hace ese trabajo por mi. Puedes verlo directamente Github

Como funciona el script

Para construir esta herramienta use varias librerias de Python, algunas que ya vienen incluidas ("biblioteca éxtandar") y una externa para que me notifique cuando el script se esta ejecutando.

Paso 1: las importaciones

import os
import shutil
import sys
from win10toast import ToastNotifier

os (Operating System): Nos permite verificar si un archivo o carpeta existe (os.path.exists), crear carpetas (os.makedirs), listar todos los archivos (os.listdir) y obtener la extensión de un archivo (os.path.splitext).
shutil (Shell Utilities): Nos permite mover archivos de un lugar a otro (shutil.move()).
sys (System): sys.executable me permite saber dónde se está ejecutando el script, lo cual es muy útil si se compila en un archivo .exe.
ToastNotifier (de win10toast): Esta es la librería externa. Es la que nos permite enviar notificaciones nativas a Windows. Se instala con pip install wintoast.

Paso 2: Mapa de archivos

Se crea un diccionario que actúa como un mapa, donde cada clave es el nombre de la carpeta que queremos crear (ej. "imagenes") y el valor es una lista de todas las extensiones de archivo que deben ir dentro de dicha carpeta.

notificar = ToastNotifier() # Inicializamos el notificador
tipos_de_archivo = {
    "imagenes": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg"],
    "videos": [".mp4", ".avi", ".mov", ".mkv", ".webm"],
    "documentos": [".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx"],
    "ejecutables y sistema": [".exe", ".msi", ".bat", ".dll"],
    "comprimidos": [".zip", ".rar", ".7z", ".iso"],
    # ...y así con todas las demás categorías...
    "Otros": [] # Una categoría especial para lo que no coincida
}

Paso 3: Configuración Flexible (Leer el rutas.txt)

No quería editar el script cada vez que quisiera añadir una carpeta nueva para organizar. Por eso, hice que el script leyera un archivo de configuración rutas.txt.

Esta función abre ese archivo, lee cada línea, y si la ruta escrita existe de verdad, la añade a una lista.

def obtener_rutas(ruta_actual, archivo='rutas.txt'):
    """
    Obtener rutas escritas en el archivo config/rutas.txt
    """
    rutas_validas = []
    # Busca el archivo .txt en una carpeta 'config'
    archivo_rutas = os.path.join(ruta_actual, 'config', archivo) 
    with open(archivo_rutas, 'r', encoding='utf-8') as rutas:
        for linea in rutas:
            ruta = linea.strip() # .strip() quita espacios en blanco
            # Si la ruta no está vacía Y existe...
            if ruta and os.path.exists(ruta):
                rutas_validas.append(os.path.abspath(ruta))

    return rutas_validas

Paso 4: Manejo de duplicados

Esta es la parte más importante. ¿Qué pasa si muevo tarea.pdf a "Documentos" y ya existe un tarea.pdf dentro?

Para eso, esta la función mover_archivo.

Intenta moverlo: Si el archivo no existe en el destino, simplemente lo mueve (shutil.move).
Si ya existe:

1- Crea una carpeta llamada "DUPLICADOS".
2- Le cambia el nombre al archivo nuevo (ej. de tarea.pdf a tarea (1).pdf).
3- Busca un nombre libre (si tarea (1).pdf existe, prueba con tarea (2).pdf, y así...).
4- Mueve el archivo renombrado a la carpeta "DUPLICADOS".

def mover_archivo(origen, destino):
    try:
        if not os.path.exists(destino):
            # Ruta libre, mover normalmente
            shutil.move(origen, destino)
        else:
            # ¡Conflicto! El archivo ya existe
            carpeta_duplicados = os.path.join(os.path.dirname(destino), "DUPLICADOS")
            os.makedirs(carpeta_duplicados, exist_ok=True)

            # Lógica para encontrar un nuevo nombre (ej. "archivo (1).ext")
            contador = 1
            base, ext = os.path.splitext(os.path.basename(origen))
            nuevo_nombre = f"{base} ({contador}){ext}"
            nuevo_destino = os.path.join(carpeta_duplicados, nuevo_nombre)

            while os.path.exists(nuevo_destino):
                contador += 1
                nuevo_nombre = f"{base} ({contador}){ext}"
                nuevo_destino = os.path.join(carpeta_duplicados, nuevo_nombre)

            shutil.move(origen, nuevo_destino)
    except Exception:
        # Si algo falla (ej. archivo en uso), simplemente lo ignora
        # para que el script no se detenga.
        pass

Paso 5: Organización

Esta función es la que recorre la carpeta que le pasamos:

Lista todo con os.listdir(ruta).
Si es un archivo, busca su extensión en nuestro "mapa" (tipos_de_archivo) y lo manda a la función mover_archivo. Si no encuentra la extensión, lo manda a "Otros".
Si es una carpeta (y no es una de nuestras carpetas de categorías, como "Imagenes"), la mueve toda a una carpeta llamada "Carpetas".

def organizar_carpeta(ruta, tipos):
    for archivo in os.listdir(ruta):
        archivo_path = os.path.join(ruta, archivo)

        if os.path.isfile(archivo_path):
            # Es un archivo, buscar extensión
            extension = os.path.splitext(archivo_path)[1]
            for categoria, extensiones in tipos.items():
                if extension.lower() in extensiones:
                    destino = os.path.join(ruta, categoria, archivo)
                    break # Encontramos categoría, rompemos el bucle
            else:
                # No se encontró, va a "Otros"
                destino = os.path.join(ruta, "Otros", archivo)
            mover_archivo(archivo_path, destino)

        elif os.path.isdir(archivo_path) and not archivo in tipos.keys():
            # Es una carpeta, mover a "Carpetas"
            destino = os.path.join(ruta, "Carpetas", archivo)
            mover_archivo(archivo_path, destino)

Paso 6: Ponerlo en marcha

El bloque if name== "main": es lo que realmente ejecuta todo.

Primero, obtiene todas las rutas a organizar de nuestro rutas.txt.
Luego, hace un bucle for por cada una de esas rutas y llama a organizar_carpeta.
Al terminar, usa notificar.show_toast() para enviarme una notificación de que se ha completado la ejecución.

if __name__== "__main__":
    # ... (código para encontrar ruta_script y ruta_icon) ...

    # 1. Obtenemos las rutas del .txt
    rutas = obtener_rutas(ruta_script)

    # 2. Organizamos cada una
    for rt in rutas:
        organizar_carpeta(rt, tipos_de_archivo)

    # 3. Notificacion
    notificar.show_toast(
        "Organizador de archivos",
        "✅ ¡Archivos de la carpeta descargas organizados!",
        icon_path= ruta_icon,
        duration=10,
    )

Nota: En mi caso utilizo windows, por lo que wintoast me funciona para las notificaciones, si utilizas linux, podrias intentar utilizar otra libreria o herramienta o simplemente saltarte este paso y la importacion de wintoast.

Cómo Usarlo

Ve a mi repositorio fiedri's Toolbox en GitHub.
Asegúrate de tener Python y las librerías necesarias: pip install wintoast
Crea una carpeta config al lado del script, y dentro de ella un archivo rutas.txt.
En rutas.txt, escribe las rutas completas de las carpetas que quieres organizar (ej. C:\Users\fiedri\Downloads), una por línea.
Ejecútar

Como automatizar el script (windows)

Para hacer que el script se ejecutara solo, sin tener que hacer nada. La forma más fácil es usar el Programador de Tareas (Task Scheduler).

Busca "Programador de Tareas" en el menú de inicio de Windows.
En el panel de la derecha, haz clic en "Crear Tarea Básica...".
Le pones un nombre y eliges cuándo quieres que se ejecute. Yo lo configuré para que corra semanalmente a una hora en la que sé que la PC estará encendida.
Elige "Iniciar un programa".
Configuración:
- En "Programa/script", busca y selecciona tu python.exe (suele estar en C:\Python310\python.exe).
- En "Agregar argumentos", pega la ruta completa al script: C:\ruta\a\tu\organizer_downloads_auto.py.
- Opcional: Si compilaste el script a un .exe (lo que yo hice), solo tienes que poner la ruta a ese .exe en "Programa/script" y listo.

¿Qué Son los Genéricos?

Friedrich Ruiz — Sun, 02 Nov 2025 02:02:22 +0000

En programacion muchas veces requerimos crear componentes (como funciones, clases o estructuras de datos) que realicen la misma lógica con diferentes tipos de datos.

Por ejemplo: una funcion que invierte el orden de los elementos en un array. Esta funcion utiliza la misma logica para un array de numeros que para un array de textos o un array de objetos

Si se define la funciona con tipos especificos (ej: number):

function invertir(input: Array<number>): Array<number> {
    // ... Lógica de inversión
}

Esta función no puede ser reutilizada para Array<string>. Tendrías que duplicar el código para cada tipo, lo que genera rigidez y mantenimiento complejo.

Algunos lenguajes, como por ejemplo typescript, permiten el uso de los tipos comodin, estos serian una solucion. Solo que al utilizar un tipo generico o any, pierdes la seguridad. El compilador ya no puede verificar si estás llamando a la función correctamente o si estás intentando, por ejemplo, sumar un número con un texto.

la mejor solucion:

Los Genéricos son una herramienta de la programación orientada a objetos que resuelve el problema de la rigidez sin sacrificar la seguridad de tipos.

Definición

Un genérico es un marcador de posición de tipo (a menudo llamado T por Type) que se define al crear un componente (función, clase).

Esto permite escribir componentes que pueden:

Trabajar con cualquier tipo de dato.
Mantener la información del tipo de dato hasta el momento de la ejecución (o compilación).

Implementación Conceptual

Al crear un componente, se introduce una "variable de tipo" (el genérico) usando una notación especial (comúnmente los corchetes angulares, < >):

// Función GENÉRICA
function invertir<T>(input: Array<T>): Array<T> {
    // La lógica aquí funciona para cualquier tipo T
    // ...
}

Uso

Al llamar a la función, el compilador "sustituye" la T por el tipo real que se está pasando, lo que garantiza la seguridad en toda la ejecución.

Código de Llamada	El Compilador Entiende	Seguridad
`invertir<string>(["a", "b"])`	`string` se sustituye por `T`	Espera `string[]`, devuelve `string[]`. ✅ Seguro.
`invertir<number>([1, 2])`	`number` se sustituye por `T`	Espera `number[]`, devuelve `number[]`. ✅ Seguro.
`invertir([obj1, obj2])`	(El compilador infiere el tipo)	Determina el tipo de objeto. ✅ Seguro.

En Resumen: El Valor de los Genéricos

Característica	Propósito
Reutilización	Escribir la lógica una sola vez para múltiples tipos.
Seguridad de Tipos	El compilador garantiza que los tipos de entrada y salida coincidan.
Flexibilidad	El componente no se compromete con un tipo específico hasta que es utilizado.