Cómo crear un archivo Swap en Linux

Para este ejemplo, crearemos un archivo de 4 GB (puedes cambiar el número si necesitas más o menos espacio). Tienes que ejecutar estos comandos como superusuario (sudo).

1.Asignar el espacio para el archivo:Paso 1.

Crea un archivo vacío del tamaño deseado. Usaremos dd porque asegura que los bloques de disco se asignen de forma contigua y real:

Bash

sudo dd if=/dev/zero of=/swapfile bs=1G count=4 status=progress

(Esto creará un archivo llamado swapfile de 4 GB en la raíz de tu sistema).

2.Asegurar los permisos (Crítico):Paso 2.

Por seguridad, la memoria Swap solo debe ser accesible por el sistema (root). Si otros usuarios pueden leerla, podrían ver datos sensibles de la RAM:

Bash

sudo chmod 600 /swapfile

3.Formatear el archivo como Swap:Paso 3.

Dile al sistema operativo que prepare ese archivo específico para ser usado como memoria de intercambio:

Bash

sudo mkswap /swapfile

4.Activar la nueva Swap:Paso 4.

Enciende el archivo Swap para que el sistema empiece a usarlo inmediatamente:

Bash

sudo swapon /swapfile

¿Cómo comprobar que ya funciona?

Para verificar que tu sistema ha sumado esos nuevos 4 GB de Swap, corre cualquiera de estos comandos:

Bash

free -h
# O también:
sudo swapon --show

Hacer que el cambio sea permanente

Si reinicias el ordenador ahora mismo, el archivo se apagará y no se cargará solo. Para que Linux lo active automáticamente en cada arranque, debemos añadirlo al archivo de configuración de discos fstab.

1. Abre el archivo de configuración:

   Bash

   sudo nano /etc/fstab
   

2. Ve hasta el final del todo y añade esta línea en una nueva línea limpia:

   Plaintext

   /swapfile none swap sw 0 0
   

3. Guarda (Ctrl + O, luego Intro) y sal (Ctrl + X).

¿Y si en el futuro lo quiero borrar o cambiar de tamaño?

Es tan fácil como apagarlo y borrar el archivo. Haces esto:

Bash

sudo swapoff /swapfile  # Lo apagas
sudo rm /swapfile       # Lo borras

(Y recuerdas borrar la línea que añadiste en /etc/fstab si hiciste el cambio permanente).

 

Análisis forense del contenido de la RAM en GNU/Linux: foremost y scalpel

 

Tanto foremost como scalpel son herramientas clásicas y extremadamente potentes en el mundo del análisis forense digital y la recuperación de datos en Linux. Su especialidad es una técnica llamada File Carving (tallado de archivos).

Cuando haces un volcado de la memoria RAM (un archivo .raw, .dmp o .img que contiene gigabytes de datos puros en binario), no hay una estructura de carpetas ni un índice que te diga dónde empieza o termina un archivo. Todo es un "mar" continuo de unos y ceros.

Aquí te explico cómo funcionan y cómo se usan específicamente para buscar tesoros ocultos dentro de un volcado de RAM.

El secreto de su funcionamiento: Las firmas de archivos

Tanto foremost como scalpel no leen el contenido de la memoria como lo haría un humano; buscan números mágicos (magic numbers), que son firmas de bytes únicas que los sistemas operativos colocan al principio y al final de cada tipo de archivo.

• Un archivo PDF siempre empieza por los bytes en hexadecimal 25 50 44 46 (%PDF).

• Un archivo PNG siempre empieza por 89 50 4E 47 (.PNG).

Las herramientas escanean el archivo de la RAM de arriba a abajo. Cuando encuentran una firma de inicio, abren un grifo y empiezan a guardar datos en un archivo nuevo en tu disco duro hasta que encuentran la firma de cierre de ese formato (o hasta que alcanzan un límite de tamaño máximo configurado).

1. Foremost: El explorador automático y rápido

foremost es la herramienta ideal para empezar porque es muy sencilla de usar, automática y requiere muy poca configuración. Viene con una base de datos interna de formatos comunes ya preconfigurada.

Cómo usarlo para analizar un volcado de RAM:

Supongamos que ya has hecho un volcado de la RAM de tu navegador o de todo el sistema y lo has guardado en un archivo llamado memoria_ram.raw.

