En Linux, cada archivo tiene un dueño (usuario), un grupo, y un conjunto de permisos.
Modificar todo eso es fácil… demasiado fácil si usas root sin cabeza.

Vamos a verlos uno por uno.

1. chown → Cambiar el dueño del archivo

La sintaxis es:

chown usuario archivo

Ejemplo simple:

sudo chown juan /var/www/html/index.html

Ahora Juan es el dueño de ese archivo.

Si quieres cambiar usuario y grupo:

sudo chown juan:profesores documento.txt

Cambiar solo el grupo:

sudo chown :profesores documento.txt

Cambiar de forma recursiva (carpeta entera):

sudo chown -R juan:juangroup /home/juan

chown es “Change Owner”: cambia quién manda sobre el archivo.

2. chgrp → Cambiar solo el grupo

Es más específico que chown:

sudo chgrp alumnos proyecto.txt

La idea es sencilla:
Cuando tienes un archivo, pueden mandar sobre él:

• tú como usuario
• o cualquiera de tu grupo asociado

chgrp te deja decidir ese segundo nivel.

3. chmod → Cambiar los permisos

Aquí empieza el festival de números y letras. Tus alumnos suelen entenderlo mejor si usas una metáfora de puertas.

Cada archivo tiene permisos divididos en tres bloques:

u g o
user group others

Y cada uno tiene:

• r → read (leer)
• w → write (escribir)
• x → execute (ejecutar)

Dos formas de usar chmod:

A) Modo numérico (octal)

Es el clásico:

chmod 755 archivo

Por qué 7, 5 y 5?
Porque cada permiso suma:

• r = 4
• w = 2
• x = 1

Ejemplos:

• 7 = rwx (4+2+1)
• 6 = rw- (4+2)
• 5 = r-x (4+1)
• 4 = r– (4)

Ejemplos prácticos:

Permiso para que usuario pueda todo, grupo y otros solo leer:

chmod 744 informe.txt

Permiso de ejecución para usuario y grupo:

chmod 770 script.sh

Modo más típico para scripts:

chmod 755 script.sh

B) Modo simbólico (con letras)

Más legible:

Dar ejecución al usuario:

chmod u+x script.sh

Quitar escritura a otros:

chmod o-w archivo.txt

Dar permisos de lectura y escritura al grupo:

chmod g+rw proyecto

Ejemplo 1: carpeta compartida para un grupo

sudo mkdir /compartido
sudo chgrp alumnos /compartido
sudo chmod 770 /compartido

Todo el grupo “alumnos” puede usarla.

Ejemplo 2: permitir que un usuario edite su web

sudo chown -R juan:www-data /var/www/juan
sudo chmod -R 750 /var/www/juan

Explicación para los estudiantes:

• Juan puede leer/escribir.
• El servidor (www-data) puede leer.
• Nadie más puede entrar.

Ejemplo 3: archivo ejecutable para todos

chmod a+x programa.sh

a significa all (todos los usuarios).

Ejemplo 4: bloquear totalmente un archivo

chmod 000 documento.txt

Solo root podrá tocarlo.

¿Cómo enlazar esto con la lección de root?

Un usuario normal solo puede cambiar permisos y dueños de lo que le pertenece.
Root puede cambiar todo, lo que lo convierte en una herramienta poderosa… o en un desastre en manos torpes.

sudo chown root:root /home/alumno1
sudo chmod 700 /home/alumno1

Acabas de expulsar a alumno1 de su propia casa.
Es un experimento divertido para enseñar responsabilidad… o para que entiendan por qué root no es una buena costumbre.

Resumen

• chown → cambia el dueño del archivo y su grupo
• chgrp → cambia solo el grupo
• chmod → cambia los permisos (r, w, x) en user/group/others
• root puede cambiarlo todo
• usuarios normales solo pueden cambiar sus propios archivos

La estación espacial Andrómeda necesita organizar a su tripulación.
Hay tres equipos principales:

• pilotos
• ingenieros
• cientificos

Cada miembro de la tripulación tendrá acceso solo a determinadas carpetas según su grupo.
Además, el comandante de la estación deberá poder reorganizar la tripulación, cambiar usuarios de grupo y ajustar propietarios y permisos de archivos.

Tu misión será convertirte en el administrador del sistema de la estación.

1. Objetivos de la práctica

Al finalizar esta práctica, el alumno será capaz de:

• crear usuarios en Ubuntu,
• crear grupos de usuarios,
• añadir usuarios a grupos,
• cambiar un usuario de grupo,
• comprobar a qué grupos pertenece un usuario,
• crear carpetas para distintos equipos,
• asignar propietario y grupo a carpetas y archivos,
• modificar permisos con chmod,
• utilizar chown para cambiar propietario y grupo,
• verificar que los permisos funcionan correctamente.

2. Qué vas a aprender

En Linux, cada archivo y carpeta tiene asociado:

• un propietario,
• un grupo,
• unos permisos.

Los permisos se pueden definir para:

• u → usuario propietario,
• g → grupo,
• o → otros usuarios.

Y los permisos básicos son:

• r → lectura,
• w → escritura,
• x → ejecución o acceso.

3. Preparación inicial

Antes de empezar, abre una terminal y asegúrate de trabajar con un usuario con permisos de administración.

Puedes comprobarlo con:

whoami

Y probar que tienes permisos de sudo con:

sudo -v

4. Crear los grupos de la estación

Vamos a crear los tres grupos principales de la tripulación.

sudo groupadd pilotos
sudo groupadd ingenieros
sudo groupadd cientificos

Comprobar que los grupos existen

getent group pilotos
getent group ingenieros
getent group cientificos

Esto mostrará información del grupo si se ha creado correctamente.

5. Crear los usuarios de la tripulación

Ahora vamos a crear varios usuarios.

Equipo de pilotos

sudo useradd -m -s /bin/bash luke
sudo useradd -m -s /bin/bash leia

Equipo de ingenieros

sudo useradd -m -s /bin/bash data
sudo useradd -m -s /bin/bash scotty

Equipo de científicos

sudo useradd -m -s /bin/bash ripley
sudo useradd -m -s /bin/bash spock

Explicación

• useradd crea el usuario.
• -m crea su carpeta personal en /home.
• -s /bin/bash asigna Bash como shell.

6. Asignar contraseña a los usuarios

Para que estos usuarios puedan iniciar sesión, asígnales una contraseña.

sudo passwd luke
sudo passwd leia
sudo passwd data
sudo passwd scotty
sudo passwd ripley
sudo passwd spock

Puedes usar una contraseña sencilla solo para la práctica, por ejemplo:

Clave123*

7. Añadir usuarios a sus grupos

Ahora asignamos cada usuario a su equipo.

sudo usermod -aG pilotos luke
sudo usermod -aG pilotos leia

sudo usermod -aG ingenieros data
sudo usermod -aG ingenieros scotty

sudo usermod -aG cientificos ripley
sudo usermod -aG cientificos spock

Explicación importante

• usermod modifica un usuario.
• -aG añade el usuario a uno o varios grupos sin borrar los grupos anteriores.

8. Comprobar a qué grupos pertenece cada usuario

Usa alguno de estos comandos:

groups luke
groups leia
groups data
groups scotty
groups ripley
groups spock

O también:

id luke
id data
id spock

Esto permite ver:

• el UID del usuario,
• el GID principal,
• los grupos a los que pertenece.

9. Crear la estructura de carpetas de la estación

Vamos a crear una zona común de trabajo para la estación.

sudo mkdir -p /srv/andromeda/pilotos
sudo mkdir -p /srv/andromeda/ingenieros
sudo mkdir -p /srv/andromeda/cientificos
sudo mkdir -p /srv/andromeda/comun

Verificar la estructura creada

ls -l /srv
ls -l /srv/andromeda

10. Asignar propietario y grupo a las carpetas

Ahora vamos a asociar cada carpeta con su grupo correspondiente.

sudo chown root:pilotos /srv/andromeda/pilotos
sudo chown root:ingenieros /srv/andromeda/ingenieros
sudo chown root:cientificos /srv/andromeda/cientificos
sudo chown root:root /srv/andromeda/comun

Explicación

Con chown puedes cambiar:

• el propietario,
• el grupo,
• o ambos.

En este caso:

• el propietario será root,
• el grupo será el del equipo correspondiente.

La sintaxis es:

sudo chown propietario:grupo ruta

sudo chown luke:pilotos archivo.txt

sudo chgrp pilotos archivo.txt

11. Asignar permisos a las carpetas

Queremos que cada grupo pueda entrar en su carpeta, leer y escribir en ella, pero que otros no puedan acceder.

sudo chmod 770 /srv/andromeda/pilotos
sudo chmod 770 /srv/andromeda/ingenieros
sudo chmod 770 /srv/andromeda/cientificos
sudo chmod 777 /srv/andromeda/comun

Explicación de los permisos

770

