Buscar un código de Python

Mostrando del 1 al 10 de 18 coincidencias
<<>>
Se ha buscado por la cadena: enviar
Imágen de perfil
Val: 40
Ha disminuido su posición en 2 puestos en Python (en relación al último mes)
Gráfica de Python

enviar gmail con python


Python

Publicado el 10 de Enero del 2020 por Joker_116 (6 códigos)
2.443 visualizaciones desde el 10 de Enero del 2020
Este es un programa escrito en Python para enviar mensajes por gmail
En el rar abra dos archivos un script de Python y un exe

El exe es para no tener que instalar python solo ingresan los datos y listo.
Espero lo disfruten.
Imágen de perfil
Val: 666
Bronce
Ha disminuido 1 puesto en Python (en relación al último mes)
Gráfica de Python

Enviar multitud de correo con imagen incluida en Python 2


Python

Actualizado el 28 de Octubre del 2018 por Xavi (548 códigos) (Publicado el 5 de Julio del 2011)
11.070 visualizaciones desde el 5 de Julio del 2011
Código que muestra como enviar un correo utilizando un servidor SMTP en formato texto y html, y con una imagen añadida al correo.
Permite enviar un email a tantas direcciones de correo como se desee. Utiliza la librerías smtplib y email
Imágen de perfil
Val: 666
Bronce
Ha disminuido 1 puesto en Python (en relación al último mes)
Gráfica de Python

Enviar correo con imagen adjunta siempre visible


Python

Publicado el 11 de Junio del 2013 por Xavi (548 códigos)
6.590 visualizaciones desde el 11 de Junio del 2013
Código que muestra como enviar un correo con una imagen adjunta y siempre visible en el correo. Utiliza un servidor smtp para el envió del correo, y se pueden personalizar tantas direcciones de correo como se deseen para hacer un envió masivo.
Imágen de perfil

BITCOIN: Transación, formato raw.


Python

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 4 de Marzo del 2025 por Hilario (145 códigos)
1.733 visualizaciones desde el 4 de Marzo del 2025
Captura-de-pantalla-de-2025-03-04-11-16-50

**********************************************




Ejercicio: Aula_28_Transacion_Bit_Coin_Marzo_25.py
**************************************************

Formato RAW de la transacción BITCOIN
//////////////////////////////////////////////////////////////////


Propongo un ejercicio interesante. Datos de una transacción de Bitcoin en formato raw (hexadecimal).Cuando una transacción se crea, se representa en un formato hexadecimal binario. Pero luego, ¿Cómo se calcula el txid de una transacción en Bitcoin?. Pues, queridos alumnos, de eso va este ejercicio propuesto.
IDEA INICIAL DEL CÓDIGO.
Necesitamos hacer en Python, bajo Ubuntu, un programa ejemplo de una transacción en formato raw (hexadecimal), teniendo en cuenta que se deben aportar los datos ficticios, es decir para tener una salida en formato raw, de la transación y posteriormente lograr el cálculo que nos dará el txid, correspondiente. Este es el punto de partida, para que una vez optenidos todos los TXID, de todas las transacciones podramos obtener :
Una vez que tenemos todos los TXID de las transacciones de un bloque, los organizamos en un árbol de Merkle, - que ya vimos en un ejercicio anterior, que se construye aplicando doble SHA-256 a pares de hashes hasta obtener un único hash raíz (Merkle root).

¿Qué significa esto en la práctica?
El hash final del bloque (Block Hash) es el identificador único de ese bloque en la blockchain.
Este hash será el "hash del bloque anterior" en el siguiente bloque de la cadena, asegurando la integridad y seguridad de la blockchain.

Bien, los datos ficticios que aportaremos en nuestro programa serán los siguientes:
*******************************************************************************
Este formato hexadecimal incluye:
• Version de la transacción.
• Entradas (Inputs):
• Hash de la transacción previa (UTXO).
• Índice de salida (vout).
• Script de firma.
• Salidas (Outputs):
• Cantidad de satoshis enviados.
• Script de bloqueo (scriptPubKey).
• Locktime (para definir si se puede gastar en el futuro).

SIGNIFICADOS:
***********************
1. Versión de la transacción
Este es un número que indica la versión del formato de la transacción. A medida que el protocolo de Bitcoin evoluciona, pueden introducirse nuevas versiones para mejorar la funcionalidad y seguridad de las transacciones.