Para procesarlo con foremost, abre tu terminal de Linux y ejecuta:

Bash

foremost -t pdf,png,jpg -i memoria_ram.raw -o /home/diego/Escritorio/extraccion_ram

Desglose del comando:

• -t: Especifica los tipos de archivos que quieres buscar (separados por comas). Si quieres buscar todo lo que reconozca, puedes poner -t all.

• -i: El archivo de entrada (input), que es tu volcado de RAM.

• -o: La carpeta de salida (output) donde foremost creará carpetas automáticas (/pdf, /png, etc.) con todo lo que logre rescatar de la RAM.

2. Scalpel: El bisturí de precisión quirúrgica

scalpel nació originalmente como una optimización de foremost. Es mucho más eficiente con el uso de la memoria de tu propia máquina y es el preferido cuando el archivo de la RAM es gigantesco (decenas de gigabytes), ya que realiza el escaneo en pasadas mucho más rápidas.

La principal diferencia es que scalpel te obliga a revisar su archivo de configuración antes de trabajar, porque por defecto viene con todos los formatos de archivo desactivados (comentados).

Paso 1: Configurar el bisturí

Antes de ejecutarlo, tienes que abrir su archivo de configuración (normalmente en /etc/scalpel/scalpel.conf) con tu editor de texto favorito:

Bash

sudo nano /etc/scalpel/scalpel.conf

Verás una lista enorme de líneas como esta:

Plaintext

# pdf   y   5000000   \x25\x50\x44\x46   \x25\x25\x45\x4F\x46

Para activar la búsqueda de PDFs, tienes que quitar el símbolo # (descomentar la línea). Esa línea le dice a scalpel: "Busca archivos PDF, que tienen un tamaño máximo de 5MB, empiezan por \x25\x50\x44\x46 y terminan en \x25\x25\x45\x4F\x46". Guarda el archivo (Ctrl+O y Ctrl+X).

Paso 2: Ejecutar el escaneo

Una vez configurado lo que buscas, ejecutas el comando:

Bash

scalpel -o /home/diego/Escritorio/extraccion_scalpel memoria_ram.raw

(Nota: A diferencia de foremost, en scalpel no hace falta poner -i, el archivo de la RAM se pone simplemente al final).

⚖️ ¿Cuál deberías usar para analizar la RAM?

Característica	Foremost	Scalpel
Facilidad	⭐⭐⭐⭐⭐ (Listo para usar)	⭐⭐⭐ (Requiere editar el .conf)
Rendimiento	Pesado con archivos muy grandes	Muy rápido y eficiente con la CPU/RAM
Personalización	Más rígido	Permite definir tamaños máximos exactos

El gran problema del Carving en la RAM (La fragmentación)

Hay algo muy importante que debes tener en cuenta al usar estas herramientas con la RAM: la fragmentación. La memoria RAM guarda los datos en pequeños bloques dispersos (páginas de memoria). Si el archivo que buscas (por ejemplo, un vídeo de un blob:https:) era muy grande, es muy probable que sus datos no estuvieran seguidos en la RAM, sino repartidos en "islas" de memoria.

Tanto foremost como scalpel asumen que los archivos son contiguos (que todo el archivo está del tirón). Por eso, al analizar la RAM, es muy común que muchos archivos extraídos te salgan corruptos o cortados por la mitad. ¡Aun así, para rescatar imágenes, textos, fragmentos de código o PDFs indexados en memoria, son herramientas mágicas!

El fin del APK libre (como lo conocíamos): Cómo seguir usando tus propias apps caseras tras el cambio de Google

Si eres de los que disfruta programando sus propias herramientas, automatizando tareas o, como en mi caso, creando una aplicación "hecha a mano" para simplificar las farragosas operaciones con el banco, seguro que has escuchado los rumores. En internet se habla de un "bloqueo masivo", de que Google va a borrar apps y de que Android va a cerrarse al más puro estilo iOS.

¿Qué hay de verdad en todo esto? ¿Vamos a quedarnos sin el placer de instalar nuestro propio software?

La respuesta corta es no, pero las reglas del juego cambian. A partir de septiembre de este año (2026), Google va a endurecer drásticamente las políticas de Google Play Protect. Si tienes apps propias en tu móvil o planeas seguir programando para ti, esto es exactamente lo que necesitas saber para que tu teléfono siga siendo tuyo.

