UNIVERSIDAD TECNOLOGICA DE HONDURAS

UTH

CAMPUS: SPS

CLASE: TELECOMUNICACIONES

CATEDRATICO: ING. NORMAN CUBILLAS

ALUMNO: MARLON ALBERTO ANTUNEZ

# CUENTA: 201210040082

ACUMULATIVO: MANUAL PROYECTO 3ER PARCIAL

SPS, 22 AGOSTO DEL 2020

Manual Emulación control Mikrotik desde interfaz de Python .

El presente manual presenta el procedimiento para el realizar la interfaz de control de usuario

programada en Python.

Equipo utilizado:

 Una máquina virtual con kubuntu Desktop, sobre VMware

 Imagen virtualizada de un router Mikrotik, con 4 adaptadores de red en modo bridged. En
caso el ip principal de mi router será la 192.168.0.35.

 Se estableció un certificado de confianza entre el mikrotik y el servidor Ubuntu para el

usuario mantunez con credencial uth1234
Back-End
Sobre nuestro back-End se han configurado una serie de script necesarios que se llamaran a nivel
de Python.

1. Script para insertar el segmento de red de forma remota. Llamado add.sh, ubicado sobre
el directorio /home/mantunez, este script como se pueda apreciar contiene los comandos
necesarios para conectar vía ssh hacia el equipo mikrotik con ip 192.168.0.35.

Este script a nivel de programación en Python va acompañado por una función llamada
Apply:
 En esta función se toman en primera instancia el segmento de red, el numero de ether
sobre el que dicho segmento de red en nuestro mikrotik y luego los comentarios si los
tuviese aplicados. Avanzo con la sintaxis, se crean unas constantes para el almacenar los
parámetros de ssh que utilizan para las consultas remotas al mikrotik. Posterior de aplican
los permisos de super root al Shell add.sh.

2. Script para eliminar una interfaz de red configurada previamente en nuestro mikrotik, en
nuestro caso de tomara de referencia un flags o el numero de ether ocupado por algún
segmento de red en específico. El Shell de referencia se llama delete.sh ubicado sobre el
directorio /home/mantunez

La función a nivel programación en Python que se encarga de mandar a eliminar alguna ip

configurada a nivel de interfaz en el mikrotik es la siguiente:
3. Script en Shell encargado de deshabilitar alguna interfaz de nuestro mikrotik es disable.sh:

La función que utiliza este Shell desde Python se llama disabled:

4. Script en Shell que tomara la función para habilitar alguna interfaz de red, que pueda estar
deshabilitada se llama enable.sh, ubicado en el directorio /home/mantunez

Función encargada de llamar este script desde Python se llama enable

5. Desde nuestra interfaz de usuario, se mostrará print de las interfaces activas en nuestro
mikrotik, para ello será necesario escribir sobre un archivo de texto llamado en nuestro
Ubuntu ubicado sobre nuestro directorio /home/mantunez/read.txt que al cual se envían
los parámetros de red que tiene nuestro mikrotik en ese momento.
Vista de nuestro archivo a nivel de Back-End:

A nivel Front-End se vería de la siguiente manera:

Desde Python la función encargada de hacer esta rutina se llama read()

6. Desde el sistema de emulación a nivel front-end, hay una función que hará una copia de
una interfaz de red esto para hacer más fácil la edición de una nueva interfaz para ello se
configuro la siguiente función que hace uso de unos Shell scripting; La función a la que
hago referencia a nivel de Python se llama copy()
 Dentro de la sintaxis de esta función se puede apreciar el archivo filtro.sh, este en este
caso se encarga de seleccionar la interfaz de red que nosotros seleccionemos a nivel de
aplicación. El contenido de este script es el siguiente:

Este script se encarga de tomar la interfaz de red seleccionada para luego mandarla a
guardar un archivo local llamado filtro.txt, de momento tiene el siguiente contenido:

El siguiente Shell que se pueda apreciar incluido en la función de Python se llama

copyprocess.sh, este se encarga de separar los parámetros necesarios en decir separarlos
por variables para poderlos copiar al texto en nuestro interfaz de usuario;