Actualmente, las versiones más comunes son 1 y 2.
La versión 2 se introdujo para admitir Replace-By-Fee (RBF), permitiendo reemplazar una transacción no confirmada con una versión de mayor comisión.
2. Entradas (Inputs)
Las entradas indican de dónde provienen los bitcoins que se están gastando en la transacción.

2.1. Hash de la transacción previa (UTXO)
Cada entrada hace referencia a una salida no gastada (UTXO, Unspent Transaction Output) de una transacción anterior. Para identificar de dónde provienen los fondos, se usa el hash de la transacción previa que contenía la salida que ahora queremos gastar.

Este hash es un identificador único de 256 bits (64 caracteres en hexadecimal).
Se obtiene aplicando SHA-256 dos veces a los datos de la transacción anterior.
2.2. Índice de salida (vout)
Dado que una transacción puede tener múltiples salidas, necesitamos especificar cuál de esas salidas estamos gastando.

vout es un número entero que indica el índice de la salida en la transacción anterior (comienza desde 0).
Ejemplo:
Si la transacción anterior tiene dos salidas y queremos gastar la segunda, vout será 1.

2.3. Script de firma
También llamado scriptSig, es un script que prueba que el usuario tiene permiso para gastar los bitcoins de la UTXO referenciada.

Contiene la firma digital generada con la clave privada del propietario de los bitcoins.
También incluye la clave pública del firmante.
Se ejecuta junto con el script de bloqueo (scriptPubKey) de la transacción anterior para validar la autenticidad del gasto.
3. Salidas (Outputs)
Cada salida define a dónde van los bitcoins en esta transacción.

3.1. Cantidad de satoshis enviados
Especifica la cantidad de bitcoins que se enviarán en esta salida, expresados en satoshis (1 BTC = 100,000,000 satoshis).

Ejemplo:
Si queremos enviar 0.01 BTC, la cantidad en satoshis será 1,000,000.

3.2. Script de bloqueo (scriptPubKey)
Es un script que define las condiciones para gastar esta salida en el futuro.

Generalmente, es un Pay-to-PubKey-Hash (P2PKH), que especifica que solo la persona que tenga la clave privada correspondiente a la clave pública hash puede gastar esos bitcoins.
También puede ser un Pay-to-Script-Hash (P2SH), Pay-to-Witness-PubKey-Hash (P2WPKH) u otros formatos de pago.
Ejemplo de scriptPubKey para una dirección P2PKH:


OP_DUP OP_HASH160 <PublicKeyHash> OP_EQUALVERIFY OP_CHECKSIG
4. Locktime (para definir si se puede gastar en el futuro)
Locktime es un campo opcional que define a partir de cuándo la transacción puede ser confirmada.

Si locktime es 0, la transacción se procesa inmediatamente.
Si es un número mayor que 500,000,000, representa una fecha en formato timestamp UNIX (segundos desde 1970).
Si es menor, representa el número de bloque a partir del cual la transacción será válida.
Ejemplo:

locktime = 800000 → Solo se confirmará después del bloque 800,000.
locktime = 1700000000 → Solo se confirmará después del 14 de noviembre de 2023 (según la fecha UNIX).
Resumen final
La transacción en Bitcoin tiene una versión para definir su formato.
Cada entrada (input) hace referencia a una UTXO anterior mediante su hash y un índice de salida (vout).
Para validar el gasto, la transacción incluye un script de firma (scriptSig).
Cada salida (output) especifica cuántos satoshis se envían y a quién, mediante un script de bloqueo (scriptPubKey).
Locktime puede definir un tiempo de espera antes de que la transacción sea válida.

**********************************************************************************

• Locktime (para definir si se puede gastar en el futuro).
Deberas de tener en cuenta que los datos aportados en formato hash, deberan ser chequeados para que cumplan las normas, es decir deben de ser exadecimales de 0 a 9, y letras de A a la F, sin espacios etc, si no eres cuidado en esto, el programa siempre dara errores.
Una vez que tengas la transacción en formato raw (hexadecimal), deberás Calcular el txid
1. Hash SHA-256 sobre los datos en formato hexadecimal.
2. Aplicar SHA-256 de nuevo al resultado del primer hash (doble SHA-256).
3. Invertir el orden de los bytes (little-endian).
Deberá verse por consola la transacion en formato Hexadecimal.
También deberá verse por consola el TXID.
Según la foto adjunta del programa.

*****************************************************************
No os explico aquí el programa, porque he intentado explicaros en el propio código
cada paso.
------------------------------------------------------------------------------------
Programa realizado en linux Ubuntu.
Con el editor sublime text.
Ejecución bajo consola linux:
python3 Aula_28_Transacion_Bit_Coin_Marzo_25.py
------------------------------------------------------------------------------------------

