# Eliminar la primera ocurrencia de value en la lista.
 
import random
 
def eliminarElemento(lista, value):
    lista.remove(value)
 
def imprimirLista(lista,nombre):
    for i in range(0,len(lista)):
        print nombre + "[" + str(i) + "]=" + str(lista[i])
 
def leerLista():
    lista=[]
 
    i=0
    while i < 10:
        lista.append(int(random.randint(0, 10)))
        i=i+1
    return lista
 
A=leerLista()
imprimirLista(A,"A")
cn=int(raw_input("Valor a liminar: "))
eliminarElemento(A,cn)
imprimirLista(A,"A")

¿Qué necesitamos?
En principio, necesitamos hacer que Apache, incorpore un soporte para servir archivos Python. Para ello, necesitaremos habilitarle un módulo, que brinde este soporte.

Existen varios módulos de Apache que brindan soporte para correr archivos Python. Uno de los más populares es el módulo mod_python, que sin embargo, presenta algunos problemas que pueden prevenirse, utilizando el módulo mod_wsgi el cual utilizaremos en este curso.

1) Instalación de mod_wsgi en Apache

Para habilitar mod_wsgi en Apache, basta con instalar el paquete libapache2-mod-wsgi:

sudo apt-get install libapache2-mod-wsgi

2) Crear la estructura de directorios para nuestra aplicación

Primero, es importante saber, como va a funcionar nuestra aplicación y cómo va a interactuar vía Web.

Debemos tener un directorio destinado a montar toda la aplicación:

mkdir /home/yo/curso-python/trunk/python-web

Dentro de este directorio, vamos a dividir su arquitectura en dos partes:

Destinada al almacenaje de nuestra aplicación Python pura (será un directorio privado, no servido).
Destinada a servir la aplicación (directorio público servido) en el cuál solo almacenaremos archivos estáticos.

mkdir /home/yo/curso-python/trunk/python-web/mypythonapp
mkdir /home/yo/curso-python/trunk/python-web/public_html

Dentro de nuestro directorio mypythonapp, almacenaremos entonces, todos los módulos y paquetes de nuestra aplicación Python, mientras que en public_html, estarán todos los archivos estáticos y será el único directorio al que se pueda acceder mediante el navegador Web.

Aprovecharemos este paso, para crear una carpeta, destinada a almacenar los logs de errores y accesos a nuestra Web App:

mkdir /home/yo/curso-python/trunk/python-web/logs

3) Crear un controlador para la aplicación

Todas las peticiones realizadas por el usuario (es decir, las URI a las cuáles el usuario acceda por el navegador), serán manejadas por un único archivo, que estará almacenado en nuestro directorio mypythonapp.

echo ‘# -*- coding: utf-8 -*-‘ > mypythonapp/controller.py

Este archivo controller.py actuará como un pseudo front controller, siendo el encargado de manejar todas las peticiones del usuario, haciendo la llamada a los módulos correspondientes según la URI solicitada.

Dicho módulo, solo se encargará de definir una función, que actúe con cada petición del usuario. Esta función, deberá ser una función WSGI aplicación válida. Esto significa que:

Deberá llamarse application
Deberá recibir dos parámetros: environ, del módulo os, que provee un diccionario de las peticiones HTTP estándar y otras variables de entorno, y la función start_response, de WSGI, encargada de entregar la respuesta HTTP al usuario.

def application(environ, start_response): 
# Genero la salida HTML a mostrar al usuario output = "<p>Bienvenido a mi <b>PythonApp</b>!!!</p>" 
# Inicio una respuesta al navegador 
start_response('200 OK', [('Content-Type', 'text/html; charset=utf-8')]) 
# Retorno el contenido HTML 
return output<

Más adelante, veremos como crear un Application WSGI Controller, mucho más potente.

4) Configurar el VirtualHost

En la buena configuración de nuestro VirtualHost, estará la clave para correr nuestra aplicación Python a través de la Web.

Mientras que el DocumentRoot de nuestro sitio Web, será la carpeta pública, public_html, una variable del VirtualHost, será la encargada de redirigir todas las peticiones públicas del usuario, hacia nuestro front controller. Y la variable que se encargue de esto, será el alias WSGIScriptAlias:

sudo nano /etc/apache2/sites-available/python-web

Una vez allí, escribimos el contenido del nuevo virtual host:

<VirtualHost *:80>
ServerName python-web

DocumentRoot /home/yo/curso-python/trunk/python-web/public_html
WSGIScriptAlias / /home/yo/curso-python/trunk/python-web/mypythonapp/controller.py
ErrorLog /home/yo/curso-python/trunk/python-web/logs/errors.log
CustomLog /home/yo/curso-python/trunk/python-web/logs/access.log combined

