{json.dumps(data, indent=2)}"
46 | return "No hay cookie 'user_data'."
47 |
48 | if __name__ == '__main__':
49 | app.run(debug=True)
--------------------------------------------------------------------------------
/05_Ciberseguridad_Python/Radio_frecuencias/13_Bleak_Info_Bluetooth.py:
--------------------------------------------------------------------------------
1 | # Con este codigo se crea un software que saca informacion de Bluetooth
2 | # Con la libreria de python bleak
3 | # pip install pybluez bleak
4 | import asyncio
5 | from bleak import BleakScanner, BleakClient
6 |
7 | async def conectar_y_extraer_info():
8 | print("Escaneando dispositivos Bluetooth...")
9 | dispositivos = await BleakScanner.discover(timeout=5.0)
10 |
11 | if not dispositivos:
12 | print("No se detectaron dispositivos.")
13 | return
14 |
15 | # Mostramos dispositivos
16 | for i, d in enumerate(dispositivos):
17 | print(f"[{i}] {d.name or 'Desconocido'} | {d.address} | RSSI: {d.rssi} dBm")
18 |
19 | # Selecciona uno
20 | indice = int(input("Selecciona el índice del dispositivo a conectar: "))
21 | device = dispositivos[indice]
22 |
23 | print(f"Conectando a {device.name or 'Desconocido'} ({device.address})...")
24 |
25 | async with BleakClient(device.address) as client:
26 | print("Conectado.")
27 |
28 | # Listar servicios y características disponibles
29 | for service in client.services:
30 | print(f"\n📡 Servicio: {service.uuid}")
31 | for char in service.characteristics:
32 | props = ', '.join(char.properties)
33 | print(f" - Característica: {char.uuid} ({props})")
34 | # Si es legible, intentamos leer
35 | if "read" in char.properties:
36 | try:
37 | value = await client.read_gatt_char(char.uuid)
38 | print(f"Valor leído: {value}")
39 | except Exception as e:
40 | print(f"Error al leer: {e}")
41 |
42 | if __name__ == "__main__":
43 | asyncio.run(conectar_y_extraer_info())
--------------------------------------------------------------------------------
/05_Ciberseguridad_Python/Encriptaciones/Esteganografia/01_Piexif_Esteganografia_desencriptacion.py:
--------------------------------------------------------------------------------
1 | # En el siguiente codigo de programacion, se muestra una forma sencilla
2 | # De extraer informacion en una imagen
3 | # Pirmero descargamos y usamos las librerias
4 | # "pip install piexif"
5 |
6 | import os
7 | from PIL import Image
8 | import piexif
9 |
10 | # Con el siguiente codigo se extrae el metadato que esta encriptado
11 | def extraer_metadato(ruta_imagen):
12 | try:
13 | imagen = Image.open(ruta_imagen)
14 | exif_dict = piexif.load(imagen.info.get('exif', b''))
15 |
16 | # Extraer UserComment (ID 37510)
17 | user_comment = exif_dict["Exif"].get(piexif.ExifIFD.UserComment, None)
18 | if user_comment:
19 | # Eliminar encabezado '\x00\x00' y decodificar
20 | texto = user_comment[2:].decode('utf-8', errors='ignore')
21 | return texto
22 | else:
23 | return None
24 | except Exception as e:
25 | print(f"(-) No se pudo leer el dato: {e}")
26 | return None
27 |
28 | def main():
29 | print("!! Empieza a leer los metadatos de la imagen !!")
30 |
31 | # La siguiente pregunta pide la ruta de la imagen
32 | ruta_imagen = input("Ruta de la imagen (ej. editada_foto.jpg): ").strip()
33 | if not os.path.exists(ruta_imagen):
34 | print("(-) No se encontro la imagen")
35 | return
36 |
37 | if not ruta_imagen.lower().endswith((".jpg", ".jpeg")):
38 | print("(-) La imagen no es jpg")
39 | return
40 |
41 | # 2. Extraer y mostrar dato
42 | dato = extraer_metadato(ruta_imagen)
43 | if dato:
44 | print(f"(+) El dato encontrado en la imagen es : '{dato}'")
45 | else:
46 | print("(-) No se encontro metadatos")
47 |
48 | if __name__ == "__main__":
49 | main()
50 |
51 |
--------------------------------------------------------------------------------
/05_Ciberseguridad_Python/Radio_frecuencias/09_Graficador_Potencias_Electromagneticas_Pyrtlsdr.py:
--------------------------------------------------------------------------------
1 | # En este ejemplo de codigo se muestra un graficador de potencias electromagneticas
2 | # con la distancia de los dispositivos en una frecuencia
3 | # pip install pyrtlsdr matplotlib numpy
4 | import numpy as np
5 | import matplotlib.pyplot as plt
6 | from rtlsdr import RtlSdr
7 |
8 | # Parámetros del barrido
9 | freq_start = 88e6 # Frecuencia inicial en Hz (por ejemplo, 88 MHz)
10 | freq_end = 108e6 # Frecuencia final en Hz (por ejemplo, 108 MHz)
11 | freq_step = 2e6 # Paso de frecuencia (ancho de banda de la muestra), típico ~2 MHz
12 | sample_rate = 2.4e6 # Tasa de muestreo en Hz
13 | num_samples = 1024 # Número de muestras por paso
14 |
15 | # Inicializa el SDR
16 | sdr = RtlSdr()
17 | sdr.sample_rate = sample_rate
18 | sdr.gain = 'auto'
19 |
20 | frequencies = []
21 | powers = []
22 |
23 | try:
24 | freqs = np.arange(freq_start, freq_end, freq_step)
25 |
26 | for freq in freqs:
27 | print(f"Escaneando {freq / 1e6:.2f} MHz...")
28 | sdr.center_freq = freq
29 | samples = sdr.read_samples(num_samples)
30 |
31 | # FFT y cálculo de potencia
32 | power = np.abs(np.fft.fftshift(np.fft.fft(samples)))**2
33 | power_db = 10 * np.log10(power)
34 | freqs_axis = np.linspace(freq - sample_rate/2, freq + sample_rate/2, num_samples)
35 |
36 | frequencies.extend(freqs_axis)
37 | powers.extend(power_db)
38 |
39 | finally:
40 | sdr.close()
41 |
42 | # Graficar
43 | plt.figure(figsize=(12, 6))
44 | plt.plot(np.array(frequencies)/1e6, powers, lw=0.5)
45 | plt.title("Espectro de Frecuencia (Barrido RTL-SDR)")
46 | plt.xlabel("Frecuencia (MHz)")
47 | plt.ylabel("Potencia (dB)")
48 | plt.grid(True)
49 | plt.tight_layout()
50 | plt.show()
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
--------------------------------------------------------------------------------
/02_Ejemplos_Librerias/05_PyAutoGUI_ejemplo.py:
--------------------------------------------------------------------------------
1 | # Primero se instala PyAutoGUI con el siguiente comando "pip install PyAutoGUI"
2 | import pyautogui
3 | import time
4 |
5 | #Con la funcion alert, mostramos en pantalla un mensaje con la informacion que queremos
6 | #En este caso mostramos un size, que es el tamaño de la pantalla
7 | pyautogui.alert(pyautogui.size())
8 | #Se le da 5 segundos, por si el computadr es lento
9 | time.sleep(5)
10 | #En este caso mostramos un position, que es la ubicacion del maus en la pantalla
11 | pyautogui.alert(pyautogui.position())
12 | #Se le da 5 segundos, por si el computadr es lento
13 | time.sleep(5)
14 | #Con las 2 funciones siguientes, se mueve el mause hacia una coordenada exacta.
15 | #Con moveTo, el puntero del mause llega rapido y con moverel, se demora su transporte
16 | pyautogui.moveTo(15,15, duration=3)
17 | pyautogui.moveRel(500,500, duration=3)
18 | #Con el siguiente codigo se presiona el boton windows
19 | pyautogui.press("win")
20 | #Se le da 3 segundos, por si el computadr es lento
21 | time.sleep(3)
22 | #Con la caracteristica write de pyautogui, escribimos la palabra excel con un intervalo de 0.1 segundos y luego damos enter
23 | pyautogui.write("excel", interval = 0.10)
24 | pyautogui.press("enter")
25 | #Esperamos 10 segundos para que abra el excel
26 | time.sleep(10)
27 | #Luego damos enter para abrir una pagina nueva de excel y posteriormente se escribe un texto
28 | pyautogui.press("enter")
29 | pyautogui.write("hola, soy un texto escrito", interval = 0.05)
30 | #Luego movemos 1 vez hacia abajo y 1 vez a la derecha, para luego ingresar un numero y dar enter
31 | pyautogui.press(['down', 'right'])
32 | pyautogui.write('+1+3')
33 | pyautogui.press("enter")
34 | #Por ultimo damos el grupo de comandos para guardar y mostramos un alerta de terminar el software
35 | pyautogui.hotkey('ctrl', 's')
36 | pyautogui.alert('Terminamos el script.')
37 |
38 |
--------------------------------------------------------------------------------
/02_Ejemplos_Librerias/23_Instagrapi_Instagram_Dejar_De_Seguir.py:
--------------------------------------------------------------------------------
1 | # En este programa se muestra un codigo para dejar de seguir usuarios en instagram
2 | # Se usaran 2 librerias os y instagrapi
3 | # Primero se instala captcha con el siguiente comando "pip install instagrapi"
4 | import os
5 | from instagrapi import Client
6 | import time
7 |
8 | usuario = "Usuario_Instagram"
9 | contraseña = "Contraseña"
10 |
11 | # Ruta para guardar sesión
12 | SESSION_PATH = "session.json"
13 | # Crear cliente
14 | cl = Client()
15 |
16 | # Intentar cargar sesión existente
17 | if os.path.exists(SESSION_PATH):
18 | cl.load_settings(SESSION_PATH)
19 | try:
20 | cl.login(usuario, contraseña)
21 | print("(+) Se logueo")
22 | except Exception as e:
23 | print("(+-) Sesión caducada. Reautenticando...")
24 | cl.set_settings({})
25 | cl.login(usuario, contraseña)
26 | cl.dump_settings(SESSION_PATH)
27 | print("(+) Se logueo")
28 | else:
29 | cl.login(usuario, contraseña)
30 | cl.dump_settings(SESSION_PATH)
31 | print("(+) Se logueo")
32 |
33 | # Leer usernames del archivo
34 | with open("no_en_ambas.txt", "r", encoding="utf-8") as archivo:
35 | usernames = [line.strip() for line in archivo if line.strip()]
36 | print("(+) Se cargaron los datos del .txt")
37 | # Dejar de seguir a cada uno
38 | unfollow_count = 0
39 |
40 | for username in usernames:
41 | try:
42 | user_id = cl.user_id_from_username(username)
43 | if cl.user_unfollow(user_id):
44 | print(f"(+) Dejaste de seguir a: {username}")
45 | unfollow_count += 1
46 | else:
47 | print(f"(-) No se pudo dejar de seguir a: {username}")
48 | except Exception as e:
49 | print(f"(+-) Error con {username}: {e}")
50 | time.sleep(50) # ⏳ Pausa para evitar bloqueos
51 |
52 | print(f"\n(+) Total dejado de seguir: {unfollow_count}")
--------------------------------------------------------------------------------
/02_Ejemplos_Librerias/20_Requests_Github_Quien_NoMe_Sigue.py:
--------------------------------------------------------------------------------
1 | # En este programa se muestra un codigo para consultar seguidos y seguidores en un github
2 | # Luego se guarda en un txt los que no estan en las 2 listas Se usaran
3 | # Primero se instala captcha con el siguiente comando "pip install flask requests"
4 | import requests
5 |
6 | # 👇 Cambia esto con tu nombre de usuario de GitHub
7 | username = 'Usuario_github'
8 |
9 | # 👇 Si tienes token, pégalo aquí. Si no, déjalo como ''
10 | token = 'Token_Alfanumerico' # opcional pero recomendado
11 |
12 | # Cabecera para autenticar con token (si lo usas)
13 | headers = {'Authorization': f'token {token}'} if token else {}
14 |
15 | # Función para obtener usuarios paginados (followers o following)
16 | def get_paginated_users(url):
17 | users = []
18 | while url:
19 | response = requests.get(url, headers=headers)
20 | response.raise_for_status()
21 | data = response.json()
22 | users.extend([user['login'] for user in data])
23 | # Revisa si hay otra página
24 | url = response.links.get('next', {}).get('url')
25 | return users
26 |
27 | # URLs de API
28 | followers_url = f'https://api.github.com/users/{username}/followers'
29 | following_url = f'https://api.github.com/users/{username}/following'
30 |
31 | print("(+) Obteniendo seguidores...")
32 | followers = get_paginated_users(followers_url)
33 |
34 | print("(+) Obteniendo seguidos...")
35 | following = get_paginated_users(following_url)
36 |
37 | # Comparar listas: quiénes sigues que NO te siguen
38 | no_te_siguen = [user for user in following if user not in followers]
39 |
40 | # Guardar en archivo
41 | with open('no_me_siguen.txt', 'w', encoding='utf-8') as f:
42 | for user in no_te_siguen:
43 | f.write(user + '\n')
44 |
45 | print(f"\n(+) Usuarios que sigues y no te siguen: {len(no_te_siguen)}")
46 | print("(+) Guardado en archivo: no_me_siguen.txt")
--------------------------------------------------------------------------------
/05_Ciberseguridad_Python/Radio_frecuencias/01_Receptor_Sencillo_Radio_Pyrtlsdr.py:
--------------------------------------------------------------------------------
1 | # En este codigo se muestra un ejemplo de receptor de señales de radio
2 | # y tambien como usar la libreria RtlSdr
3 | # pip install numpy scipy matplotlib sounddevice pyrtlsdr
4 | import numpy as np
5 | from rtlsdr import RtlSdr
6 | from scipy.signal import decimate, butter, lfilter
7 | import sounddevice as sd
8 |
9 | # Se configuran las caracteristicas de sdr radio frecuencia
10 | Radio_frecuencia = RtlSdr()
11 | Radio_frecuencia.sample_rate = 2.4e6 # Frecuencia de muestreo
12 | Radio_frecuencia.center_freq = 100.0e6 # Frecuencia de estación FM (100 MHz por ejemplo)
13 | Radio_frecuencia.gain = 40
14 |
15 | # Con la siguiente funcion se demodula la señal
16 | def fm_demodulate(iq):
17 | phase = np.angle(iq[1:] * np.conj(iq[:-1]))
18 | return phase
19 |
20 | # En la siguiente funcion se filtra la señal
21 | def lowpass_filter(data, cutoff, fs, order=5):
22 | from scipy.signal import butter, lfilter
23 | nyq = 0.5 * fs
24 | norm_cutoff = cutoff / nyq
25 | b, a = butter(order, norm_cutoff, btype='low')
26 | return lfilter(b, a, data)
27 |
28 | try:
29 | print("Se esta recibiendo la radio FM... Si quiere detenerlo CTL + C")
30 | while True:
31 | # Se capturan los datos actuales
32 | Muestra_ejemplo = Radio_frecuencia.read_samples(256*1024)
33 |
34 | # Demodulación FM
35 | audio = fm_demodulate(Muestra_ejemplo)
36 |
37 | # Filtro y reducción de tasa para reproducir como audio
38 | audio = lowpass_filter(audio, cutoff=16e3, fs=2.4e6)
39 | audio = decimate(audio, int(2.4e6 / 48e3))
40 |
41 | # Normalizar y reproducir
42 | audio /= np.max(np.abs(audio))
43 | sd.play(audio, 48000, blocking=True)
44 |
45 | except KeyboardInterrupt:
46 | print("\n La Recepción de señal fue detenida.")
47 | finally:
48 | Radio_frecuencia.close()
49 | sd.stop()
50 |
51 |
52 |
--------------------------------------------------------------------------------
/05_Ciberseguridad_Python/Radio_frecuencias/03_Analisador_Espectro_Pyrtlsdr.py:
--------------------------------------------------------------------------------
1 | # En este codigo se muestra un analisador de señales de radio
2 | # y tambien como usar la libreria RtlSdr
3 | # pip install numpy matplotlib pyrtlsdr scipy
4 |
5 | import numpy as np
6 | import matplotlib.pyplot as plt
7 | from rtlsdr import RtlSdr
8 | import time
9 |
10 | # Primero inicializamos el RtlSdr
11 | Radio_frecuencia = RtlSdr()
12 |
13 | # Luego procedemos a configurar sus caracteristicas
14 | Radio_frecuencia.sample_rate = 2.4e6 # Frecuencia de muestreo (Hz)
15 | Radio_frecuencia.center_freq = 100e6 # Frecuencia central (Hz) — puedes cambiarla, por ejemplo 100 MHz
16 | Radio_frecuencia.gain = 'auto' # Ganancia automática
17 |
18 | # Tambien usamos matplot para crear la grafica que muestra la señal
19 | plt.ion()
20 | fig, ax = plt.subplots()
21 | line, = ax.plot([], [], lw=1)
22 | ax.set_xlim(0, Radio_frecuencia.sample_rate / 1e6)
23 | ax.set_ylim(-100, 0)
24 | ax.set_xlabel('Frecuencia (MHz)')
25 | ax.set_ylabel('Potencia (dB)')
26 |
27 | # Esta funcion muestra como sacar datos de la señal escogida
28 | def update_spectrum():
29 | Muestra_ejemplo = Radio_frecuencia.read_samples(256*1024)
30 | # Calcular FFT y convertir a escala logarítmica
31 | fft_vals = np.fft.fftshift(np.fft.fft(Muestra_ejemplo))
32 | psd = 20 * np.log10(np.abs(fft_vals))
33 | freqs = np.linspace(-Radio_frecuencia.sample_rate/2, Radio_frecuencia.sample_rate/2, len(psd)) / 1e6 # MHz
34 |
35 | # Se ingresan los datos a la grafica
36 | line.set_xdata(freqs)
37 | line.set_ydata(psd)
38 | fig.canvas.draw()
39 | fig.canvas.flush_events()
40 |
41 | # Se crea un while para mostrar la grafica en tiempo real
42 | print("Se esta mostrando en pantalla la señal de radio")
43 | try:
44 | while True:
45 | update_spectrum()
46 | time.sleep(0.1)
47 | except KeyboardInterrupt:
48 | print("\n Se detuvo por orden del usuario.")
49 | finally:
50 | Radio_frecuencia.close()
--------------------------------------------------------------------------------
/05_Ciberseguridad_Python/Radio_frecuencias/15_Convertir_Sonido_Frecuencias_Diferente.py:
--------------------------------------------------------------------------------
1 | # Con este codigo se crea un software que emite sonido grabados
2 | # En frecuencias no audibles
3 | # Con la libreria de python Scapy
4 | # pip install pydub simpleaudio numpy pydub ffmpeg-python
5 |
6 | from pydub import AudioSegment
7 | import numpy as np
8 | import simpleaudio as sa
9 | import os
10 |
11 | # Se solicita el audio y la frecuencia a convertir
12 | audio_path = input("Por favor ingrese el archivo MP3 o WAV: ")
13 | freq = float(input("Por favor anexe la nueva frecuencia (Hz) para modificar el audio: "))
14 |
15 | # Se carga el audio
16 | audio = AudioSegment.from_file(audio_path)
17 | samples = np.array(audio.get_array_of_samples()).astype(np.float32)
18 | sample_rate = audio.frame_rate
19 |
20 | print(f"La frecuencia original del audio es: {sample_rate} Hz")
21 | print(f"La nueva frecuencia del audio es: {freq} Hz")
22 |
23 | # La siguiente parte del codigo convierte el audio en los herz indicados
24 | factor = freq / sample_rate # escala del tiempo
25 | indices = np.round(np.arange(0, len(samples), factor))
26 | indices = indices[indices < len(samples)].astype(int)
27 | modified_samples = samples[indices]
28 |
29 | # Se quita la distorcion
30 | modified_norm = modified_samples * (32767 / np.max(np.abs(modified_samples)))
31 | modified_int16 = modified_norm.astype(np.int16)
32 |
33 | # Se crea el audio MP3 con la nueva frecuencia
34 | new_audio = AudioSegment(
35 | modified_int16.tobytes(),
36 | frame_rate=sample_rate,
37 | sample_width=2,
38 | channels=1
39 | )
40 |
41 | # Se guarda el archivo con el sonido
42 | output_name = "audio_modificado.mp3"
43 | new_audio.export(output_name, format="mp3")
44 | print(f"El archivo generado es: {output_name}")
45 |
46 | # Se procede a reproducir el audio
47 | print("Reproduciendo el audio modificado…")
48 | play_obj = sa.play_buffer(modified_int16, 1, 2, sample_rate)
49 | play_obj.wait_done()
50 |
51 | print("Fin del proceso")
52 |
--------------------------------------------------------------------------------
/05_Ciberseguridad_Python/Radio_frecuencias/02_Decodificador_RadioFM_Pyrtlsdr_.py:
--------------------------------------------------------------------------------
1 | # En este codigo se muestra un decodificador FM de señales de radio
2 | # y tambien como usar la libreria RtlSdr
3 | # pip install numpy scipy matplotlib sounddevice pyrtlsdr
4 | import numpy as np
5 | from rtlsdr import RtlSdr
6 | import matplotlib.pyplot as plt
7 | from scipy.signal import decimate, butter, lfilter
8 | import sounddevice as sd
9 |
10 |
11 | # Inicializar el SDR
12 | Radio_frecuencia = RtlSdr()
13 | Radio_frecuencia.sample_rate = 2.4e6 # Hz
14 | Radio_frecuencia.center_freq = 100.0e6 # 100 MHz, cambia a una estación local
15 | Radio_frecuencia.gain = 40
16 |
17 | def fm_demodulate(iq_signal):
18 | angle = np.angle(iq_signal[1:] * np.conj(iq_signal[:-1]))
19 | return angle
20 |
21 | # Filtro pasa-bajo para aislar canal de audio
22 | def butter_lowpass(cutoff, fs, order=5):
23 | nyq = 0.5 * fs
24 | norm_cutoff = cutoff / nyq
25 | b, a = butter(order, norm_cutoff, btype='low')
26 | return b, a
27 |
28 | def lowpass_filter(data, cutoff, fs, order=5):
29 | b, a = butter_lowpass(cutoff, fs, order=order)
30 | return lfilter(b, a, data)
31 |
32 | # Creamos un bucle para recibir la señal
33 | try:
34 | print("Se muestra la señal que esta modulada en FM")
35 | while True:
36 | Muestra_ejemplo = Radio_frecuencia.read_samples(256*1024)
37 |
38 | # Demodular FM
39 | demodulated = fm_demodulate(Muestra_ejemplo)
40 |
41 | # Filtrar y decimar para obtener audio (de ~2400000 Hz a 48000 Hz)
42 | audio = lowpass_filter(demodulated, cutoff=16e3, fs=2.4e6)
43 | audio = decimate(audio, int(2.4e6 / 48e3))
44 |
45 | # Procedemos a normalizar el audio con np
46 | audio /= np.max(np.abs(audio))
47 |
48 | # Reproducir audio
49 | sd.play(audio, 48000, blocking=True)
50 |
51 | except KeyboardInterrupt:
52 | print("\n En espera...")
53 | finally:
54 | Radio_frecuencia.close()
55 | sd.stop()
--------------------------------------------------------------------------------
/05_Ciberseguridad_Python/Encriptaciones/Esteganografia/02_ZipFile_Esteganografia_encriptacion.py:
--------------------------------------------------------------------------------
1 | # En el siguiente codigo de programacion, se muestra una forma sencilla
2 | # De guardar un archivo texto en una imagen png
3 | # Pirmero descargamos y usamos las librerias
4 | # Primero se instala zipfile con el siguiente comando
5 | # "pip install zipfile"
6 |
7 |
8 | import zipfile
9 | from PIL import Image
10 |
11 | # La siguiente funcion sirve para crear un archivo texto con una informacion
12 | def crear_txt(nombre_txt, contenido):
13 | with open(nombre_txt, 'w') as f:
14 | f.write(contenido)
15 | print(f"El archivo .txt se creo sin problemas: {nombre_txt}")
16 |
17 | # Con esta funcion se crea una imagen con un nombre indicado
18 | def crear_imagen_png(nombre_imagen):
19 | img = Image.new('RGB', (200, 200), color='lightgreen')
20 | img.save(nombre_imagen)
21 | print(f"Imagen PNG creada: {nombre_imagen}")
22 |
23 | # En este codigo se muestra como meter un archivo texto a un archivo comprimido zip
24 | def crear_zip(nombre_zip, archivo_txt):
25 | with zipfile.ZipFile(nombre_zip, 'w') as zipf:
26 | zipf.write(archivo_txt)
27 | print(f"[✔] ZIP creado: {nombre_zip}")
28 |
29 | # En este codigo se explica como ingresarle el texto a la imagen con un archivo zip
30 | def fusionar_imagen_y_zip(imagen_png, archivo_zip, salida_png_con_zip):
31 | with open(imagen_png, 'rb') as img_file:
32 | datos_img = img_file.read()
33 |
34 | with open(archivo_zip, 'rb') as zip_file:
35 | datos_zip = zip_file.read()
36 |
37 | with open(salida_png_con_zip, 'wb') as salida:
38 | salida.write(datos_img)
39 | salida.write(datos_zip)
40 |
41 | print(f"La imagen quedo con el zip comprimido adentro: {salida_png_con_zip}")
42 |
43 | # EJECUTAR FLUJO COMPLETO
44 | crear_imagen_png('imagen_base.png')
45 | crear_zip('archivo.zip', 'Texto_a_guardar.txt')
46 | fusionar_imagen_y_zip('imagen_base.png', 'archivo.zip', 'imagen_con_mensaje.png')
47 |
48 |
49 |
--------------------------------------------------------------------------------
/02_Ejemplos_Librerias/17_Captcha.py:
--------------------------------------------------------------------------------
1 | # En este programa se muestra un codigo para crear y validar un captcha
2 | # Se usaran 3 librerias flask, captcha y random, para crear la imagen chaptcha
3 | # Primero se instala captcha con el siguiente comando "pip install flask captcha pillow"
4 | from flask import Flask, session, request, send_file, render_template_string, redirect, url_for
5 | from captcha.image import ImageCaptcha
6 | import random
7 | import string
8 | import io
9 |
10 | app = Flask(__name__)
11 | app.secret_key = 'clave_secreta_segura' # Necesaria para usar sesiones
12 |
13 | # Generador de texto CAPTCHA
14 | def generar_texto(longitud=5):
15 | return ''.join(random.choices(string.ascii_uppercase + string.digits, k=longitud))
16 |
17 | @app.route('/')
18 | def index():
19 | return render_template_string('''
20 | | Identificacion | 49 |Nombre | 50 |Celular | 51 |Operaciones | 53 ||
| {{contact.0 }} | 59 |{{contact.1 }} | 60 |{{contact.2 }} | 61 |{{contact.3 }} | 62 |63 | Editar 64 | borrar 65 | | 66 |