En las clases sucesivas, explicaremos dudas, que supongo serán muchas.
Imágen de perfil

Elíptica_Criptografía


Python

Publicado el 27 de Noviembre del 2024 por Hilario (145 códigos)
786 visualizaciones desde el 27 de Noviembre del 2024
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Figure_1

---------------------------------------------------------------------------------------------------------------------------

Captura-de-pantalla-de-2024-11-27-12-07-57

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Aula_28_Nov_Eliptica_Criptografia.py
+++++++++++++++++++++++++++++




Dentro de todas las partes, digamos, técnologicas, que hemos ido estudiando y procesando. Comenzamos un tema nuevo,
para el que seguiremos utilizando el lengua Python, y un sistema operativo basado en linux.
Nos adentramos en el mundo de la criptografía y de las claves, en principio, en los sistemas más utilizados
por el secure shel SSH, en principio con un ejemplo sencillo, que intentaré explicar lo mejor posible.
Como siempre, en nuestras sucesivas clases de técnología iremos aclarando las dudas que surjan, lo que supondrá, como siempre
ocurre en nuestras clases, profundizar mucho más sobre el tema. Os pido, que dentro de lo posible, intenteis razonar el código.
Luego ya aclararemos todo lo que surja, pero es más fácil su comprensión si llevamos, digamos, trillado, un poco de lo que se trata.

EMPECEMOS:
++++++++++++++

-¿Qué es una curva elíptica?
Una curva elíptica es una curva matemática que tiene la forma general:
y2=x3+ax+b (Ya sabeis, y elevado a 2, igual a x elevado a 3, más a por x, más b)
Esta curva tiene propiedades interesantes que se aprovechan en criptografía para generar claves. En criptografía de curvas elípticas (ECC, por sus siglas en inglés), usamos puntos sobre esta curva para construir un sistema de claves.


¿Cómo se construyen las claves con una curva elíptica?
1. Selección de la curva elíptica:
◦ Primero, se elige una curva elíptica específica. La ecuación y2=x3+ax+b tiene parámetros como a, b, y un número primo p que define el campo finito (es decir, trabajamos con números que están "limitados" por un número p).
◦ Un ejemplo común de curva elíptica es la curva secp256k1, que se usa en Bitcoin.

2. Punto generador (G):
◦ Sobre la curva elíptica, hay un punto generador G que es un punto específico de la curva, que se conoce de antemano. Este punto sirve para generar las claves.

3. Clave privada:
◦ La clave privada es un número aleatorio que se elige de manera segura. Es como una "semilla" que vamos a usar para generar la clave pública.
◦ Este número privado es secreto, y nunca se debe compartir.

4. Clave pública:
◦ La clave pública se genera multiplicando el punto generador G por el número privado (clave privada). Esto se hace mediante una operación llamada multiplicación escalar.
◦ Matemáticamente, si tienes una clave privada k, la clave pública P es: P=k⋅G
◦ Aquí, P es un nuevo punto sobre la curva que depende de k y G. Es casi imposible calcular k solo a partir de P, lo que hace la curva elíptica segura para su uso en criptografía.

5. Uso en criptografía:
◦ En criptografía de clave pública, puedes usar la clave pública para verificar la autenticidad de un mensaje o para cifrar datos.
◦ Solo la persona que tiene la clave privada puede descifrar los datos o firmar mensajes, porque se necesita la clave privada para generar la firma o descifrar.

Ejemplo práctico en criptografía
Imagina que quieres enviar un mensaje seguro a alguien:
1. La otra persona te envía su clave pública.
2. Tú usas esa clave pública para cifrar el mensaje.
3. La otra persona usa su clave privada para descifrarlo.
Y cuando firmes un mensaje:
1. Usas tu clave privada para firmar el mensaje (de forma que solo tú puedas hacerlo).
2. Cualquier persona que tenga tu clave pública puede verificar que la firma es auténtica y que no ha sido modificada.

¿Por qué es segura?
La seguridad de este sistema se basa en que, aunque la multiplicación escalar de un número por un punto en la curva es fácil de hacer, el proceso inverso (saber la clave privada a partir de la clave pública) es extremadamente difícil. Este problema se llama el problema del logaritmo discreto, y es la base de la seguridad de las curvas elípticas.