• propietario: rwx
• grupo: rwx
• otros: ---

777

• propietario: rwx
• grupo: rwx
• otros: rwx

La carpeta comun será accesible para todos, mientras que las otras estarán restringidas.

12. Comprobar los permisos

ls -ld /srv/andromeda/pilotos
ls -ld /srv/andromeda/ingenieros
ls -ld /srv/andromeda/cientificos
ls -ld /srv/andromeda/comun

Fíjate en algo como esto:

drwxrwx--- 2 root pilotos ...

Eso significa:

• d → es una carpeta,
• rwx → permisos del propietario,
• rwx → permisos del grupo,
• --- → permisos del resto.

13. Probar acceso con distintos usuarios

Ahora toca comprobar si realmente funciona.

Entrar como un usuario concreto

Puedes cambiar de usuario con:

su - luke

O, si prefieres, ejecutar comandos como otro usuario:

sudo -u luke ls /srv/andromeda/pilotos
sudo -u luke ls /srv/andromeda/ingenieros

Qué debería ocurrir

• luke sí debería poder entrar en /srv/andromeda/pilotos
• luke no debería poder entrar en /srv/andromeda/ingenieros

Prueba varios casos:

sudo -u luke ls /srv/andromeda/pilotos
sudo -u luke ls /srv/andromeda/ingenieros
sudo -u data ls /srv/andromeda/ingenieros
sudo -u ripley ls /srv/andromeda/cientificos
sudo -u spock ls /srv/andromeda/pilotos

Ejecuta el comando ls como si lo estuviera lanzando el usuario luke. 
-u luke Le dice a sudo que el comando no se ejecute como tu usuario actual, sino como el usuario luke.

14. Crear archivos dentro de las carpetas

Vamos a crear documentos de misión dentro de cada zona.

sudo touch /srv/andromeda/pilotos/ruta_estelar.txt
sudo touch /srv/andromeda/ingenieros/reactor.txt
sudo touch /srv/andromeda/cientificos/informe_biologico.txt
sudo touch /srv/andromeda/comun/avisos_generales.txt

Añadimos contenido:

echo "Ruta secreta al sector Omega" | sudo tee /srv/andromeda/pilotos/ruta_estelar.txt

echo "Estado del reactor principal" | sudo tee /srv/andromeda/ingenieros/reactor.txt

echo "Análisis de muestras alienígenas" | sudo tee /srv/andromeda/cientificos/informe_biologico.txt

echo "Reunión general a las 18:00" | sudo tee /srv/andromeda/comun/avisos_generales.txt

15. Cambiar propietario de un archivo con chown

Ahora vamos a usar chown de forma más clara sobre archivos.

Por ejemplo, el archivo del reactor lo va a gestionar el ingeniero data.

sudo chown data:ingenieros /srv/andromeda/ingenieros/reactor.txt

Y el informe biológico será gestionado por spock.

sudo chown spock:cientificos /srv/andromeda/cientificos/informe_biologico.txt

Verificar el cambio

ls -l /srv/andromeda/ingenieros/reactor.txt
ls -l /srv/andromeda/cientificos/informe_biologico.txt

16. Cambiar solo el grupo de un archivo

También puedes cambiar únicamente el grupo.

Por ejemplo:

sudo chown :pilotos /srv/andromeda/comun/avisos_generales.txt

Eso cambia solo el grupo, manteniendo el propietario actual.

Compruébalo:

ls -l /srv/andromeda/comun/avisos_generales.txt

17. Dar permisos concretos a los archivos

Vamos a ajustar permisos para que:

• el propietario pueda leer y escribir,
• el grupo pueda leer,
• otros no puedan acceder.

sudo chmod 640 /srv/andromeda/ingenieros/reactor.txt
sudo chmod 640 /srv/andromeda/cientificos/informe_biologico.txt
sudo chmod 664 /srv/andromeda/comun/avisos_generales.txt

Interpretación

640

• propietario: lectura y escritura
• grupo: lectura
• otros: sin permisos

664

• propietario: lectura y escritura
• grupo: lectura y escritura
• otros: lectura

18. Cambiar un usuario de grupo

Ahora viene una situación de la historia.

La comandante decide que leia deja el equipo de pilotos y pasa al equipo de ingenieros.

Primero la añadimos al nuevo grupo:

sudo usermod -aG ingenieros leia

Comprobamos sus grupos:

groups leia

Ahora leia pertenece a dos grupos: pilotos e ingenieros.

Quitarla del grupo de pilotos

Para hacerlo de forma clara en Ubuntu:

sudo gpasswd -d leia pilotos

Volvemos a comprobar:

groups leia

Ahora debería quedar solo en ingenieros además de su grupo principal.

19. Crear un nuevo usuario y asignarlo a un grupo

La estación recibe a un nuevo tripulante: neo.

sudo useradd -m -s /bin/bash neo
sudo passwd neo
sudo usermod -aG cientificos neo

Comprobar:

groups neo

20. Probar qué puede hacer cada usuario

Haz pruebas reales con comandos como estos:

sudo -u data cat /srv/andromeda/ingenieros/reactor.txt
sudo -u luke cat /srv/andromeda/ingenieros/reactor.txt
sudo -u spock cat /srv/andromeda/cientificos/informe_biologico.txt
sudo -u leia touch /srv/andromeda/ingenieros/prueba_leia.txt
sudo -u neo touch /srv/andromeda/cientificos/muestra_01.txt

Qué observar

• Un usuario del grupo correcto debería poder trabajar dentro de su carpeta.
• Un usuario de otro grupo debería recibir un error de permisos.
• Los archivos deben respetar los permisos establecidos.

21. Ver propietarios y permisos de toda la estación

Para revisar toda la estructura:

ls -lR /srv/andromeda

Esto te mostrará:

• carpetas,
• archivos,
• propietarios,
• grupos,
• permisos.

22. Recuerda

Diferencia entre propietario y grupo

• El propietario es normalmente el usuario dueño del archivo.
• El grupo permite que varios usuarios compartan acceso a archivos y carpetas.

Diferencia entre chown y chmod

• chown cambia el propietario o grupo.
• chmod cambia los permisos.

Comandos clave

Crear grupo

sudo groupadd nombre_grupo

Crear usuario

sudo useradd -m -s /bin/bash nombre_usuario

Asignar contraseña

sudo passwd nombre_usuario

Añadir usuario a grupo

sudo usermod -aG grupo usuario

Ver grupos de un usuario

groups usuario

Quitar usuario de un grupo

sudo gpasswd -d usuario grupo

Cambiar propietario y grupo

sudo chown propietario:grupo archivo_o_carpeta

Cambiar permisos

sudo chmod permisos archivo_o_carpeta

23. Actividad

Ahora que ya sabes manejar usuarios y permisos, realiza estas tareas:

Tarea 1

Crea un nuevo grupo llamado:

seguridad

Tarea 2

Crea dos usuarios nuevos:

• trinity
• morpheo

Tarea 3

Añade ambos al grupo seguridad.

Tarea 4

Crea la carpeta:

/srv/andromeda/seguridad

Tarea 5

Haz que:

• el propietario sea root,
• el grupo sea seguridad,
• los permisos sean 770.

Tarea 6

Crea dentro un archivo llamado:

protocolo_defensa.txt

Tarea 7

Haz que el archivo pertenezca a trinity:seguridad.

Tarea 8

Pon permisos 640 al archivo.

Tarea 9

Comprueba que:

• trinity puede leerlo,
• morpheo puede leerlo,
• luke no puede acceder.

25. Planteate las siguientes preguntas.

1. ¿Qué diferencia hay entre un usuario y un grupo?
2. ¿Qué hace el comando chown?
3. ¿Qué hace el comando chmod?
4. ¿Qué significa el permiso 770?
5. ¿Qué significa el permiso 640?
6. ¿Cómo se comprueba a qué grupos pertenece un usuario?
7. ¿Qué comando se usa para eliminar a un usuario de un grupo?
8. ¿Por qué es útil trabajar con grupos en lugar de dar permisos usuario por usuario?

La estación orbital Andrómeda ya está organizada.
Cada tripulante pertenece a su equipo, cada carpeta está protegida y los documentos sensibles solo son accesibles por el personal autorizado.
Has completado con éxito tu primera misión como administrador de sistemas espaciales.

Tabla de comandos y opciones principales

Tabla permisos numéricos

Cómo leer un permiso como 770

Ejemplos rápidos

En este pequeño universo, tu Linux hace de Máquina Central, un nodo que controla el flujo de información entre los humanos libres y las máquinas. Los alumnos son “operadores”, encargados de levantar accesos, crear identidades falsas, aislar directorios y conceder privilegios solo a quienes “existen dentro del sistema”.

El sistema está dividido en dos mundos:

La Superficie (usuarios sin privilegios)

El Backdoor (usuarios con acceso sudo)

La misión avanza en fases, y cada fase tiene su sentido dentro del lore.