7. Como se puedo apreciar durante la presentación del interfaz de usuario al inicio del
manual esta incluido unos tabs los cuales tienen otras funciones este caso para definir
ruteos estáticos al mikrotik
 Este tab de ruteos, tiene una función Python que se encarga de llamar a un Shell para
agregar los parámetros que agreguemos de ruteos en nuestra interfaz de usuario. La
función utilizada en la segunda pestana de sistema se llama addRoute ()

El script que se encarga guardar el ruteo en nuestro mikrotik se llama addRoute.sh, con el
siguiente contenido:

8. Desde la misma interfaz de usuario también se utiliza para mandar imprimir los ruteos que
existen en ese momento en el mikrotik, la función que se encarga de realizar ese proceso
se llama printRoute ()

Como se puede apreciar en la función en primera instancia se establece una conexión por
ssh al mikrotik y se mandan a traer los ruteos que existan en él, para luego mandarlos a
guardar al archivo txt printRoute.txt:
 Este archivo de texto, se utiliza para luego mandarse a mostrar en el interfaz de usuario:

9. En la tercera pestaña desde Python, se agregaron unas funciones básicas de instrucciones

como ser mostrar le nombre del mikrotik, mandar instrucción para reiniciarlo o apagarlo.
Las funciones encargadas de dichos propósitos son:

CODIGO FUENTE EMPLEADO A NIVEL PYTHON

# Librerias
from Tkinter import *
import ttk
import tkFont
import tkMessageBox
import os
import subprocess
import ScrolledText
import time

# Crear ventana
v0=Tk()
v0.title("New Address")
v0.geometry("600x500+200+100")
v0.configure(bg="#0ac1b1")