En fin, alumnos, resumiendo:
1. Clave privada: Número secreto que eliges.
2. Clave pública: Punto en la curva generado a partir de la clave privada.
3. Suma de puntos: Usada para multiplicar el punto generador G para obtener la clave pública.
4. Seguridad: Es muy difícil calcular la clave privada a partir de la clave pública.


Este enfoque se usa en criptografía moderna para asegurar comunicaciones y transacciones, como en Bitcoin o en protocolos TLS/SSL para la navegación segura por Internet.
----------------------------------------------------------------------------------------------------------------------------------

Bien, después de esta pequeña introducción, que ampliaremos en clase, la próxima semana y sucesivas, vamos con algo más práctico:

1. Representación gráfica de la curva elíptica.
---------------------------------------------------------------
El programa comienza generando una gráfica de la curva elíptica definida por y2=x3+8x+12 sobre los números reales:
• Cálculo de y2:
La ecuación se evalúa para valores de x en un rango definido [−10,10] para obtener los valores de y2.
• Raíces cuadradas positivas y negativas:
La raíz cuadrada de y2 se toma tanto positiva como negativa (y=±y2​) para trazar ambas ramas de la curva.
• Visualización:
Usa matplotlib para graficar las ramas positiva y negativa en colores distintos. También incluye líneas de referencia para los ejes x e y, junto con una cuadrícula para mejorar la legibilidad.
Propósito:
Este gráfico permite entender visualmente la forma de una curva elíptica sobre los números reales antes de trabajar con el caso modular (campo finito).

2. Implementación de una curva elíptica modular (campo finito pequeño)
-------------------------------------------------------------------------------------------------------
En esta sección, se define una clase EllipticCurve para manejar operaciones básicas en una curva elíptica sobre un campo finito

Fp​:
• Parámetros de la curva:
La curva está definida por y2=x3+ax+bmodp, donde:
◦ a=8, b=12, y p=97 (un número primo que define el campo).
• Validación de singularidades:
Verifica que la curva no sea singular usando la condición 4a3+27b2=0modp.

• Operaciones básicas:
◦ Pertenencia a la curva: Verifica si un punto (x,y) está en la curva.
◦ Suma de puntos: Implementa la adición de puntos, considerando casos como:
▪ P+O=P (punto identidad).
▪ Suma de puntos distintos.
▪ Duplicación de un punto (derivada de la tangente).
◦ Multiplicación escalar: Repite la suma k⋅P usando el algoritmo de duplicación y adición.

• Generación de claves:
◦ Se generan todos los puntos válidos en la curva para el campo F97​.
◦ Selecciona un punto generador G (el primero de la lista).
◦ La clave privada es un entero aleatorio entre 1 y p−1.
◦ La clave pública es el resultado de k⋅G, donde k es la clave privada.

Resultados:
Imprime:
• La ecuación de la curva modular.
• El punto generador G.
• Las claves privada y pública generadas.

3. Criptografía realista con secp256k1
Esta sección introduce una curva elíptica de uso práctico en criptografía, secp256k1, utilizada por Bitcoin:
• Definición:
La curva está definida por y2=x3+7modp, donde:
◦ p es un número primo grande (2256−232−977).
◦ G es un punto generador predeterminado en la curva.
◦ n es el orden del punto generador.
• Operaciones similares:
Implementa las mismas operaciones (pertenencia, suma de puntos, multiplicación escalar) adaptadas a los parámetros de secp256k1.
• Generación de claves:
◦ La clave privada es un número aleatorio de hasta 256 bits (1≤k<n).
◦ La clave pública es k⋅G, donde G y n aseguran un espacio de claves inmenso y seguridad criptográfica.
Resultados:
Muestra:
• La ecuación de secp256k1.
• El punto generador G.
• Las claves privada y pública.


Como véis, queridos alumnos, el propósito formativo del programa es:
++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++
1. Introducción visual a las curvas elípticas:
La gráfica inicial ayuda a entender cómo luce una curva elíptica y su simetría sobre los números reales.
2. Conceptos básicos de curvas elípticas en campos finitos:
◦ Explica cómo las curvas se definen y operan en un espacio modular, con un ejemplo simple (p=97).
◦ Introduce operaciones críticas como suma de puntos y multiplicación escalar.
3. Aplicación práctica en criptografía:
◦ Usa una curva criptográfica estándar (secp256k1) para mostrar cómo generar claves privadas y públicas.
◦ Destaca las diferencias entre un ejemplo educativo y un caso práctico con parámetros reales.