FASE 1 — Generación de identidades (crear usuarios)

La Resistencia necesita identidades nuevas para infiltrarse en Matrix.

Cada alumno debe crear:

• 3 usuarios sin privilegios:
  • trinity
  • apoc
  • switch
• 1 usuario operador con privilegios sudo:
  • neo

“neo” deberá ser añadido al grupo sudoers.

Instrucciones sugeridas (los alumnos deben descubrir qué significan las opciones):

sudo adduser trinity
sudo adduser apoc
sudo adduser switch
sudo adduser neo
sudo usermod -aG sudo neo

Justificación narrativa:

Neo es “El Elegido”, así que puede alterar las reglas del sistema.

Los demás son “agentes infiltrados” con permisos normales.

FASE 2 — Crear grupos: Escuadrones de la Resistencia

La Resistencia funciona por células. Necesitamos 2 grupos:

• zion → humanos libres
• matrix → identidades falsas dentro del sistema

Asignación:

• trinity y neo deben estar en zion
• apoc y switch deben estar en matrix

El operador (neo) pertenece a los dos mundos, así que debe estar en ambos grupos.

sudo groupadd zion
sudo groupadd matrix

sudo usermod -aG zion neo
sudo usermod -aG zion trinity

sudo usermod -aG matrix neo
sudo usermod -aG matrix apoc
sudo usermod -aG matrix switch

Neo vive en el umbral entre los mundos. Sus permisos lo reflejan.

FASE 3 — Estructura de directorios: Los Distritos de Matrix

Se pide crear:

1. /mission-data

Carpeta para las operaciones de la Resistencia, acceso exclusivo al grupo zion.

No debe ser visible para los usuarios del grupo matrix.

2. /simulacion

Carpeta donde residirán archivos falsos del “mundo simulado”.

Acceso libre para el grupo matrix, pero solo lectura para zion (ellos no deben ensuciarse demasiado con la ilusión).

3. /backdoor

Carpeta secreta, accesible solo por neo. El resto debe recibir un “Acceso denegado”.

Comandos sugeridos:

sudo mkdir /mission-data
sudo mkdir /simulacion
sudo mkdir /backdoor

# mission-data (solo zion)
sudo chown :zion /mission-data
sudo chmod 770 /mission-data

# simulacion (matrix rwx / zion r-x)
sudo chown :matrix /simulacion
sudo chmod 775 /simulacion

# backdoor (solo neo)
sudo chown neo:neo /backdoor
sudo chmod 700 /backdoor

La carpeta backdoor representa la puerta por la que Neo accede al código subyacente de Matrix.

FASE 4 — Pruebas de acceso: El Oráculo y los obstáculos

1. Entrar con cada usuario y comprobar qué carpetas ven.
2. Crear un archivo dentro de /mission-data con usuarios que NO son del grupo → debe fallar.
3. Intentar listar /backdoor con un usuario que no sea neo → debe fallar.
4. Que /simulacion permita escribir a matrix, pero no a zion.

Esto entrena:

– su comprensión de permisos

– su uso de su, ls -l, id, touch, mkdir, groups, etc.

FASE 5 — Mini misión final: Neutralizar al Agente Smith

smith → representa al Agente Smith

Este usuario NO debe pertenecer a ningún grupo de la resistencia ni a matrix.

Debe tener una carpeta personal sin permisos para nadie más:

sudo adduser smith
sudo chmod 700 /home/smith

Debes demostrar que smith no puede interactuar con las carpetas del sistema (mission-data, simulacion, backdoor) y explicar por qué, usando ls -ld, permisos y grupos.

La Resistencia ha detectado alteraciones en el sistema.

Alguien ha entrado sin permiso. El sistema (Linux) registra todas las trazas, pero necesitan operadores capacitados para reconstruir lo ocurrido.

El alumno se convierte en Analista de Zion, encargado de rastrear la actividad de los usuarios creados en el Reto 1: neo, trinity, apoc, switch, smith.

El objetivo:

Descubrir quién ha accedido, cuándo, desde dónde, qué ha tocado, y si ha conseguido privilegios dentro de Matrix.

FASE 1 — La lluvia de código (logs en tiempo real)

Orden del Oráculo: observar el flujo del sistema en directo.

1. Ver los mensajes del sistema en tiempo real: sudo journalctl -f
2. Cambiar entre usuarios mientras journalctl está abierto (por ejemplo, su - trinity, luego exit).
3. Detectar en el log: • el evento de autenticación • si el login se ha permitido o ha fallado

