En determinadas «circunstancias especiales» puede ser necesario que un PC tenga una tarjeta de red con una dirección MAC específica. Esta receta explica cómo conseguirlo con ifconfig, iproute o macchanger

Un minúsculo tutorial para quién necesite o simplemente le apetezca aprender Python.

Introducción

Python es un lenguaje interpretado, interactivo y orientado a objetos. Se le compara con C++. Java o Perl. Tiene variables, clases, objetos, funciones y todo lo que se espera que tenga un lenguaje de programación «convencional». Cualquier programador puede empezar a trabajar con Python con poco esfuerzo. Según muchos estudios, Python es uno de los lenguajes más fáciles de aprender y que permiten al novato ser productivo en tiempo record, lo cual lo hace ideal como primer lenguaje.

Python es perfecto como lenguaje «pegamento» y para prototipado rápido de aplicaciones (aunque finalmente fuera necesario rehacerlas en otros lenguajes), aunque eso no implica que no se puedan ser definitivos. Dispone de librerías para desarrollar aplicaciones multihilo, distribuidas, bases de datos, con interfaz gráfico, juegos, gráficos 3D, cálculo científico, machine learning y una larga lista.

Este pequeño tutorial utiliza la versión actual de Python (3.9) y presupone que el lector tiene nociones básicas de programación con algún lenguaje como C, Java o similar.

Empezamos

Nada como usar algo para aprender a usarlo. El intérprete de Python se puede utilizar como una shell (lo que se llama modo interactivo), algo que viene muy bien para dar nuestros primeros pasos.

$ python3
Python 3.9.1+ (default, Jan 20 2021, 14:49:22)
[GCC 10.2.1 20210110] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Variables y tipos

Las variables no se declaran explícitamente, se pueden usar desde el momento en que se inicializan. Y normalmente no hay que preocuparse por liberar la memoria que ocupan, tiene un «recolector de basura» (como Java).

$ python3
>>> a = "hola"

En el modo interactivo se puede ver el valor de cualquier objeto simplemente escribiendo su nombre:

>>> a
'hola'

Python es un lenguaje de tipado fuerte, pero dinámico. Eso significa que no se puede operar alegremente con tipos diferentes (como se hace en C). Las operaciones están definidas para trabajar con los tipos previstos.

>>> a + 1
Traceback (most recent call last):
  File "", line 1, in 
TypeError: Can't convert 'int' object to str implicitly

Esa operación ha provocado que se dispare la excepción TypeError. Las excepciones son el mecanismo más común de notificación de errores.

Pero se puede cambiar el tipo de una variable sobre la marcha:

>>> a = 3

En realidad no hemos cambiado el tipo de a, sino que hemos creado una nueva variable que reemplaza la anterior.

Tipos de datos

Valor Nulo

Una variable puede existir sin tener valor ni tipo, para ello se asigna el valor None. Es el valor adecuado cuando se quiere indicar que una variable no se refiere a ningún objeto:

>>> a = None
>>> a

>>>

Booleanos

Lo habitual:

>>> a = True
>>> a
True
>>> not a
False
>>> a and False
False
>>> 3 > 1
True
>>> b = 3 > 1
>>> b
True

Numéricos

Python dispone de tipos enteros de cualquier tamaño que soportan todas las operaciones propias de C, incluidas las de bits. También hay reales como en cualquier otro lenguaje. Ambos tipos se pueden operar entre si sin problema. Incluso tiene soporte para números complejos de forma nativa.

>>> a = 2
>>> b = 3.0
>>> a + b
5.0
>>> b - 4j
(3-4j)

Secuencias

No hay tipo carácter, se utilizan cadenas de tamaño 1. Las cadenas admiten operaciones como la suma y la multiplicación.

>>> greeting = 'hola '
>>> greeting + 'mundo'
'hola mundo'
>>> greeting * 3
'hola hola hola '

El tipo bytes permite manejar secuencias de bytes. Es especialmente útil para serialización de datos. Por ejemplo, podemos convertir una cadena de caracteres UTF-8 a bytes y viceversa:

>>> word = 'ñandú'
>>> coded = word.encode()
>>> coded
b'\xc3\xb1and\xc3\xba'
>>> coded.decode()
'ñandú'

Las tuplas son una agrupación de valores similar al concepto matemático de tupla. Se pueden empaquetar y desempaquetar varias variables (incluso de tipo diferente).

>>> x = greeting, 'f', 3.0
>>> x
('hola ', 'f', 3.0)
>>> v1, v2, v3 = x
>>> v2
'f'

Las Listas son similares a los vectores o arrays de otros lenguajes, aunque en Python se pueden mezclar tipos.

>>> x = [1, 'f', 3.0]
>>> x[0]
1

Las listas también se pueden sumar y multiplicar:

>>> x = [1, 'f', 3.0]
>>> x + ['adios']
[1, 'f', 3.0, 'adios']
>>> x * 2
[1, 'f', 3.0, 1, 'f', 3.0]

Cualquier secuencia se puede indexar desde el final o mediante «rodajas» (slices):

>>> greeting = 'holamundo'
>>> greeting[-1]
'o'
>>> greeting[1:6]
'olamu'
>>> greeting[:3]
'hol'
>>> greeting[3:]
'amundo'
>>> greeting[-6:-2]
'amun'

Los diccionarios son tablas asociativas:

>>> grades = {'antonio':6, 'maria':9}
>>> grades['antonio']
6

Python dispone de otros tipos de datos nativos como conjuntos (sets), pilas, colas, listas multidimensionales, etc.

Type checking

Aunque Python es un lenguaje de tipado dinámico, en la versión 3.0 ya se daba la opción de hacer anotaciones sobre las variables y sus tipos, y actualmente (se introdujo con el PEP 484) existe un módulo donde se definen la semántica y convenciones para especificar de forma opcional esas anotaciones o hints.

>>> pi: float = 3.14

Las anotaciones de las variables se almacenan en el atributo __annotations__:

>>> a = "hola"
>>> pi: float = 3.14
>>> __annotations__
{'pi': }

El comportamiento del lenguaje es el mismo, y las variables puede cambiar el tipo de valor que almacenan independientemente de su definición sin producir errores:

>>> pi: float = 3.14
>>> pi = "Tres coma catorce"

Sirve principalmente para facilitar la comprensión del código y poder llevar a cabo comprobaciones de tipos o type checking sobre el código escrito con herramientas como MyPy.

Orientado a objetos

Casi todo en Python está orientado a objetos, incluyendo las variables de tipos básicos, y hasta los literales!

>>> cad = 'holamundo'
>>> cad.upper()
'HOLAMUNDO'
>>> 'ADIOS'.lower()
'adios'

Módulos

Los módulos son análogos a las 'librerías' o 'paquetes' de otros lenguajes. Para usarlos se utiliza la sentencia import:

>>> import sys
>>> sys.exit(1)

Estructuras de control

Están disponibles las más habituales: for, while, if, if else, break, continue, return, etc. Todas funcionan de la forma habitual excepto for. El for de Python no es un while disfrazado, como ocurre en algunos lenguajes. Este for hace que, en cada iteración, la variable de control tome los valores que contiene una secuencia, es decir, que itere sobre ella. Ejemplo:

>>> for c in "hello":
...    print(c)
...
'h'
'e'
'l'
'l'
'o'

Indentación estricta

En muchos lenguajes se aconseja «tabular» de determinada manera para facilitar su lectura. En Python este estilo es obligatorio porque el esquema de indentación define los bloques. Es una importante peculiaridad de este lenguaje. Se aconseja tabulación blanda de 4 espacios. Mira el siguiente fragmento de un programa Python:

total = 0
passed = 0
grades = {'antonio':6, 'maria':9}
for i in grades.values():
   total += i
   if i >= 5:
      passed += 1

print('Average:', total / len(grades))

El cuerpo del bloque for queda definido por el código que está indentado un nivel debajo de él. Lo mismo ocurre con el if. La sentencia que define el bloque siempre lleva un ':' al final. No se utilizan llaves ni ninguna otra cosa para delimitar los bloques.