Bien, y como posibles mejoras, vamos a implementar lo siguiente:
---------------------------------------------------------------
• Implementar firmas digitales (ECDSA) como extensión práctica.
• Mostrar cómo la clave pública se convierte en un formato útil (como direcciones en Bitcoin).
• Incluir explicaciones más detalladas sobre seguridad y resistencia frente a ataques.


Comoos lo expuesto, tengo por sentado que os resultará un tanto farragoso, deseo que, como ya dije, comencéis su estudio-
Iremos puliendo dudas, y asentando conceptos los próximos días.



///////////////////////////////////////////////////////////////////////////
Como casi todos los ejercicios, este fue realizado, bajo una plataforma Linux,
en concreto con Ubuntu 20.04.6 LTS.
Fue editado con Sublime Text.
Se utilizó, Python3.
Y como smpre indico, se deberán de tener cargadas en el sistema, todas las librerias
que el código pide importar para su ejecucucíon.

Comando de ejecucuón bajo consola linux:

python3 Aula_28_Nov_Eliptica_Criptografia.py
Imágen de perfil

Quién está en nuestra WIFI


Python

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 29 de Septiembre del 2024 por Hilario (145 códigos)
478 visualizaciones desde el 29 de Septiembre del 2024
Captura-de-pantalla-de-2024-09-29-11-50-29

----------------------------------------------------------------------------------------------------------
En este ejemplo, vamos a realizar una propuesta de estudio para el Aula 18, sobre desarrollo de programación, para crear un programa en Python que determine, qué usuarios o dispositivos están conectados a tu red Wi-Fi, en un sistema operativo Linux (como Ubuntu), podemos usar una combinación de herramientas de red disponibles en Linux, como arp-scan o nmap.

Aquí te dejo un ejemplo básico que utiliza arp-scan, una herramienta que escanea la red en busca de dispositivos conectados.
********************************************************************
En este ejemplo iremos describiendo paso a paso, el proceso de creación de
nuestro programa.
-------------------------------------------------------------------------
Pasos para instalar y usar el script:
Instalar arp-scan: Primero, debes instalar la herramienta arp-scan si no la tienes en tu sistema. Abre una terminal y ejecuta:

sudo apt-get install arp-scan
Crear el programa en Python:

Crea un archivo Python con el siguiente código, por ejemplo, llámalo Ejercicio_Aula_Sep_29.py:


Nota:
Necesitas tener privilegios de root para usar arp-scan, de ahí que el script deba ejecutarse con sudo.
Este es un método sencillo para obtener información de los dispositivos conectados a la misma red Wi-Fi.

Para incluir el nombre de la interfaz de red del terminal (como wlan0, eth0, etc.), podemos hacer que el programa detecte automáticamente la interfaz de red que está en uso para conectarse a la red Wi-Fi. Esto es necesario ya que arp-scan puede requerir que especifiques la interfaz de red correcta en lugar de asumirlo por defecto.

También podemos usar el comando ip link para listar las interfaces de red y determinar cuál está activa.

Otra cosa que podemos hacer es modificar el programa para que, cuando sea necesario ejecutar sudo, no tengas que invocar el script desde la línea de comandos con sudo. En su lugar, el propio programa pedirá la contraseña de superusuario automáticamente si no se está ejecutando con privilegios de administrador.

Python tiene una librería llamada os que permite verificar si el programa se está ejecutando como root. Si no es así, podemos utilizar sudo para ejecutar el propio script.


Verifica si el script está siendo ejecutado con permisos de superusuario usando os.geteuid().
Si no se está ejecutando con permisos de root (es decir, si el identificador de usuario efectivo no es 0), el programa se reiniciará automáticamente con sudo.
Usa subprocess.run(['sudo', 'python3'] + sys.argv) para reejecutar el script actual con sudo. Esto mantiene cualquier argumento que hayas pasado al script.
Lógica del programa:

El script primero comprueba si tiene privilegios de superusuario usando check_sudo().
Si no es así, se reinicia automáticamente con sudo para obtener los permisos necesarios y ejecutar el comando arp-scan correctamente.
Después de obtener los permisos adecuados, continúa con el flujo normal: obtener la interfaz de red y ejecutar el escaneo de dispositivos.
Ejecución del script:
Ahora puedes ejecutar el script sin tener que usar sudo manualmente:


Este enfoque es útil cuando quieres asegurarte de que el script siempre tenga privilegios adecuados para ejecutar comandos que requieren permisos elevados, como arp-scan.


Se utiliza getpass.getpass() para solicitar la contraseña de sudo al usuario de forma segura (sin que la contraseña se muestre en la pantalla).
Opción -S de sudo:

Se ha añadido la opción -S al comando sudo en subprocess.run(). Esto permite que sudo acepte la contraseña desde la entrada estándar (stdin) en lugar de solicitarla directamente a través de la terminal.
Enviar la contraseña a stdin:

La contraseña introducida por el usuario se pasa a través del parámetro input de subprocess.run(), que envía la contraseña directamente al comando sudo.

Flujo del programa:

Si el script detecta que no tiene permisos de superusuario, solicitará la contraseña y reejecutará el script automáticamente con sudo, utilizando la contraseña ingresada por el usuario.
Ejecución del script:
Puedes ejecutar el script sin sudo como antes, y se pedirá la contraseña si es necesario:


Cuando se soliciten permisos de superusuario, el script pedirá la contraseña en la terminal. Si la contraseña es correcta, se volverá a ejecutar el script con los permisos adecuados.

Nota:
Este enfoque es útil para evitar tener que ejecutar el script directamente con sudo, y también para mejorar la seguridad al no dejar la contraseña visible.


Una solución simple es asegurarse de que el script se está ejecutando directamente desde una terminal interactiva real. Pero si deseas que la entrada de la contraseña funcione correctamente en cualquier contexto, puedes usar una combinación de herramientas para evitar este error. Una opción es hacer que el propio comando sudo solicite la contraseña en lugar de gestionarla mediante getpass.


Ya no solicitamos manualmente la contraseña usando getpass. En lugar de eso, simplemente dejamos que sudo maneje la solicitud de la contraseña en la terminal.
Ejecutar con sudo:

Si el script no se está ejecutando como superusuario, se reiniciará automáticamente con sudo (sudo python3 script.py), y sudo pedirá la contraseña al usuario de manera normal. Esto evita problemas relacionados con la entrada de contraseña a través de getpass en ciertos entornos.

Flujo del programa:

El script verifica si tiene permisos de superusuario y, si no es así, se reinicia con sudo, permitiendo que sudo maneje la interacción con el usuario para la contraseña.
Ejecución del script:
Puedes ejecutar el script como de costumbre, sin sudo, y el programa pedirá la contraseña automáticamente cuando sea necesario:

Puesdes poner en el bash de tu consola
Copiar código
python3 Ejercicio_Aula_Sep_29.py
Si no tienes permisos de superusuario, sudo te pedirá la contraseña de forma normal, como lo haría en cualquier comando de terminal.


Nota:
Este enfoque garantiza que la entrada de la contraseña sea gestionada directamente por sudo, lo que evitará problemas con el manejo de la contraseña en diferentes entornos.


Cuando ejecutas el comando con sudo, el sistema te pedirá la contraseña de superusuario antes de ejecutar el script. Dado que ya estás ejecutando el script con permisos elevados, no necesitarás incluir la lógica para reiniciar el script con sudo dentro del código.

Simplificación del código si usas sudo directamente
Si prefieres siempre ejecutar el script directamente con sudo, puedes simplificar el código y eliminar la verificación de superusuario. Aquí te dejo una versión simplificada del programa, ya que no necesitas verificar si el script tiene permisos de root (esto será garantizado por el uso de sudo en la terminal):



bash
Copiar código
sudo python3 Ejercicio_Aula_Sep_29.py
Este enfoque es más sencillo si ya estás acostumbrado a ejecutar comandos que requieren permisos de superusuario.

Nota:
Importante comprobar otra vez: Asegúrate de que tienes instalada la herramienta arp-scan en tu sistema, ya que es esencial para este programa. Puedes instalarla ejecutando:


bash
Copiar código
sudo apt-get install arp-scan
Ahora que ejecutas el script con sudo desde el principio, no tendrás problemas relacionados con permisos.

En caso de problemas.
Es extraño que al ejecutar el script con sudo no obtengas ningún resultado, ya que el uso de sudo debería garantizar que arp-scan tenga los permisos necesarios para funcionar correctamente. Sin embargo, podrían estar ocurriendo algunos problemas que podemos revisar:

Posibles causas:
arp-scan no está instalado: Asegúrate de que la herramienta arp-scan está instalada. Si no lo está, puedes instalarla con:

bash
Copiar código
sudo apt-get install arp-scan
Interfaz de red incorrecta: Puede que la interfaz que el script detecta no sea la correcta (por ejemplo, si estás conectado a través de Wi-Fi pero detecta una interfaz Ethernet). Verifica que la interfaz detectada sea la que está en uso.