<Directory />
Options FollowSymLinks
AllowOverride All
</Directory>
</VirtualHost>

Una vez configurado nuestro VirtualHost:

Habilitamos el sitio web: sudo a2ensite python-web
Recargamos Apache: sudo service apache2 reload
Habilitamos el sitio en nuestro host: sudo nano /etc/hosts y allí agregamos la siguiente línea:

127.0.0.1python-web

A partir de ahora, si abrimos nuestro navegador Web e ingresamos la url http://python-web veremos la frase: “Bienvenido a mi PythonApp”.

En este artículo veremos algunas herramientas que supuestamente nos ayudan a proteger nuestro código y lo fácil que es subvertirlas.

A continuación tenemos dos programas de ejemplo escritos en Python: el primero es una simple función que nos pide una contraseña y nos muestra un mensaje; el segundo ejemplo es igual, aunque en esta ocasión hemos utilizado una clase.

def main():

        a = "toomanysecrets"

        res = raw_input("Please enter your password: ")
        
        if res == a:
                print "ACCESS GRANTED"
        else:
                print "ACCESS DENIED"

if __name__ == "__main__":
	main()

secretapp1.py

class DoMain:

        def __init__(self):
                self.a = "toomanysecrets"

        def Ask(self):
                res = raw_input("Please enter your password: ")

                if res == self.a:
                        print "ACCESS GRANTED"
                else:
                        print "ACCESS DENIED"

if __name__ == "__main__":
	dm = DoMain()
	dm.Ask()

secretapp2.py

Supongamos que no quiero entregar el código de estos programas, por lo que tengo varias opciones. Nuestra primera opción será ofuscar el código, dificultando su lectura.

Pyobfuscate

Este programa nos permite ofuscar nuestro programa de forma totalmente válida para el intérprete Python. Veamos un ejemplo con SecretApp1 y SecretApp2.

Fig. 1 – Secretapp1 ofuscado

Fig. 2 – Secretapp2 ofuscado

A simple vista nuestro código no tiene sentido, pero si analizamos el resultado veremos cómo las cadenas de texto siguen en el código y podemos reconocer sintaxis de Python. No es demasiado difícil reconstruir el código ofuscado.

Htibctobf

Originalmente esta herramienta se escribió para resolver un reto en una competición de hacking en el congreso Hack in the Box.

A diferencia de la anterior herramienta, Htibctobf ofusca el código Python modificando los AST (Abstract Syntax Trees). Al ejecutar esta herramienta podemos ver nuestro código Python ofuscado en la Fig. 3 y Fig. 4.

Fig. 3 – Secretapp1 ofuscado

Fig. 4 – Secretapp2 ofuscado

Podemos observar el código ofuscado, incluso las cadenas de texto, sin embargo a pesar de todo no es demasiado difícil reconstruir el código original.

Sin duda un interesante concepto con amplias posibilidades pero que requiere de mejoras para ser útil.

En algunos casos quizás baste con ofuscar el código, pero busquemos otras opciones para proteger nuestro código de forma más efectiva: tendremos que recurrir a compilar el código Python creando un ejecutable.

Py2exe

Posiblemente una de las opciones más populares para convertir código Python en ejecutables Windows. Py2exe

En primer lugar tenemos que crear un fichero llamado setup.py que incluya una referencia a nuestro programa que queremos compilar. Ver código setup.

from distutils.core import setup
import py2exe

setup(console=['secretapp1.py'])

setup.py

Ya estamos listos para compilar nuestro código Python en un ejecutable Windows, para ello ejecutamos py2exe. Ver Fig. 5.

Fig. 5 – Compilando secretapp1.exe

Una vez finalizado el proceso de compilación, py2exe nos creará un directorio llamado “dist” que incluye nuestro ejecutable y algunas librerías necesarias. En la Fig. 6 podemos ver que py2exe finaliza con éxito y ejecutamos nuestro programa en formato exe.

Fig. 6 – Compilación completada

Ahora podríamos distribuir este binario sin miedo a entregar nuestro código o quizás no ¿?

Py2exe_extract

Esta herramienta nos permite extraer los objetos Python dentro de los ejecutables creados con py2exe, básicamente invertimos el proceso.Py2exe_extract

En la Fig. 7 podemos ver como utilizamos py2exe_extract para obtener el fichero objeto (el contenido de este fichero es independiente de la plataforma y se conoce como Bytecode) de nuestra aplicación secretapp1.exe (secretapp1.pyc)