def clean():
address.set('')
interface.set('')
comment.set('')
numero.set('')
ethernet.set('')
# Defincion de Funciones
def Apply():
# Variables
ad=address.get()
ether=interface.get()
comm=comment.get()
# Constantes
enc="#!/bin/bash"
tab=" "
cs="'"
sshpass="sshpass -p \"uth1234\" ssh -l mantunez 192.168.0.35"
ipadd="ip address add address="
intf="interface="
c="comm="
# Asignar full privilegios add.sh
os.system("sudo chmod -R 777 add.sh")
#crear la variable cadena
cadena=(str(sshpass)+''+str(tab)+''+str(cs)+''+str(ipadd)+''+str(ad)+''+str(tab)+''+str(int$

form = Tk()
form.title("Configuracion Mikrotik UTH")
form.geometry("700x380")

style =ttk.Style(form)
style.configure("lefttab.TNotebook",tabposition="wn")
tab_root=ttk.Notebook(form,style="lefttab.TNotebook")

tab1=ttk.Frame(tab_root, width=200, height=200)

tab2=ttk.Frame(tab_root, width=200, height=200)
tab3=ttk.Frame(tab_root, width=200, height=200)

tab_root.add(tab1,text="Address ")
tab_root.add(tab2,text="Rutas ")
tab_root.add(tab3,text="System ")

tab_root.pack(expand=25,fill='both')

# Apertura del Archivo

pf=open(r'/home/mantunez/add.sh','w')
pf.write(enc)
pf.write("\n")
pf.write(cadena)
pf.write("\n")
pf.close()
time.sleep(0.1)
os.system("sudo /./home/mantunez/add.sh &")
clean()

def delete():
n=numero.get()
delete="ip address remove"
tab=" "
cs="'"
enc="#!/bin/bash"
sshpass="sshpass -p \"uth1234\" ssh -l mantunez 192.168.0.35"
# Asignar full privilegios al archivo
os.system("sudo chmod -R 777 delete.sh")

cadena_delete=(str(sshpass)+''+str(tab)+str(cs)+''+str(delete)+''+str(tab)+''+str(n)+''+st$

# apertura del Archivo

pf2=open(r'/home/mantunez/delete.sh','w')
pf2.write(enc)
pf2.write("\n")
pf2.write(cadena_delete)
pf2.write("\n")
pf2.close()
os.system("sudo /./home/mantunez/delete.sh &")
clean()

def disabled():
n=numero.get()
disable="ip address disable"
 tab=" "
cs="'"
enc="#!/bin/bash"
sshpass="sshpass -p \"uth1234\" ssh -l mantunez 192.168.0.35"
# Asignar full privilegios al archivo
os.system("sudo chmod -R 777 /home/mantunez/disable.sh")
# Crear de cadena de comando
cadena_disable=(str(sshpass)+''+str(tab)+''+str(cs)+''+str(disable)+''+str(tab)+''+str(n$
pf3=open(r'/home/mantunez/disable.sh','w')
pf3.write(enc)
pf3.write("\n")
pf3.write(cadena_disable)
pf3.close()
os.system("sudo /./home/mantunez/disable.sh &")
clean()
def enable():
n=numero.get()
enable="ip address enable"
tab=" "
cs="'"
enc="#!/bin/bash"
sshpass="sshpass -p \"uth1234\" ssh -l mantunez 192.168.0.35"
# Asignar full privilegios al archivo
os.system("sudo chmod -R 777 /home/mantunez/enable.sh")
# Crear de cadena de comando
cadena_enable=(str(sshpass)+''+str(tab)+''+str(cs)+''+str(enable)+''+str(tab)+''+str(n)+$
pf3=open(r'/home/mantunez/enable.sh','w')
pf3.write(enc)
pf3.write("\n")
pf3.write(cadena_enable)
pf3.close()
os.system("sudo /./home/mantunez/enable.sh &")
clean()

def read():
os.system('sshpass -p "uth1234" ssh -l mantunez 192.168.0.35 "ip address print" >
/home/mant$
valor1=subprocess.check_output("cat /home/mantunez/read.txt",shell=True)
textarea1=ScrolledText.ScrolledText(v0,width=80,height=20)
textarea1.place(x=10,y=160)
textarea1.insert(INSERT,valor1)
v0.after(1000,read)
read()
def copy():
ether=ethernet.get()
if (ether==''):
tkMessageBox.showinfo("save",message="Campo vacio, indicar que ether clonar")
else:
 comando="ip address print where interface="
tab=" "
cs="'"
enc="#!/bin/bash"
sshpass="sshpass -p \"uth1234\" ssh -l mantunez 192.168.0.35"
tuberia=">"
destino="/home/mantunez/filtro.txt"
#Filtro addresses list
cadena_filtro=(str(sshpass)+''+str(tab)+''+str(cs)+''+str(comando)+''+str(ether)+''+str$
# arhivo filtro full permisos
os.system("sudo chmod -R 777 filtro.sh")
pf4=open(r'/home/mantunez/filtro.sh','w')
pf4.write(enc)
pf4.write("\n")
pf4.write(cadena_filtro)
pf4.write("\n")
pf4.close()
os.system("sudo /./home/mantunez/filtro.sh")
os.system("sudo /./home/mantunez/filtro.sh")
time.sleep(1)
os.system("sudo /./home/mantunez/copyprocess.sh")
time.sleep(1)
os.system("sudo /./home/mantunez/copyprocess.sh")
clean()
p1=subprocess.check_output("cat /home/mantunez/p1.txt",shell=True)
p2=subprocess.check_output("cat /home/mantunez/p2.txt",shell=True)
#p1=p1.split("\n")
#p2=p2.split("\n")
address.set(p1)
interface.set(p2)
comment.set("COPIA")
def Salir():
os.system("sudo pkill -f addmk1.py")

# configurar texto
text1_titulo=tkFont.Font(family="Arial",size=14)
text2=tkFont.Font(family="arial",size=12)
text3=tkFont.Font(family="arial",size=10)
# Etiquetas
label_titulo=Label(v0,text="--- Agregar IP ---",font=text1_titulo).place(x=10,y=5)
label_address=Label(v0,text="Address",font=text2).place(x=10,y=50)
label_interface=Label(v0,text="Interface",font=text2).place(x=10,y=80)
label_comment=Label(v0,text="Comment",font=text2).place(x=10,y=110)
label_flags=Label(v0,text="Flags",font=text3).place(x=400,y=70)
label_ether=Label(v0,text="ethernet",font=text3).place(x=500,y=70)
# zona de variables
global address
global interface
global comment
global numero
global ethernet
address=StringVar()
interface=StringVar()
comment=StringVar()
numero=StringVar()
ethernet=StringVar()
# Cajas de Texto
txt_address=Entry(v0,textvariable=address,width=20).place(x=100,y=50)
txt_interface=Entry(v0,textvariable=interface,width=20).place(x=100,y=80)
txt_comment=Entry(v0,textvariable=comment,width=20).place(x=100,y=110)
txt_number=Entry(v0,textvariable=numero,width=5).place(x=400,y=90)
txt_ethernet=Entry(v0,textvariable=ethernet,width=7).place(x=500,y=90)
# Botones
btn_apply=Button(v0,text=" Apply ",bg="light green",borderwidth=4,
command=Apply).place(x=600,y=50)
btn_read=Button(v0,text=" Read ",bg="light green",borderwidth=4,
command=read).place(x=600,y=90)
btn_remove=Button(v0,text=" Delete ",bg="light green",borderwidth=4,
command=delete).place(x=600,y=130)
btn_salir=Button(v0,text=" Salir ",bg="light green",borderwidth=4,
command=Salir).place(x=600,y=290)
btn_disable=Button(v0,text=" Disable",bg="light green",borderwidth=4,
command=disabled).place(x=600,y=1$
btn_enable=Button(v0,text=" Enable ",bg="light green",borderwidth=4,
command=enable).place(x=600,y=210)
btn_copy=Button(v0,text=" Copy ",bg="light green",borderwidth=4,
command=copy).place(x=600,y=250)

# === # === # === # TAB 2 # === # === # === #

destdAdress=StringVar()
gateway=StringVar()

def addRoute():
dad=destdAdress.get()
gw=gateway.get()

if not re.search("^((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0-
4$
mensaje("Debe ingresar una IP destino valida")
elif not re.search("^((([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))\.){3}([1-9]?[0-9]|1[0-9]{2}|2[0$
mensaje("Debe ingresar una Gateway valida")
else:
binstr="#!/bin/bash\n\n"
sshpass="sshpass -p \"uth1234\" ssh -l mantunez "+IP_MIKROTIK
addstr=" 'ip route add dst-address="+dad
 interstr=" gateway="+gw+"'"
cadena=binstr+sshpass+addstr+interstr

os.system("sudo chmod -R 777 add.sh")

pf=open(r"/home/mantunez/addRoute.sh","w")
pf.write(cadena)
pf.close()
time.sleep(0.1)
os.system("sudo /./home/mantunez/addRoute.sh &")

mensaje("Ruta agregada exitosamente!")

cleanRoute()
printRoute()

def removeRoute():
linea= tkSimpleDialog.askinteger("Eliminar Ruta ","Numero de linea", parent=tab2,
minvalue=0,maxval$
if linea is not None:
os.system('sudo sshpass -p "uth1234" ssh -l mantunez '+IP_MIKROTIK+' "ip route remove
'+str(lin$
printRoute()
def cleanRoute():
destdAdress.set("")
gateway.set("")

def printRoute():
os.system('sudo sshpass -p "uth1234" ssh -l mantunez '+IP_MIKROTIK+' "ip route print" >
printRoute.$
valor=subprocess.check_output("cat /home/mantunez/printRoute.txt", shell=True)

textArea=ScrolledText.ScrolledText(tab2, width=80,height=10)
textArea.place(x=10,y=180)
textArea.insert(INSERT,valor)
#Labels
Label(tab2,text=" + Nueva Ruta +" , font=font14).place(x=10,y=10)
Label(tab2,text="Dest address" , font=font10).place(x=10,y=50)
Label(tab2,text="Gateway",font=font10).place(x=10,y=80)
#Inputs
Entry(tab2,textvariable=destdAdress,width=17).place(x=90,y=50)
Entry(tab2,textvariable=gateway,width=17).place(x=90,y=80)
#Buttons
btn=Button(tab2,text="Registrar",command=addRoute).place(x=10,y=110)
btn=Button(tab2,text="Eliminar",command=removeRoute).place(x=100,y=110)

printRoute()
# === # === # === # TAB 3 # === # === # === #
def mkhost():
os.system('sudo sshpass -p "uth1234" ssh -l mantunez 192.168.0.35 "system identity print" >
mkhost.$
valor=subprocess.check_output("cat /home/mantunez/mkhost.txt",shell=True)
textarea=ScrolledText.ScrolledText(tab3,width=80,height=20)
textarea.place(x=30,y=120)
textarea.insert(INSERT,valor)

def mkreboot():
os.system('sudo sshpass -p "uth1234" ssh -l mantunez 192.168.0.35 "system reboot" >
mkreboot.txt')
'''valor=subprocess.check_output("cat /home/mantunez/mkreboot.txt",shell=True)
textarea=ScrolledText.ScrolledText(tab3,width=80,height=20)
textarea.place(x=30,y=120)
textarea.insert(INSERT,valor)'''

def mkshutdown():
os.system('sudo sshpass -p "uth1234" ssh -l mantunez 192.168.0.35 "system shutdown" >
mkshutdown.tx$
'''valor=subprocess.check_output("cat /home/mantunez/mkshutdown.txt",shell=True)
textarea=ScrolledText.ScrolledText(tab3,width=80,height=20)
textarea.place(x=30,y=120)
textarea.insert(INSERT,valor)'''

#Button
btn=Button(tab3,text="MKHost",command=mkhost).place(x=10,y=30)
btn=Button(tab3,text="MKReboot",command=mkreboot).place(x=100,y=30)
btn=Button(tab3,text="MKShutdown",command=mkshutdown).place(x=200,y=30)

v0.mainloop()
DEMOSTRACION A NIVEL FRONT-END
10. En primera instancia en la interfaz web, tendremos la solicitud de para agregar ip a
nuestro mikrotik en este caso se solicita el ip en formato (x.x.x.x/x), seguidamente sobre
que interfaz de red se configuran esos segmentos (En mi escenario tengo disponible el
ether2, ether3, ether4), el tercer parámetro solicitado será el opcional que es el de
comentarios. En el siguiente ejemplo se agregará la siguiente configuración, seguidamente
dándole Click al botón aplicar:

A nivel de nuestro lector de interfaz en la misma ventana podremos apreciar que se

guardó el ip:

También se verifica a nivel de interfaz en el mikrotik que funciono lo mando desde nuestro
winbox

Incluso desde el terminal de otro equipo ya se le puede llegar al ip agregado a nivel de

interfaz ether3 del mikrotik
11. Ahora validaremos el botón de eliminar una interfaz de red basado en el flags que nos de
la lectura del print interfaces:

Al dar Click sobre el botón Delete, se refrescará el cambio en una txt área de la siguiente
manera:

Desde Terminal de Mikrotik:

12. En el siguiente paso deshabilitaremos una interfaz de red, en este caso la que configure en
el ejemplo anterior. Para ello basado en el flags

Al dar Click sobre el botón Disable, aparecerá un X al par del flags 3 indicando dicha
interfaz esta deshabilitada:

Validando a nivel de terminal desde nuestro Mikrotik se vería de la misma manera:

13. Validando funcionalidad del botón Enable, se agregará nuevamente el flags 3.

 Al ejecutar la instrucción, se habilitará nuevamente la interface 3

14. Por el ultimo en cuanto a las funcionalidades de la primera ventana estará el botón de
copiar, a este tendremos que ingresar de referencia el número de ethernet necesario para
copiar, ejemplo:

Al dar sobre Click en el botón copy, pasara lo siguiente:

15. Ahora nos ubicamos sobre el segundo tabs, que hace referencia a la opción de agregar
rutas de red:

En nuestro ejemplo guardaremos la siguiente ruta:

Al dar Click sobre el botón registrar

 Desde el terminal de MK observamos el ruteo se agrego correctamente.

16. El otro escenario de mantenimiento que se pueda hacer desde esta interfaz es el apartado
de eliminar una ruta estática, para el siguiente ejemplo agregare la ruta recién agregada
en este manual;

Al dar Click sobre el botón ok, se actualizara nuestra interfaz indicando la ruta indicada se
eliminó:
 Ejecutando desde el terminal de mikrotik verificamos que en efecto funciono, lo ejecutado
desde Front-End

17. Dentro de las otras funcionalidades agregadas, esta una tercera pestaña que tiene la
función de obtener el nombre de nuestro MK

Los siguientes botones mandan los parámetros de reinicio o apagado del MK desde
front-end.