Para confirmar qué interfaz de red estás usando, también puedes ejecutar manualmente:

bash
Copiar código
ip link
Asegúrate de que la interfaz que está en "estado UP" (activa) es la que quieres escanear. Si no es la correcta, podemos modificar el código para especificar manualmente la interfaz.


bash
Copiar código
sudo arp-scan -I INTERFAZ -l
Reemplaza INTERFAZ por el nombre de tu interfaz de red activa (por ejemplo, wlp3s0 si es Wi-Fi).

Permisos de sudo en el script: A veces, sudo puede no pasar bien la contraseña o no funcionar adecuadamente dentro de un script. Si este es el caso, prueba ejecutando todo manualmente para asegurarte de que el problema no esté en la interacción con sudo.

Ajustes al script:
Vamos a ajustar el script para que imprima más información de depuración, lo que nos ayudará a identificar el problema exacto.


Ejecuta este código modificado para que imprima más detalles de depuración, como la salida del comando ip link. Esto nos permitirá verificar qué interfaz está detectando.

Si el script detecta la interfaz incorrecta o ninguna interfaz, revisa el comando ip link para asegurarte de que tienes la interfaz correcta en estado "UP".

Prueba arp-scan manualmente en la terminal con la interfaz correcta:

bash
Copiar código
sudo arp-scan -I INTERFAZ -l
Si arp-scan manualmente funciona bien, pero el script no, entonces es posible que haya un problema en cómo el script maneja los comandos.

Análisis adicional, con estas preguntas puedes solucionar los errores, haceroslas en el Aula, siempre se aprende:
¿El script detecta correctamente tu interfaz de red?
¿La salida de arp-scan manual te muestra resultados?
Estos pasos nos ayudarán a depurar el problema.onales.