Funciones

Nada mejor para explicar su sintaxis que un ejemplo:

def factorial(n):
    if n == 0:
       return 1
    return n * factorial(n-1)

# y su invocación
print(factorial(10))

Python is different

Como cualquier lenguaje, Python tiene sus peculiaridades, y conocerlas puede ayudar a sacarle el máximo potencial. Siempre hay una manera más «pythónica» de hacer las cosas, utilizando por ejemplo las características de programación funcional que incorpora. Como ejemplo, el factorial se puede hacer aún más compacto con algo como:

from functools import reduce
from operator import mul
factorial = lambda x: reduce(mul, range(1, x+1), 1)
print(factorial(10))

Muy aconsejable Python Is Not Java

Hacer un fichero «ejecutable»

#!/usr/bin/python3

Y no olvides darle permisos de ejecución al fichero:

$ chmod +x fichero.py

¿Y ahora qué?

• Python koans
• Empieza por el el tutorial oficial.
• Incluso hay varios libros libres:
  • Inmersión en Python 3
  • Byte of Python
  • Learning Python
  • Codeacademy
  • Introducción a la programación en Python 3/a>
• Si necesitas la referencia oficial, pues la la página de Python

Esta receta es para todos aquellos que estais en un entorno restrictivo en el que solo hay acceso al exterior a través de un proxy HTTP, como es mi caso actualmente.

Tan solo os será necesario un programa llamado Corkscrew. Los usuarios de Debian y derivados lo tenemos a tiro de apt-get.

Explicación

¿Qué hace este programa? Pues aprovecha una capacidad del proxy, el método CONNECT que permite hacer una conexión a un puerto TCP usando al proxy como intermediario. Lógicamente esto es de sobra conocido por un administrador de red y lo mas normal es que el proxy esté situado detrás de un firewall que no permitirá al proxy acceder a puertos distintos de los puramente web. Estos puertos son el HTTP:80 y HTTPS:443, cabe la posibilidad de que también tengamos acceso a FTP a través del proxy, lo que significará que éste también puede acceder a los puertos 20 y 21.

Con esta información ya nos vamos haciendo una idea de lo que va a pasar. Vamos a invocar ssh a través de Corkscrew para que se conecte al servidor de destino utilizando el proxy. El servidor de SSH utiliza el puerto 22 y lo normal es que el proxy no pueda acceder a dicho puerto, por este motivo será necesario que en el servidor al que queremos acceder le hayamos hecho un pequeño truco previo. El “truco” consiste en redirigir un puerto web que no esté en uso al puerto 22. Usualmente se utiliza el 443.

Vamos a ver como se cocina todo esto junto.

Elaboración

En primer lugar hay que redirigir el tráfico de nuestro servidor, del puerto 443 al 22. Una opción es lanzar el demonio ssh directamente en el puerto 443, pero eso no parece una solución elegante. No obstante quien quiera hacerlo no tiene más que tocar en /etc/ssh/sshd_config.

Lo mas limpio es usar iptables para redirigir el trafico. La orden es esta.

# iptables -t nat -A PREROUTING -i ippp0 -p tcp --dport 443 -j REDIRECT --to-port 22

Con corkscrew instalado vamos al directorio $HOME/.ssh y editamos el fichero config (si no existe, lo creamos). En su interior ponemos esto:

Host servidor.casa.com
ProxyCommand /usr/bin/corkscrew proxy.curro.es 8080 %h %p

Donde proxy.curro.es el la dirección del proxy de nuestra red y 8080 es el puerto que usa el proxy. Las variables %h y %p se refieren al host y al port que usaremos para conectar y se le pasan desde el comando ssh como veremos a continuación.

Ahora para conectar a cualquier sitio tan sólo necesitamos ejecutar la orden.

$ ssh -p 443 usuario@servidor.casa.com

Más difícil todavía

Si nuestro proxy necesita autenticación tendremos que crear un segundo fichero en .ssh/autenticacion con lo siguiente

usuario:password

y en el fichero anterior (ssh_proxy) ponemos:

ProxyCommand /usr/bin/corkscrew proxy.curro.es 8080 %h %p $HOME/.ssh/autenticacion

Un consejo final

Si os pasa, además de todo lo anterior, que vuestra conexión se corta cada dos por tres por falta de actividad basta con añadir esto en el fichero ssh_proxy

ServerAliveInterval 60
ProxyCommand /usr/bin/corkscrew proxy.curro.es 8080 %h %p

¿Utilidad final de todo esto?

Vale, ya puedo acceder mediante SSH al ordenador de casa desde el trabajo, ¿y que? Pues si tenéis problemas con el proxy de vuestro trabajo porque os deniega el acceso a algunas páginas web que os son imprescindibles y el departamento de sistemas os ignora completamente, tan solo tenéis que instalar un proxy HTTP en vuestro ordenador, como por ejemplo squid (la configuración por defecto de squid en Debian funciona para lo que queremos hacer) y tunelizar las peticiones desde nuestro ordenador con el siguiente comando.

$ssh -p 443 usuario@servidor.casa.com -L 3128:localhost:3128

Estamos suponiendo que el servidor squid casero corre en el puerto por defecto, y redirigimos nuestro puerto local hacia el puerto remoto. Ahora solo tenemos que configurar el programa que queramos para que use como proxy

localhost:3128

Enlaces relacionados

• Establecer una sesión SSH a través de Proxy

En esta receta explico como instalar eDonkey2000. La idea es instalar el core en un PC y el cliente ed2k-gui en otro PC distinto.

Instalar el core

# dpkg -i el_core_que_sea.deb

$ edonkeyclc
[--- Storing settings in '/XXXXX/XXXX/.eDonkey2000' ---]

Welcome to eDonkey2000 command line client 1.3.0
Enter commands at any time (type '?' for help)
>

> name fulanito

> dumax 20 7

> pass usuario passwd

> vo
Name:                   fulanito
Max Download Speed:     20.00
Max Upload Speed:       7.00
Line Speed Down:        0.00
TCP Port:               0
UDP Port:               3620
Admin Port:             4663
Admin Name:             usuario
Admin Pass:             passwd
Verbose:                0
SaveCorrupted:          1
MaxConnections:         45
ScreenLines:            24
Allow Private Messages:         0
Allow Viewing of Files:         0

> q
Are you sure wanna quit (Y/n)?
y

$ edonkeyclc -g

Instalar el gui

# dpkg -i paquetito_gui.deb

Hostname or IP: 1.2.3.4
Admin Port: 4663
Admin Username: usuario
Admin Password: passwd

Script de inicio

#!/bin/bash

PROGRAM=edonkeyclc
PROGRAM_DIR=/home/tu_usuario
PROGRAM_LOG=/tmp

case "$1" in
  start)
     cd $PROGRAM_DIR
     su - tu_usuario -c "$PROGRAM -g -l" >> $PROGRAM_LOG/edonkey.log &
     sleep 5
     echo -e "¡¡¡¡¡¡¡ CORE ejecutandose !!!!!!!\n"
  ;;
  stop)
     sync
     kill -9 `pidof $PROGRAM`
     echo -e "¡¡¡¡¡¡¡ Parando el CORE !!!!!!!\n"
     sleep 2
  ;;
  *)
     echo "Uso: /etc/init.d/core-ed2k {start|stop}"
     exit 1
  ;;
esac

exit 0

 # update-rc.d core-ed2k start 99 2 . stop 99 0 2 .

 /etc/init.d/core-ed2k {start|stop}

Enlaces

• eDonkey
• ed2k-gtk-gui

Cómo utilizar la herramienta jigdo para descargar las ISO de los CDs y DVDs de Debian.

Cómo configurar «a mano», es decir, sin DHCP, los parámetros más importantes de una tarjeta de red en Debian GNU/Linux, Ubuntu o similar.

Hay otras posibilidades (como etherconf) pero la finalidad de esta receta es utilizar los comandos básicos disponibles en los sistemas GNU/Linux, en concreto con ipconfig y route del paquete net-tools.