Fig. 7 – Extrayendo el fichero objeto

Ahora tenemos que ver cómo podemos obtener el código de este fichero objeto.

Unwind

Unwind es un desensamblador para Python Bytecode que podemos utilizar para analizar ficheros objetos “.pyc”. Para este ejemplo he escrito un simple script en Python, mytest.py, que importa el desensamblador y analiza el fichero pyc. Ver código a continuación.

import unwind

print(unwind.disassemble('secretapp1.pyc'))

mytest.py

Con este script podemos ejecutar el siguiente comando y obtener un desensamblado del fichero objeto. Ver Fig. 8.

Fig. 8 – Python Bytecode

Uncompyle2

Otra opción es utilizar un decompilador como uncompyle2 para obtener el código directamente del fichero objeto “.pyc” sin tener que pasar por el desensamblador como vimos anteriormente.

Esta herramienta es potente y fácil de utilizar, como se puede observar en la Fig. 9 mediante un simple comando obtenemos el código fuente de secretapp1.pyc.

Fig. 9 – Código de secretapp1 obtenido del fichero objeto

Wow, tenemos código fuente!

A lo largo del artículo hemos visto algunas técnicas de ofuscación y compilación de código Python para protegerlo, no obstante hemos podido subvertir todo el proceso de protección fácilmente 

La siguiente lista son otros compiladores Python que podemos utilizar para Windows, Linux o MacOS, pero tienen los mismos problemas.

• cx_Freeze
• Shed Skin
• py2app

También podríamos analizar y subvertir el binario utilizando herramientas como IDA PRO o Immunity Debugger, lo que dejaremos para un futuro post. Otra interesante herramienta que no he comentado es pyREtic, un potente framework para reversing de in-memory de Python Bytecode.

Que un atacante consiga el código Python es cuestión de tiempo, sin embargo para ponérselo realmente difícil desde un punto de vista defensivo se
tienen que combinar diferentes técnicas.

Fuente simonroses

Sin mas aqui esta el codigo.

# Obtenemos números.
numeros = []
for i in ['primer', 'segundo','tercer']:
    texto = u'Introduce el %s número: ' % (i)
    numeros.append(float(raw_input(texto)))

# Ordenamos.
numeros.sort()

# Obtenemos máximo y mínimo.
minimo = numeros[0]
maximo = numeros[2]

# Obtenemos la media aritmética.
media = round((numeros[0] + numeros[1] + numeros[2]) / float(3),3)

# Visualizamos resultados.
cadena = u'Mínimo: %d, Máximo: %d, Media: %f' % (minimo, maximo, media)
print cadena

En esta ocasión le mostrare como convertir fácilmente de python a Windows con la librería cx_Freeze el cual descargaremos http://cx-freeze.sourceforge.net/ ahí elegimos la versión que tenemos instalada de python y la versión del sistema si es 32 o 64 bits, luego tendremos que crear un archivo de configuración donde pondremos los datos de información de nuestro sistema y donde importaremos la librería quedando de la siguiente forma.

#setup.py
from cx_Freeze import setup, Executable
setup(
   name = "Nombre interno",
   version = "0.1",
   description = "Descripcion",
   executables=[Executable("Tuprograma.py")]
)  

Donde Tuprograma.py es el código de tu programa una vez tengamos estos nos dirigimos a la consola de Windows y teclearemos el el siguiente comando

Python.exe .\setup.py build

En este ejemplo se supone que el archive de configuración es setup.py y que esta en la misma carpeta donde esta nuestro ejecutable de python

Luego de esto se creara una carpeta llamada build y en ella se encontrara nuestra aplicación ya compilada

import random

def insertarElemento(lista, indice, elemento):
    lista.insert(indice,elemento)

def imprimirLista(lista,nombre):
    for i in range(0,len(lista)):
        print nombre + "[" + str(i) + "]=" + str(lista[i])

def leerLista():
    lista=[]

    i=0
    while i < 10:
        lista.append(int(random.randint(0, 10)))
        i=i+1
    return lista

A=leerLista()
imprimirLista(A,"A")
cn_val=int(raw_input("Ingrese Valor: "))
cn_ind=int(raw_input("Ingrese Indice: "))
insertarElemento(A,cn_ind,cn_val)
imprimirLista(A,"A")

Tor acepta trae integrado en servidor telnet el cual acepta comando entre ellos el signal newnym el cual concede una nueva conexión a tor
En esta ocasión dejo un pequeño código en python el cual renueva la nueva identidad para ello se debe de entrar a la configuración de tor y ponerle una contraseña para acceder al Telnet.