A continuacion os pongo una salida típica del comando hecha en la consola de mi portatil, hacerlo en el Aula:
sudo arp-scan -I wlo1 -l
Interface: wlo1, type: EN10MB, MAC: 1c:4d:70:0e:0e:fc, IPv4: 192.168.0.18
Starting arp-scan 1.9.7 with 256 hosts (https://github.com/royhills/arp-scan)
192.168.0.1 3c:98:72:2e:4f:f2 Sercomm Corporation.
192.168.0.19 64:66:24:aa:34:b6 Sagemcom Broadband SAS
192.168.0.13 7e:cb:c5:38:37:f0 (Unknown: locally administered)


Dado que el comando arp-scan funciona perfectamente cuando lo ejecutas manualmente en la terminal pero no dentro del programa Python, es probable que el problema esté relacionado con cómo el script maneja la salida de arp-scan. Puede haber varios factores que están afectando la forma en que el programa ejecuta arp-scan o captura su salida.


Al eliminar la captura de salida para que puedas ver directamente los resultados en la terminal en lugar de capturarlos en el script.
Usa subprocess.Popen en lugar de subprocess.run para tener un control más fino sobre cómo se maneja la salida.

Cambios realizados:
subprocess.Popen:
Usamos subprocess.Popen en lugar de subprocess.run para ejecutar arp-scan y leer la salida en tiempo real. Esto nos da más control sobre cómo se captura y procesa la salida.
Impresión en tiempo real:
Ahora el programa imprime la salida directamente en la terminal mientras se ejecuta arp-scan, tal como sucede cuando ejecutas el comando manualmente. Esto debería darte los mismos resultados que ves cuando lo ejecutas en la terminal.

Ejecución:
Guarda este nuevo código en tu archivo Ejercicio_Aula_Sep_29.py

Ejecuta el programa con sudo:

bash
Copiar código
sudo python3 Ejercicio_Aula_Sep_29.py
Qué esperar:
Ahora, deberías ver la salida de arp-scan directamente en la terminal, tal como sucede cuando lo ejecutas manualmente. Esto debería ayudarte a identificar si hay algún problema con la captura de la salida o la ejecución dentro del programa Python.



También podemos modificar el código para que sudo lea la contraseña desde la entrada estándar (-S), lo que permitirá que el programa te pida la contraseña y la pase correctamente a sudo.


Opción sudo -S:
Ahora el comando sudo usa la opción -S, que permite que la contraseña sea leída desde la entrada estándar (stdin).
Manejo de la contraseña:
Utilizamos la función getpass.getpass() para solicitar la contraseña del usuario de forma segura sin que se muestre en pantalla.
La contraseña se pasa al proceso sudo a través de process.communicate().
Pasos para ejecutar:
Guarda el script Ejercicio_Aula_Sep_29.py


Ejecuta el script sin sudo porque el propio script manejará la contraseña:

bash
Copiar código
python3 Ejercicio_Aula_Sep_29.py

¿Qué esperar?
El programa te pedirá que ingreses tu contraseña de sudo.
Una vez ingresada la contraseña, el comando arp-scan debería ejecutarse correctamente y mostrar los dispositivos conectados a la red.
Ahora podemos probar estos, queridos alunmnos para mirar si funcionan las modificaciones.
----------------------------------------------------------------------
----------------------------------------------------------------------
VAMOS A COLOCAR AQUI EL CODIGO FINAL, DESPUES DE TODAS LAS MODIFICACIONES REALIZADAS-
******************************************************************
import subprocess
import re
import getpass

def get_network_interface():
try:
# Ejecutar 'ip link' para obtener las interfaces de red
print("Ejecutando 'ip link' para obtener la interfaz de red...")
result = subprocess.run(['ip', 'link'], capture_output=True, text=True)

if result.returncode != 0:
print("Error al ejecutar ip link:", result.stderr)
return None

# Imprimir la salida completa para depuración
print("Salida completa de 'ip link':")
print(result.stdout)

# Usar una expresión regular para encontrar interfaces que estén activas (estado UP)
interfaces = re.findall(r'\d+: (\w+):.*state UP', result.stdout)

if interfaces:
# Retornar la primera interfaz que esté en estado UP
return interfaces[0]
else:
print("No se encontraron interfaces de red activas.")
return None

except Exception as e:
print(f"Error al obtener la interfaz de red: {e}")
return None

def scan_network(interface):
try:
# Pedir la contraseña del superusuario
password = getpass.getpass("Introduce la contraseña de sudo: ")

# Ejecutar el comando 'arp-scan' especificando la interfaz con sudo -S
print(f"Ejecutando 'arp-scan' en la interfaz {interface}...")

# Usar subprocess.Popen para pasar la contraseña al comando sudo
process = subprocess.Popen(['sudo', '-S', 'arp-scan', '-I', interface, '-l'],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True)

# Pasar la contraseña al proceso
stdout, stderr = process.communicate(input=password + '\n')

# Imprimir la salida del escaneo
if process.returncode == 0:
print("Dispositivos conectados a la red:")
print(stdout)
else:
print(f"Error al ejecutar arp-scan: {stderr}")

except Exception as e:
print(f"Hubo un error al escanear la red: {e}")

if __name__ == "__main__":
print("Obteniendo la interfaz de red activa...")
interface = get_network_interface()

if interface:
print(f"Interfaz de red activa: {interface}")
print("Escaneando dispositivos conectados a la red Wi-Fi...")
scan_network(interface)
else:
print("No se encontró ninguna interfaz de red activa. Verifica tu conexión.")


********************************************************************
GRACIAS, NOS VEREMOS EN EL AULA.
Imágen de perfil
Val: 40
Ha disminuido su posición en 2 puestos en Python (en relación al último mes)
Gráfica de Python

RAT CRACKER V1.2


Python

Publicado el 4 de Noviembre del 2019 por Joker_116 (6 códigos)
3.997 visualizaciones desde el 4 de Noviembre del 2019
Hola lectores hoy vengo con la segunda parte del RAT en python que habia publicado
esta ves con una mejor interfas grafica me refiero a que use la libreria de python colorama
para poner textos a color y acomode los banners y como siempre esta herramienta de administracion remota para hackear sistemas operativos windows y linux es compatible con ambas plataformas
solo abran el RATC.py y se abrira el rat con las opciones.

como ya dije RAT CRACKER sirve para obtener acceso remoto a otras maquinas
tanto dentro como fuera de lan.

para poder enviar el troyano generado por gmail lo comprimen en un .ZIP y luego en un .RAR con password
y haci el antivirus no lo puede escanear, no me hago responsable del mal uso de esta RAT.

por ultimo la opcion dos generara el troyano solo para la plataforma que estes usando ademas te pedira tu ip y el puerto en el que estara listando el server la ip devera ir entre comillas sin espacio.

para compilar el client.py desde linux para windows hay que generar el script con la opcion 2 y luego le damos a no compilar abrimos de nuevo el server y le damos a compilad desde linux para windows tiene que estar wine instalado y python instalado con wine.

JOKER 116
fake-mp3-troyan
RATC
screen_compile-options
screen_shot1
screen_shot2
Anterior12Siguiente