¿Qué va a pasar realmente en septiembre de 2026?

Google no va a entrar de forma remota en tu smartphone a borrar lo que ya tienes instalado. El cambio real está en la verificación de desarrolladores.

Hasta ahora, cualquiera podía compilar un archivo .apk, pasárselo a un amigo o instalarlo en su propio dispositivo con solo activar el interruptor de "Orígenes desconocidos". A partir de septiembre, Google Play Protect exigirá que los desarrolladores estén plenamente identificados y verificados con documentos oficiales.

Si intentas instalar un APK nuevo que no venga firmado por un desarrollador verificado, Play Protect bloqueará la instalación de forma fulminante o te inundará con advertencias de seguridad tan agresivas que asustarían a cualquiera. Esto busca frenar el malware, pero, de rebote, deja en el limbo a los desarrolladores independientes y a quienes programamos por puro hobby.

Guía de supervivencia: Cómo seguir instalando tus apps "hechas a mano"

Si tienes una app propia que necesitas actualizar, o si estás diseñando una nueva herramienta local, no te rindas. Android sigue siendo Android y mantiene vías de escape para los creadores de software. Aquí tienes los tres métodos para saltarte el bloqueo:

Método 1: El puente de mando (Instalación vía ADB)

Este es el método más limpio, seguro y el que yo personalmente recomiendo si programas en tu ordenador. Cuando instalas una app a través de las herramientas de desarrollo, el sistema operativo asume que sabes lo que haces.

1. Activa las Opciones de Desarrollador en tu móvil (ve a Ajustes > Información del teléfono y pulsa 7 veces sobre "Número de compilación").

2. Entra al nuevo menú de desarrolladores y activa la Depuración por USB.

3. Conecta el móvil al ordenador y, usando la consola de comandos (o terminal), instala tu app directamente con el comando: adb install tu_aplicacion.apk

Las aplicaciones instaladas por esta vía suelen esquivar las restricciones más duras de Play Protect porque el sistema detecta que es una instalación de entorno de pruebas (debug).

Método 2: Compilar siempre en Modo Debug

Si sueles exportar el APK para pasártelo a ti mismo por Telegram, Drive o cable, asegúrate de cómo lo compilas. Google Play Protect se ensaña especialmente con los APKs compilados en modo Release (listos para producción) que no tienen firma digital. Si compilas tu proyecto en modo Debug desde Android Studio, el archivo resultante llevará una firma provisional de desarrollo. El sistema seguirá avisándote de que la app es "desconocida", pero por ahora suele ofrecer un botón de "Instalar de todos modos".

Método 3: La opción nuclear (Apagar el guardián)

Si solo quieres probar algo rápido y el sistema no te deja avanzar, puedes desactivar temporalmente el análisis de la tienda:

1. Abre Google Play Store y toca tu foto de perfil.

2. Entra en Play Protect y pulsa el icono de la rueda dentada (Ajustes) en la esquina superior derecha.

3. Desactiva la casilla "Analizar aplicaciones con Play Protect".

Nota: Haz esto bajo tu propio riesgo y solo mientras instalas tu app. Es recomendable volver a activarlo después para mantener el móvil protegido contra amenazas reales de internet.

Un aviso importante si trabajas con datos bancarios

Si tu app casera interactúa con la API de tu banco, hace web scraping de tus cuentas para ahorrarte pasos o lee notificaciones de transacciones, ten en cuenta que el enemigo no es solo Google.

Hoy en día, las aplicaciones bancarias oficiales son extremadamente sensibles. Si detectan que tienes las Opciones de Desarrollador activadas o que hay una aplicación de origen desconocido interactuando con la accesibilidad de la pantalla, el propio sistema de seguridad del banco podría bloquear tus cuentas de forma preventiva para evitar fraudes (phishing). Si vas a usar el Método 1, recuerda desactivar la depuración USB cuando termines de instalar tu app para evitar sorpresas con la app de tu banco.

Conclusión: El software libre se vuelve un poco más burocrático

Android no ha muerto para los desarrolladores caseros, pero la época de la "libertad absoluta con un solo clic" se está terminando. Google está vallando el jardín, obligándonos a usar las herramientas de desarrollo profesionales (ADB) incluso para las tareas más sencillas de nuestro día a día.