Resultado esperado: reconocer entradas como “session opened”, “session closed”, fallos PAM, etc.

:

Cada login es una “vibración en el código de Matrix”, y journalctl es la pantalla donde llueve el código verde.

FASE 2 — El rastro de entrada y salida

Aquí usamos last, who, w.

1. ¿Quién está conectado ahora mismo?

who
w

2. ¿Qué usuarios han entrado en el sistema en los últimos días?

last

3. ¿Se detectan accesos fallidos?

(En Distros Debian/Ubuntu)

sudo zgrep -i "failed" /var/log/auth.log*

Preguntas tipo misión:

• ¿Trinity accedió ayer?
• ¿Apoc intentó entrar varias veces y falló?
• ¿Neo ha usado sudo recientemente?
• ¿Smith existe en los logs aunque no debería moverse por el sistema?

FASE 3 — Sudo: quién ha manipulado Matrix

sudo journalctl -u sudo

o en Ubuntu también:

sudo grep 'COMMAND=' /var/log/auth.log

Descubrir si “Neo ha modificado normas de la simulación” o si “Smith ha intentado elevarse”.

Tareas:

1. Ver qué comandos se han ejecutado con sudo.
2. Identificar el usuario que los ejecutó.
3. Detectar intentos de sudo fallidos.

Bonus para rizar el rizo:

sudo journalctl | grep sudo

FASE 4 — Huellas en el historial: El Código dejado atrás

Revisar qué comandos ha ejecutado cada usuario.

Para ello, entrar como cada uno:

sudo su - trinity
history

o inspeccionar los archivos:

• ~/.bash_history

• ~/.zsh_history (si procede)

Preguntas narrativas:

• ¿Quién creó un archivo dentro de /simulacion fuera de su hora de trabajo?
• ¿Quién intentó entrar a /backdoor aunque no tenía permisos?
• ¿Qué usuario ejecutó comandos sospechosos como sudo su?
• ¿Acaso Smith intentó copiar algo desde mission-data?

FASE 5 — Localizar la intrusión: reconstrucción forense

“Durante la noche, uno de los usuarios ha intentado manipular el código de Matrix.

El sistema registró 3 accesos fallidos, un uso indebido de sudo y una entrada en /simulacion fuera del horario.” (Realiza con un usuario las acciones para mantener la ficción)

Tu misión es:

1. Localizar esos eventos.
2. Determinar qué usuario lo hizo.
3. Extraer las líneas exactas de log donde ocurrió.
4. Preparar un informe breve tipo forense: • usuario implicado • hora • evento • interpretación técnica

Aquí se cruzan:

• journalctl
• auth.log
• last
• history
• permisos

1. Descargar Clonezilla (la ISO correcta)

Ve a la página oficial:

Descarga Clonezilla Live (no la Server).
La versión más típica es:

• CPU: amd64 (si tu PC es moderno)
• Tipo: ISO

Ejemplo del archivo: clonezilla-live-3.x.x-amd64.iso

2. Crear el USB en Windows (método fácil: Rufus)

1. Descarga Rufus: https://rufus.ie
2. Inserta el USB (mínimo 1–2 GB).
3. En Rufus:
   • Device: tu USB
   • Boot selection: selecciona la ISO de Clonezilla
   • Partition scheme: MBR (compatibilidad máxima)
   • Target system: BIOS o UEFI
   • Deja el resto por defecto
4. Pulsa Start
5. Si pregunta por “ISO mode” o “DD mode”, elige ISO mode.

Eso deja un USB arrancable sin dolor.

3. Arrancar el PC desde el USB

Reinicia y entra al menú de arranque (suele ser F12, F10, ESC, DEL según la placa). Elige el pendrive y verás el menú de Clonezilla.

¿Dónde guarda Clonezilla la imagen?

Cuando arrancas Clonezilla y eliges device-image, te pregunta:

Where to save the image?

Y aquí seleccionas el “repositorio de imágenes” (la carpeta donde lo guardará).
Estos son los cuatro destinos típicos:

1. Otro USB o disco duro externo (la opción más usada)

Esto es lo más cómodo:

• Arrancas con el pendrive de Clonezilla
• Conectas un segundo USB o un disco externo
• Clonezilla lo detecta
• Seleccionas una carpeta dentro de ese disco y ¡listo!

Clonezilla creará algo como:

/nombre_de_la_imagen/
├── blkdev.list
├── disk
├── parts
├── sda-mbr
└── sda1.dd.img.gz

La carpeta entera es la copia.