Hay que hacer mencion que se debe tener la libreria TorCtl instala en pyton para que este funcione ya que sin ella no funcionara el codigo

from TorCtl import TorCtl
conn = TorCtl.connect(controlAddr="127.0.0.1", controlPort=9051, passphrase="abc")
TorCtl.Connection.send_signal(conn, "NEWNYM")

Esto es algo que nos ha sorprendido a todos los que alguna vez nos hemos enfrentado al Python. ¿Por qué demonios no hay un switch? ¿Y ahora qué hago yo? ¿Tengo que anidar un montón de if-else?

Pues no, en Python no existe la estructura switch. Sin embargo no es necesario empezar a anidar if-else, podemos usar diccionarios.

Un diccionario en Python es parecido a lo que en otros lenguajes se llama array asociativo y se define así:

edades = { 'Paco': 20, 'Luis': 25, 'Lucas': 30 }

y la forma de usarlo es:

edades['Paco']

por ejemplo:

print ("La edad de Paco es "+str(edades['Paco'])+".")

Que mostrará: La edad de Paco es 20. Entonces, si quisiéramos algo como esto (ojo, recuerda que este código no funciona en Python):

nombre = "Luis"
switch(nombre):
   case 'Paco':
     edad = 20
     break
   case 'Luis':
     edad = 25
     break
   case 'Lucas':
     edad = 30
     break
print edad

tendríamos que hacer:

edades = { 'Paco': 20, 'Luis': 25, 'Lucas': 30 }
nombre = 'Luis'
edad = edades[nombre]
print edad

Bastante sencillo ¿no? Pero, podrías pensar, esto está muy bien para seleccionar valores como en este caso pero ¿y si lo que quiero es llamar a una función o ejecutar un bloque de código? Pues tranquilo, porque se puede. Mira el siguiente ejemplo:

def sumar(a, b):
    return a + b
 
def restar(a, b):
    return a - b
 
def multiplicar(a, b):
    return a * b;
 
num1 = raw_input("Num1: ")
num2 = raw_input("Num2: ")
 
print("Opciones\n1.- Sumar\n2.- Restar\n3.- Multiplicar")
 
operaciones = { '1': sumar, '2': restar, '3': multiplicar}
 
seleccion = raw_input('Escoge una: ')
try:
    resultado = operaciones[seleccion](int(num1), int(num2))
    print resultado
except:
    print("Esa no vale")

Como en este caso no sabemos la opción que va a elegir el usuario (podría teclear un 4 o cualquier otra cosa) tenemos que usar try-except para evitar errores (algo similar al default de los switch-case).

if condición:
  aquí van las órdenes que se ejecutan si la condición es cierta
  y que pueden ocupar varias líneas
else:
  y aquí van las órdenes que se ejecutan si la condición es
  falsa y que también pueden ocupar varias líneas

La primera línea contiene la condición a evaluar. Esta línea debe terminar siempre por dos puntos (:).
A continuación viene el bloque de órdenes que se ejecutan cuando la condición se cumple (es decir, cuando la condición es verdadera).

Es importante señalar que este bloque debe ir sangrado, puesto que Python utiliza el sangrado para reconocer las líneas que forman un bloque de instrucciones. El sangrado que se suele utilizar en Python es de cuatro espacios, pero se pueden utilizar más o menos espacios. Al escribir dos puntos (:) al final de una línea, IDLE sangrará automáticamente las líneas siguientes. Para terminar un bloque, basta con volver al principio de la línea.

Después viene una línea con la orden else (opcional), que indica a Python que el bloque que viene a continuación se tiene que ejecutar cuando la condición no se cumpla (es decir, cuando sea falsa). Esta línea también debe terminar siempre por dos puntos (:).

En último lugar está el bloque de instrucciones sangrado que corresponde al else.

edad = int(input("¿Cuántos años tiene? "))
if edad < 18:
    print("Es usted menor de edad")
else:
    print("Es usted mayor de edad")
print("¡Hasta la próxima!")

Este programa pregunta la edad al usuario y almacena la respuesta en la variable “edad”. Después comprueba si la edad es inferior a 18 años. Si esta comparación es cierta, el programa escribe que es menor de edad y si es falsa escribe que es mayor de edad. Finalmente el programa siempre se despide, ya que la última instrucción está fuera de cualquier bloque y por tanto se ejecuta siempre.

Sin mas por el momento aqui dejo el codigo

a=float(input("ingresa numero\n"))  
b=float(input("ingresa numero\n"))  
suma=a+b  
print(str(suma))