Cómo limitar el tamaño de un archivo en Linux para que no crezca indefinidamente

 

Hay varias formas de limitar el tamaño de un archivo en Linux para que no crezca indefinidamente y mantenga solo los datos más recientes (comportamiento tipo "buffer circular" o "ring buffer"). Aquí te muestro las soluciones más prácticas y usadas en 2025-2026 para tu caso concreto:

Bash

python programa.py > salida_limitada.output

Queremos que salida_limitada.output nunca supere ~2 MB y que elimine contenido antiguo automáticamente.

Opciones recomendadas (de más sencilla a más robusta)

1. La más fácil y directa (recomendada para la mayoría de casos)

Usa tail + sponge (del paquete moreutils):

Bash

# Instalar moreutils si no lo tienes
sudo apt install moreutils    # Debian/Ubuntu
sudo dnf install moreutils    # Fedora
sudo pacman -S moreutils      # Arch

# Ejecución
python programa.py | tail -c 2M | sponge salida_limitada.output

Ventajas:

• Muy simple
• Mantiene exactamente los últimos 2 MB (o un poco menos si corta a mitad de línea)
• El archivo nunca crece más de ~2 MB

Variante más bonita (mantiene líneas completas):

Bash

python programa.py | tail -n 50000 | sponge salida_limitada.output

(ajusta el número de líneas según tu caso — 50.000 líneas suelen caber en < 2 MB en la mayoría de logs)

2. Usando stdbuf + tail (sin moreutils)

Bash

stdbuf -oL python programa.py | tail -c 2M > salida_limitada.output

No es perfecto porque > trunca el archivo cada vez → puede perder datos si el programa escribe muy rápido. La opción con sponge es superior.

3. La opción más profesional y usada en producción: logrotate con copytruncate y size

Crea este archivo (por ejemplo):

Bash

sudo nano /etc/logrotate.d/salida_manual

Contenido:

text

/ruta/completa/salida_limitada.output {
    size 2M
    rotate 1
    copytruncate
    missingok
    notifempty
}

Luego puedes forzar la rotación manualmente cuando quieras:

Bash

logrotate -f /etc/logrotate.d/salida_manual

O dejar que se ejecute automáticamente (normalmente cada día).

Ventaja: sistema muy robusto, usado por casi todos los servicios de Linux.

4. Script bash muy simple (buen compromiso)

Bash

#!/usr/bin/env bash
# guardar como: limit_output.sh
# chmod +x limit_output.sh

MAX_SIZE=$((2*1024*1024))  # 2 MiB
FILE="salida_limitada.output"

# Si el archivo existe y es > 2MB → truncamos a las últimas 2MB
if [[ -f "$FILE" && $(stat -c %s "$FILE") -gt $MAX_SIZE ]]; then
    tail -c $MAX_SIZE "$FILE" > "$FILE.tmp" && mv "$FILE.tmp" "$FILE"
fi

# Añadimos la nueva salida al final
cat >> "$FILE"

Uso:

Bash

python programa.py | ./limit_output.sh

O en una sola línea:

Bash

python programa.py | tee -a salida_limitada.output | awk -v f=salida_limitada.output -v max=2097152 'BEGIN{ s=0 } {s+=length($0)+1} s>max{ system("tail -c "max" "f" > "f".tmp && mv "f".tmp "f); s=max }'

(versión compacta pero menos legible)

Resumen — ¿Qué te recomiendo según tu caso?

Situación	Recomendación principal	Comando sugerido (2 MB)
Uso rápido, pruebas, una sola ejecución	tail + sponge	python programa.py | tail -c 2M | sponge salida_limitada.output
Quieres líneas completas	tail -n XXXX + sponge	tail -n 40000 (ajustar número)
Uso prolongado / producción	logrotate con size + copytruncate	Ver configuración arriba
No quieres instalar nada	Script bash con tail cada cierto tiempo	El script de más arriba
Quieres algo muy muy ligero	tail -c 2M > salida_limitada.output (pierde datos intermedios)	No recomendado si el programa escribe continuamente

La opción tail + sponge es la que más gente usa hoy en día para este caso concreto de redirección simple.