Escolar Documentos
Profissional Documentos
Cultura Documentos
1
DISEÑO E IMPLEMENTACION DE UN ALGORITMO PARA LA CONFIGURACIÓN DE DOS
TECNOLOGÍAS DE ROUTERS, UTILIZANDO EL SOFTWARE DE ENRUTAMIENTO QUAGGA
DIRECTOR DE PROYECTO
ING. GUSTAVO ADOLFO HIGUERA CASTRO
2
Agradecimientos
Durante el camino que emprendimos en nuestra alma mater, no solo adquirimos conocimiento,
sino que también nos formamos como personas integrales y agradecidas de hacer parte de
nuestra querida Universidad Francisco José de Caldas la cual nos acogió en su seno y que hoy nos
entrega a la sociedad como personas profesionales, capaces de integrarse al desarrollo del país
de una manera productiva.
Agradecemos a Dios, a nuestras familias, a los docentes, compañeros y amigos que de una u otra
manera aportaron a nuestra formación académica y crecimiento personal. Aunque se presentaron
dificultades, tuvimos la sabiduría para poderlas superar y lograr culminar el ciclo profesional.
Por último, agradecemos a nuestro director de tesis, el ingeniero Gustavo A. Higuera Castro, por
su apoyo y acompañamiento en el desarrollo de la presente monografía.
3
HOJA DE ACEPTACIÓN
Observaciones.
_________________________________________________________
_________________________________________________________
_________________________________________________________
_________________________________________________________
_________________________________________________________
_________________________________________________________
_______________________________
Ing. Gustavo Adolfo Higuera M. Sc.
Director del Proyecto
3. RESUMEN ............................................................................................................................ 12
4. ABSTRACT .......................................................................................................................... 13
5. INTRODUCCIÓN ................................................................................................................ 14
6. OBJETIVOS ......................................................................................................................... 15
7. ANTECEDENTES ............................................................................................................... 16
8. JUSTIFICACIÓN ................................................................................................................ 18
5
10.3.3. Enrutamiento estático ........................................................................................ 22
10.12.2. Definición............................................................................................................. 31
6
10.15. PYTHON .................................................................................................................... 34
8.15.2. PyGTK....................................................................................................................... 36
7
12.3. PAQUETES DE SOFTWARE.................................................................................. 48
13.1. DESCRIPCIÓN.......................................................................................................... 72
8
13.2.6. Verificación pruebas............................................................................................. 73
1. ÍNDICE DE ILUSTRACIONES
Ilustración 5. Ejemplo de interfaz Gráfica de Usuario diseñada con el software glade ................. 30
9
Ilustración 9. Consola interactiva python ....................................................................................... 36
Ilustración 16. Router cisco elegido para interactuar con el PC enrutador .................................... 47
Ilustración 18. Modificación del archivo “sysctl.conf” para que el PC actúe como enrutador ..... 51
Ilustración 37. Equipo cilente. Prorama iperf (red quagga – cisco) ............................................... 66
Ilustración 43. Archivo descargado por medio del servidor FTP .................................................. 71
2. ÍNDICE DE TABLAS
Tabla 4. Requerimientos mínimos de las versiones LTS 14.04 y 16.04 de Ubuntu ...................... 48
11
3. RESUMEN
12
4. ABSTRACT
The present grade work consists in the elaboration of a application for desktop, implemented in
the operating system ubuntu, through the programming language Python and the interface
designer Glade. The application operates as a graphical interface so that the user can interact in
a simple and intuitive way with Cisco IOS networking commands and quagga routing software.
Initially we studied the commands available on both platforms, investigated how to use a desktop
computer as a router, started the network topology and subsequently performed connectivity
tests to verify communication between terminals. Next, the interface aspect was designed and
the algorithm was generated to be able to program the network parameters of the two routing
platforms from the same application. The programming of the routing parameters was done
centrally, you have the application running on the pc router and from there the connection to the
cisco router is made through the ssh protocol to ensure the integrity of data traffic.
What is sought with the use of the application is to facilitate learning and assimilation of routing
concepts graphically, reduce scheduling time by running multiple commands simultaneously, not
as the command console in which to enter and exit the configuration repeatedly and finally save
the changes, process that is done from the interface developed from a single window and can be
verified quickly. We also want to encourage the use of free software and interoperability in
networks, the tool developed is scalable in case you want to add more functionality and
improvements.
13
5. INTRODUCCIÓN
Cuando se está aprendiendo a cerca de redes, una vez asimilados los conceptos hay que buscar
herramientas de software para darse una idea de cómo trabajan los dispositivos de networking
de manera conjunta, es allí donde aparecen los simuladores de redes como el “Cisco Packet
Tracer”, la cual es una buena alternativa, ya que permite al estudiante diseñar la topología de la
red y hacer la programación de los dispositivos de networking por medio del CLI (Cisco Command
Line) y/o por medio de una interfaz gráfica integrada en el software. Lo ideal sería que después
de esto se pudieran practicar los conceptos con enrutadores reales, lo que en algunos casos no
es posible, debido a la falta de laboratorios de routing, el alto costo de los equipos y el tiempo
que llevan estas prácticas entre otros motivos.
Mostrar como un computador de escritorio puede ser acoplado fácilmente para operar
como un enrutador (tanto a nivel de software como hardware).
Demostrar como el uso de software libre es útil para aprender redes y como operar de
manera conjunta con enrutadores cisco.
Entregar una aplicación que permita realizar programación de routers en modo gráfico
pero que al mismo tiempo muestre al usuario cómo se programan las órdenes como si
estuviera en la propia consola de comandos.
Ofrecer una alternativa económica y versátil para facilitar el aprendizaje de redes
Una vez realizada la programación de los enrutadores, los usuarios pueden realizar las pruebas
que consideren pertinentes: por ejemplo, implementando un servidor FTP, utilizando
herramientas de análisis de tráfico, configurando los diferentes protocolos de enrutamiento para
así poder compararlos y obtener sus propias conclusiones.
14
6. OBJETIVOS
6.1. General
6.2. Específicos
15
7. ANTECEDENTES
16
El objetivo del proyecto es, previo estudio de las posibilidades de configuración de los routers
Cisco de la serie 2600, el desarrollo de un programa que permita realizar todas las tareas
relacionadas con la configuración de Servicios Diferenciados, además de opciones de
configuración básicas, en dicho equipo. Las herramientas de servicios diferenciados incluirán la
generación de listas de control de acceso, la creación de mapas de clases, adición y modificación
de mapas de políticas y, por último, la asociación de las anteriores políticas a las interfaces.
17
8. JUSTIFICACIÓN
En un entorno cada vez más cambiante, tecnológicamente hablando; la tendencia a las redes
convergentes que se viene dando a nivel mundial es solo una premisa para darse una idea de la
gran cantidad de distribuidores de dispositivos de networking que existen y de su expansión de
productos por el mundo. No obstante, debe tenerse en cuenta que son proveedores
especializados como Cisco Systems o Juniper Networks, lo que conlleva a que sus productos no
sean compatibles entre sí, no fomentan el principio de interoperabilidad.
El objetivo del proyecto es entregar una herramienta ofimática que permita una interacción más
didáctica y menos específica para configurar dos tecnologías de routers, dar una alternativa
práctica para hacer uso de un pc como router y fomentar la interoperabilidad entre dispositivos
de networking.
Con la puesta en marcha del proyecto se espera que las personas que se adentran en el campo
de la administración de redes, cuenten con una herramienta que les ayude a comprender
parámetros de enrutamiento, coexistencia de tecnologías y que además les permita administrar
la red de una manera más sencilla al permitir enviar parámetros de configuración a través de la
misma.
En un mundo cada vez más digital, la masificación de las tecnologías de la información y las
comunicaciones (TIC) es evidente y de vital importancia para mejorar el rendimiento de las
empresas, la comunicación tanto interna como externa en una entidad debe ser rápida, eficiente
y adaptable al cambio. En este sentido los dispositivos de networking juegan un papel importante;
la interacción con los mismos debe ser fluida por parte del administrador de la red, debe estar en
capacidad de realizar modificaciones en la infraestructura sin afectar la calidad de servicio de la
misma. En algunos casos esto conlleva limitaciones y/o dificultades en cuanto a disponibilidad de
equipos de red e integración con otras redes o equipos de diferentes fabricantes, debido a su
incompatibilidad.
18
La asimilación de los diferentes entornos de desarrollo por parte del administrador de red podría
no ser viable para las empresas en términos de tiempo y recursos, no se encuentran alternativas
fácilmente disponibles para suplir cambios o eventualidades en la red sin necesidad de adquirir
equipos nuevos, tampoco implementación de interfaces de programación que no incluyan
redundancia de código.
En ocasiones los routers comerciales son robustos y podrían estar sobre dimensionados
para realizar procedimientos sencillos como un cambio de topología en una red.
Los equipos de networking de los diferentes fabricantes no interactúan entre sí, se deben
buscar alternativas tecnológicas que permitan reducir esta brecha, para así fomentar la
interoperabilidad en redes.
Algunos simuladores de redes como Cisco Packet Tracer permiten la programación de los
dispositivos por medio de interfaz gráfica e interfaz de comandos, esto facilita la
comprensión de la red, deben integrarse herramientas que sigan este principio para
facilitar la administración de la red.
Configurar un router en topología centralizada puede ser una tarea ardua al utilizar
diferentes tecnologías de routers.
En el ambiente empresarial no es común encontrar interacción entre equipos de cómputo
con diferentes sistemas operativos dentro de la misma red, lo que impide aprovechar las
ventajas y/o facilidades de cada uno de ellos.
La variedad de sistemas operativos e interfaces de comandos de los routers pueden ser
difíciles de asimilar en corto tiempo, llevando a una labor menos eficiente al administrador
de la red.
19
10. MARCO TEÓRICO
Una red puede definirse como una estructura en la que hay un orden establecido. De acuerdo
con (Pérez, 2014) puede hacer referencia a la interconexión de computadoras y otros dispositivos
que comparten recursos. Un dato podría definirse como conceptos, cifras e instrucciones que se
tienen aisladas entre sí, sin seguir un patrón u orden específico.
Un protocolo de red se puede definir como una serie de pasos determinados que se deben seguir
para establecer la comunicación entre los diferentes componentes de una red y finalmente llevar
a cabo la transmisión de los datos. Ejemplos de protocolos son expuestos por (Hallberg, 2007,
pág. 92), el protocolo de control de transmisión/ Protocolo Internet (TCP/IP) define un conjunto
de reglas que se utilizan en el envío de datos de un nodo a otro en la red, el Protocolo Simple de
Transferencia de Correo (SMTP) es un conjunto de reglas y estándares que se utilizan para la
transferencia de correo electrónico y archivos adjuntos de un nodo a otro.
Los protocolos de enrutamiento son el conjunto de reglas utilizadas por un router cuando se
comunica con otros routers, con el fin de compartir información de enrutamiento. Dicha
información se usa para construir y mantener las tablas de enrutamiento.
Estos protocolos facilitan el proceso de enrutamiento, el cual consiste en que los routers se
envíen entre sí periódicamente información de las rutas, creando en cada uno de ellos unas
tablas de enrutamiento, para que en el momento que reciban un paquete de protocolo
enrutado contarán con la ruta dónde deben enviarlo. (Mier & Mier, 2008, pág. 21)
20
10.3.1. Protocolos Vector Distancia
Los protocolos de routing de vector distancia envían datos actualizados de rutas periódicas a los
vecinos directamente conectados. Cada vez que se realiza un envío en temporizador se reinicia.
La métrica utilizada por estos protocolos es el “conteo de saltos” o routers encontrados en el
camino.
10.3.1.2. Convergencia
La convergencia ocurre cuando todos los routers del dominio están de acuerdo a las rutas
que se encuentran disponibles.
El tiempo de convergencia es el tiempo que necesita cada router para sincronizar su tabla
de routing después de que se haya producido un cambio en la topología de la red. (Collado,
2009, pág. 85)
21
10.3.2. Protocolos estado de enlace
Este tipo de protocolos generalmente se usan para mantener las tablas de routing con una alta
precisión y libres de bucles. Envían sus actualizaciones de forma incremental y mediante
multicast.
Cuando se tienen tablas de enrutamiento estáticas, hay que introducir la información de dichas
tablas de forma manual, ya que el router no puede adaptarse de manera automática a los cambios
que se puedan presentar en la topología de la red, Sin embargo, este método de enrutamiento
resulta ventajoso en las siguientes situaciones. (González, s.f, pág. 1)
Existe una sola conexión con un solo ISP. En lugar de conocer todas las rutas globales, se
utiliza una única ruta estática.
Un cliente no desea intercambiar información de enrutamiento dinámico.
22
Ilustración 1. Clasificación de los protocolos de enrutamiento
El modelo de interconexión para sistemas abiertos (OSI) define todos los métodos y
protocolos necesarios para conectar una computadora a cualquier otra para formar una
red. El modelo OSI es un modelo conceptual que se utiliza con mucha frecuencia para diseñar
redes y elaborar la ingeniería de las soluciones de red. En general, el modelo OSI conforma
las redes en el mundo real, aunque existen diferencias entre la teoría que los sustenta y la
práctica real en la mayoría de las redes. Aun así, este modelo proporciona una forma
excelente para comprender y visualizar cómo se comunican las computadoras entre sí, y es
un conocimiento indispensable para cualquier persona que trabaje en el campo de la
conectividad de redes. (Hallberg, 2007, págs. 28 - 29)
El modelo OSI está conformado por 7 capas que definen las funciones de los protocolos de
comunicaciones.
23
Ilustración 2. Capas del modelo OSI
10.5. ROUTER
Los enrutadores son dispositivos de interconexión de redes o segmentos de redes que pueden
estar desarrollados tanto en software o en hardware, y cuyo objetivo es definir y establecer el
camino para que los datos lleguen desde su origen a su destino. Los enrutadores funcionan como
puntos intermedios en la red de datos, en donde se toman decisiones respecto a los caminos que
deben seguir los paquetes de información para llegar a su destino.
24
El router tiene varios componentes los cuales son:
CPU: Ejecuta las instrucciones del sistema operativo, como el inicio del sistema, y las
funciones de enrutamiento y conmutación.
RAM: Es la memoria de acceso aleatorio y se usa para guardar las tablas de enrutamiento,
se guarda la caché ARP y de conmutación rápida.
Memoria Flash: Es un tipo de ROM programable. Se usa para almacenar una imagen del
sistema operativo.
NVRAM: La memoria de acceso aleatorio no volátil se usa por lo general para guardar la
configuración de inicio.
Buses: Los buses se usan en la comunicación entre la CPU y las interfaces y ranuras de
expansión.
ROM: Memoria de solo lectura se usa para almacenar de forma permanente el código de
diagnóstico de inicio.
Fuente de alimentación: Brinda alimentación de energía a los componentes internos.
Interfaces: Son conexiones de los routers hacia el exterior y pueden ser de tres tipos LAN,
WAN y de Consola AUX.
Es posible usar un PC común como enrutador, el rendimiento de la red puede estar sujeto al
hardware propio del computador, pero es una opción más que suficiente para redes locales o
redes con un tráfico limitado. Para utilizar un PC como enrutador se debe disponer de dos tarjetas
de red y activar el soporte de enrutamiento del kernel. Para ampliar las capacidades del enrutador
y que soporte diferentes protocolos de red, se pueden usar programas como (Quagga, Vyatta,
XORP, Zebra, etc). Con estos paquetes de software se pueden implementar routers y firewalls
(propios de capa 3) con una buena eficiencia, incluyendo la posibilidad de configurarlos vía web.
(Vázquez, 2009, pág. 46)
25
Ilustración 4. Componentes internos de una computadora
Como se puede observar en la Ilustración 4, los componentes internos de una computadora son
básicamente parecidos a los de un router, solo que este dispositivo realiza la función principal de
interconectar redes
La tabla de enrutamiento es un archivo que almacena direcciones de red y las interfaces que
alcanzan a dicha red. Indica si está conectada directamente conectada o que no está
directamente conectada.
El router tiene la capacidad de determinar la mejor ruta para un paquete, pero esto va a depender
del ancho de banda, de la saturación de la red, así como de la métrica.
26
10.7. LINUX
Linux es un sistema operativo de distribución libre desarrollado inicialmente por Linus Torvalds
en 1991 en la universidad de Helsinki (Finlandia). Una comunidad de programadores expertos en
UNIX, han ayudado en el desarrollo, distribución y depuración de este sistema operativo. El
núcleo (Kernel) de Linux no contiene código desarrollado por AT&T ni por ninguna otra fuente
propietaria. La mayoría de software disponible en Linux ha sido desarrollado por el proyecto GNU
de la Free Software Fundation (FSF) de Cambridge (Massachusetts). Sin embargo, es toda una
comunidad de programadores la que ha contribuido al desarrollo de aplicaciones para este
sistema operativo. (Cuenca, 2012)
La combinación (o suma) del software GNU y kernel Linux, es lo que ha traído los actuales
sistemas GNU/Linux. Actualmente los movimientos Open Source, desde diferentes
organizaciones (como FSF) y empresas como las que generan diferentes distribuciones Linux
(Red Hat, Mandrake, SuSe…), pasando por grandes empresas como HP, IBM o Sun que
proporcionan apoyo, han dado un empujón muy grande a los sistemas GNU/Linux hasta
situarlos a nivel de poder competir, y superar, muchas de las soluciones propietarias
existentes. (Jorba & Suppi, 2004, pág. 13)
10.8. UBUNTU
Ubuntu es una distribución GNU/Linux basada en Debían GNU/Linux que proporciona un sistema
operativo actualizado y estable para el usuario medio, con un fuerte enfoque en la facilidad de
uso e instalación del sistema. Su eslogan es Linux for Human Beings (Linux para seres humanos) y
su nombre proviene de la ideología sudafricana Ubuntu («humanidad hacia otros»)
Cada seis meses se publica una nueva versión de Ubuntu la cual recibe soporte por parte de
Canonical, durante dieciocho meses, por medio de actualizaciones de seguridad, parches para
bugs críticos y actualizaciones menores de programas. Las versiones LTS (Long TermSupport),
que se liberan cada dos años, reciben soporte durante tres años en los sistemas de escritorio
y cinco para la edición orientada a servidores. (Guias_Ubuntu, 2011)
27
10.9. ZEBRA – QUAGGA
Quagga utiliza una arquitectura de software avanzada para proporcionar una gran calidad, con
un motor multi servidor de encaminamiento. Un sistema con quagga instalado actúa como un
router dedicado. Con Quagga una máquina intercambia información de routing de forma que
la información correcta esté en el lugar correcto. Quagga permite la configuración dinámica y
es posible ver la información de la tabla de routing desde la interfaz de terminal de quagga.
(Ishiguro, 2017)
El demonio ‘ripd’ maneja el protocolo RIP, el demonio ‘ospfd’ soporta OSPF versión 2. El
demonio ‘bgpd’ soporta el protocolo BGP-4. Para cambiar la tabla de enrutamiento del
núcleo y para la redistribución de rutas entre diferentes protocolos de enrutamiento, hay
28
un demonio ‘zebra’ del gestor de tablas de enrutamiento del kernel. Es fácil agregar un
nuevo demonio de protocolo de enrutamiento a todo el sistema de enrutamiento sin afectar
a ningún otro software. Sólo tiene que ejecutar el demonio de protocolo asociado con los
protocolos de enrutamiento en uso. Así, el usuario puede ejecutar un demonio específico y
enviar informes de enrutamiento a una consola de enrutamiento central. (Jakma, 2004)
10.10. GTK+
10.11. GLADE
10.12.1. Introducción
A finales de los años cincuenta y comienzos de los sesenta se desarrollaron los primeros
lenguajes de alto nivel con su propio vocabulario más o menos limitado, su gramática más
o menos estricta y su semántica, que se asimilan relativamente al lenguaje humano. Estos
lenguajes se denominan de “alto nivel” porque para poder ser utilizados deben pasarse por
un traductor que los convierta a un lenguaje de nivel inferior (código máquina o
ensamblador). A este proceso se le llama “compilación” o “interpretación” y lo realiza,
curiosamente, otro programa. El código escrito por el programador es lo que se conoce
como “código fuente” y el código traducido es lo que se conoce como “código binario”.
(Guimi, 2008)
10.12.2. Definición
Un algoritmo es un conjunto de líneas con una sintaxis específica que actúan de manera conjunta
para dar solución a un problema. Para desarrollar algoritmos eficientes se debe llevar procesos
de forma sistemática y rigurosa.
31
reputación por el enunciado de las reglas paso a paso para sumar, restar, multiplicar y dividir
números decimales; la traducción al latín del apellido en la palabra algorismus derivó
posteriormente en algoritmo. (Joyanes & Zahonero, 1999)
1. Elaboración del algoritmo, que describe la secuencia ordenada de pasos que conducen a la
solución de un problema dado. (Análisis del problema y desarrollo del algoritmo.)
2. Expresar el algoritmo como un programa en un lenguaje de programación adecuado. (Fase de
codificación.)
3. Ejecución y validación del programa por la computadora.
32
demuestran eficientes. El programador sólo tiene que crear esta lista de instrucciones en un
lenguaje de programación, compilar en la computadora y ésta, a su vez, ejecuta estas
instrucciones. (Joyanes & Zahonero, 1999)
Los atributos o características de los objetos son, por ejemplo: en las personas, su edad, su
profesión, su domicilio, etc.; en un auto, la potencia, el número de matrícula, el precio, número
de puertas, etc; en una casa, la superficie, el precio, el año de construcción, la dirección, etc. En
realidad, los atributos del mundo real tienen su equivalente en los datos de un programa; tienen
un valor específico, tal como 200 metros cuadrados, 20.000 dólares, cinco puertas, etc.
El comportamiento es una acción que ejecutan los objetos del mundo real como respuesta a un
determinado estímulo. Si usted pisa los frenos en un auto, el coche (carro) se detiene; si acelera,
el auto aumenta su velocidad, etc. El comportamiento, en esencia, es como una función: se llama
a una función para hacer algo (visualizar la nómina de los empleados de una empresa).
Por estas razones, ni los datos ni las funciones, por sí mismas, modelan los objetos del mundo real
de un modo eficiente.
33
La programación estructurada mejora la claridad, fiabilidad y facilidad de mantenimiento de los
programas; sin embargo, para programas grandes o a gran escala, presentan retos de difícil
solución. (Joyanes & Zahonero, 1999)
10.15. PYTHON
Python fue creado a principios de los 90 por Guido van Rossum en el Stichting Mathematisch
Centrum en los Países Bajos como sucesor de un lenguaje llamado ABC y la necesidad del
autor por un analizador de sintaxis sencillo y fácil de aprender. Guido sigue siendo el
principal autor de Python, aunque incluye multitud de contribuciones de otros.
Después de crear el intérprete se comenzaron a agregar partes de código similares a las de
un compilador o máquina virtual lo que permitió en un momento crear un intérprete y lograr
programas en ejecución bajo Python.
Python, a pesar de iniciar como el proyecto de una sola persona, ha llevado un diseño y
lineamientos que lo han llevado a lo que hoy es. Entre los planes originales de diseño se
encontraban:
Similitud con la Shell de UNIX, lo que permite un ambiente amigable, muy similar a la
terminal de UNIX, pero no un remplazo de la misma.
Arquitectura Extensible. Es decir, una arquitectura en la que se puedan agregar cosas
nuevas, no todo es perfecto en un principio y Python debería ser capaz de cambiar de
acuerdo a las necesidades de los usuarios. Guido van Rossum describe como doloroso su
trabajo con otros lenguajes como ABC al tratar de implementar nuevos tipos de datos.
Una herramienta en lugar de muchas. Python debería encajar bien en cualquier ambiente,
ser de uso múltiple, y por lo tanto ser un buen remplazo para muchas herramientas (y otros
lenguajes de programación). El alcanzar este objetivo requiere que Python sea altamente
portable.
Se debe poder agregar funcionalidad de manera separada. Es decir, permitir a otros la
inclusión de características adicionales a Python sin la necesidad de compilar el intérprete
de nuevo.
Factible, como para ser el proyecto de una sola persona. Al ser extensible permitió a Guido
concentrarse en las tareas más apremiantes mientras delegaba labores menos importantes
a otros.
Principalmente, servir, para poder hacer el trabajo de cada día. (Islas, 2006, pág. 8)
34
Dentro de los lenguajes informáticos, Python pertenece al grupo de los lenguajes de
programación y puede ser clasificado como un lenguaje interpretado, de alto nivel,
multiplataforma, de tipado dinámico y multiparadigma. A diferencia de la mayoría de los
lenguajes de programación, Python provee reglas de estilos, a fin de poder escribir código fuente
más legible y de manera estandarizada. Estas reglas de estilo, son definidas a través de la Python
Enhacement Proposal N° 8 (PEP8). (Islas, 2006)
35
La consola interactiva de Python permite ejecutar código sobre la marcha. Es decir, se escribe una
determinada operación y al presionar Enter se ejecuta y se muestra el resultado. Además de ser
perfecta para utilizarse como una calculadora, también resulta así para comprobar la eficacia de
pequeños códigos, la correcta instalación de un módulo, entre otras. Se accede a ella
escribiendo python en la terminal o línea de comandos. En Windows, también es posible
ejecutarla desde el acceso directo creado durante la instalación, generalmente llamado “Python
(command line)” (Recursos_Python, 2014)
8.15.2. PyGTK
PyGTK permite crear fácilmente programas con una interfaz gráfica de usuario utilizando el
lenguaje de programación Python. La biblioteca subyacente de GTK + proporciona todo tipo de
elementos visuales y utilidades para él y, si es necesario, puede desarrollar aplicaciones
completas para el escritorio de GNOME.
Pexpect hace de python una mejor herramienta para controlar otras aplicaciones. Permite que el
script genere una aplicación secundaria y la controle como si un humano estuviera escribiendo
comandos.
Pexpect se puede utilizar para automatizar aplicaciones interactivas como ssh, ftp, passwd, telnet,
etc. Se puede usar para automatizar scripts de instalación para duplicar instalaciones de paquetes
de software en diferentes servidores. Puede usarse para pruebas de software automatizadas.
Funciona en cualquier plataforma que soporte el módulo pty de Python estándar. La interfaz de
Pexpect fue diseñada para ser fácil de usar. (Spurrier, 2013)
Interfaz gráfica de usuario (En inglés Graphic User Interface, también conocido con su
acrónimo GUI) es un método para facilitar la interacción del usuario con el ordenador o la
computadora a través de la utilización de un conjunto de imágenes y objetos pictóricos
(iconos, ventanas…) además de texto. Surge como evolución de la línea de comandos de los
primeros sistemas operativos y es pieza fundamental en un entorno gráfico. (González Sojo,
s.f.)
Al desarrollar interfaces gráficas se deben tener en cuenta algunos aspectos para facilitar su
entendimiento y usabilidad
Autonomía: El desarrollo gráfico debe ser lo suficientemente claro para que el usuario ubique e
ingrese los datos de una manera intuitiva.
37
Legibilidad: La GUI debe tener elementos guía para que el usuario sepa cómo debe ingresar los
datos, en la medida de posible algún sistema que le permita comprobar los parámetros que está
ingresando.
El protocolo SSH define un protocolo propio para la transmisión segura de los datos, el protocolo
SSH. Este protocolo se sitúa directamente por debajo de la capa de transporte, (concretamente
del transporte TCP). Aparte de establecer conexiones seguras, el protocolo SSH también ofrece
otras funcionalidades como, por ejemplo, la redirección de puertos TCP o la comunicación entre
clientes y servidores de ventanas X, a través de una conexión SSH.
Confidencialidad: SSH sirve para comunicar datos, que habitualmente son la entrada de una
aplicación remota y la salida que genera, o bien la información que se transmite por un
puerto redirigido, y la confidencialidad de estos datos se garantiza mediante el cifrado. Un
servicio adicional que proporciona SSH es la confidencialidad de la identidad del usuario. En
SSH la autenticación del usuario se realiza cuando los paquetes ya se mandan cifrados. Por
otro lado, SSH2 también permite ocultar ciertas características del tráfico como, por
ejemplo, la longitud real de los paquetes.
38
También existe la posibilidad de utilizar algoritmos MAC distintos en cada sentido de la
comunicación.
Una ACL es una lista que contiene permisos y denegaciones que pueden aplicarse a una red para
determinar si un paquete puede acceder o no a ella.
Una ACL es una serie de comandos del IOS que controlan si un router reenvía o descarta paquetes
según la información que se encuentra en el encabezado del paquete. Las ACL son una de las
características del software IOS de Cisco más utilizadas. (Cisco, Principios de Routing Switching
(CCNA 2), 2014)
39
bloqueen el tráfico de video. Esto reduciría considerablemente la carga de la red y
aumentaría su rendimiento.
Proporcionan control del flujo de tráfico. Las ACL pueden restringir la entrega de
actualizaciones de routing. Si no se requieren actualizaciones debido a las condiciones de la
red, se preserva ancho de banda.
Proporcionan un nivel básico de seguridad para el acceso a la red. Las ACL pueden permitir
que un host acceda a una parte de la red y evitar que otro host acceda a la misma área. Por
ejemplo, se puede restringir el acceso a la red de Recursos Humanos a los usuarios
autorizados.
Filtran el tráfico según el tipo de tráfico. Por ejemplo, una ACL puede permitir el tráfico de
correo electrónico, pero bloquear todo el tráfico de Telnet.
Filtran a los hosts para permitirles o denegarles el acceso a los servicios de red. Las ACL
pueden permitirles o denegarles a los usuarios el acceso a determinados tipos de archivos,
como FTP o HTTP. (Cisco, Principios de Routing Switching (CCNA 2), 2014)
40
10.18.2. Tipos de ACL
ACL Estándar: Estos tipos de ACL permiten o deniegan el acceso de acuerdo con la totalidad del
protocolo, como IP. De esta forma, cuando un dispositivo host es denegado por una ACL estándar,
se deniegan todos los servicios provenientes de ese host. Este tipo de ACL sirve para permitir el
acceso de todos los servicios de un usuario específico, o LAN, a través de un router y, a la vez,
denegar el acceso de otras direcciones IP. (Cisco, www.cisco.com, s.f.)
ACL Extendida: Las ACL extendidas filtran no sólo según la dirección IP de origen, sino también
según la dirección IP de destino, el protocolo y los números de puertos. Las ACL extendidas se
utilizan más que las ACL estándar porque son más específicas y ofrecen un mayor control. El rango
de números de las ACL extendidas va de 100 a 199 y de 2000 a 2699. (Cisco, www.cisco.com, s.f.)
Este tipo de máscara es un registro de 32 dígitos binarios que, aplicado a una dirección IPv4,
permite establecer la cantidad de bits son requeridos para ejecutar una determinada acción y
cuáles no deben ser considerados. Las máscaras wildcard utilizan las siguientes reglas para
establecer la coincidencia entre los unos y ceros binarios:
41
Bit 1 de máscara wildcard: se omite el valor del bit correspondiente en la dirección
A las máscaras wildcard a menudo se las denomina “máscaras inversas”. La razón es que, a
diferencia de una máscara de subred en la que el 1 binario equivale a una coincidencia y el
0 binario no es una coincidencia, en las máscaras wildcard es al revés. Uso de una máscara
wildcard En la tabla 2, se muestran los resultados de la aplicación de una máscara wildcard
0.0.255.255 a una dirección IPv4 de 32 bits. Recuerde que un 0 binario indica un valor con
coincidencia. (Cisco, Principios de Routing Switching (CCNA 2), 2014)
42
10.19. DHCP
Cuando un dispositivo se conecta a una red, necesita una IP única. Los administradores de red
asignan direcciones IP estáticas a los routers, a los servidores, a las impresoras y a otros
dispositivos de red cuyas ubicaciones (físicas y lógicas) probablemente no cambien. Por lo tanto,
las direcciones que se les asignan se deben mantener constantes. Además, las direcciones
estáticas habilitan a los administradores para que administren estos dispositivos en forma
remota. (Cisco, Principios de Routing Switching (CCNA 2), 2014)
Las direcciones IPV4 que se usan en Internet deben registrarse en un registro regional de Internet
(RIR). Las organizaciones pueden arrendar direcciones públicas de un SP (service Provider), pero
solo el titular registrado de una dirección pública de Internet puede asignar esa dirección a un
dispositivo de red.
43
10.20.1. Tipos de NAT
44
11. METODOLOGÍA
45
12. DESARROLLO DE LA PROPUESTA
ENL832-TX+
46
CISCO 1941 Series
Una vez se tiene el ordenador con el sistema operativo instalado se debe actualizar para obtener
los drivers y controladores más recientes, actualizar repositorios y evitar conflictos con la
instalación de paquetes posteriores. Para la instalación de paquetes desde la terminal se debe
acceder en modo root. Se realiza con los siguientes comandos:
apt-get update
apt-get upgrade
También es necesario instalar el editor de texto vim, ya que con él se van a realizar scripts para
interactuar con los paquetes de software
48
12.3.1. Configuración de Quagga
En Linux, cuando se instala un paquete se agrupa en carpetas con fines similares (no queda
instalado todo el programa en una sola carpeta, como pasa en 49imple49), por tal motivo para
configurar quagga se tienen que copiar los archivos de configuración a la carpeta “etc” que es el
directorio correcto para guardar los archivos de configuración de los programas instalados, se
hace con los siguientes comandos:
cd /usr/share/doc/quagga/examples/
cp * /etc/quagga/
cd /etc/quagga/
cp zebra.conf.sample zebra.conf
cp ripd.conf.sample ripd.conf
Se configuran los demonios (archivos pertenecientes a los protocolos de enrutamiento), para que
se active zebra (demonio de administrador de protocolos) y el protocolo de routing que se vaya
a usar, en este caso rip.
En la ruta anterior se abre el archivo llamado “daemons” con el editor de texto “vim”
vim daemons
/etc/init.d/quagga restart
50
12.4. IP FORWARDING
Desde la terminal y en modo root se dirige a la siguiente ruta y se abre el archivo “sysctl.conf”
con un editor de texto, en este caso “vim”.
Vim /etc/sysctl.conf
Una vez abierto el archivo Se le quita el # a la línea
#net.ipv4.ip_forward=1
Ilustración 18. Modificación del archivo “sysctl.conf” para que el PC actúe como enrutador
Recuérdese que el PC tiene dos tarjetas de red instaladas, Ubuntu asigna como nombres para las
tarjetas de red (ETH0, ETH1, etc). En este caso la tarjeta auxiliar es la ETH0 y la que está integrada
a la placa base ETH1. La que se va usar de interfaz al router Cisco 1941 es la ETH0, por tal motivo
debe configurarse (asignarle IP, máscara y Gateway), esto se realiza por medio de los siguientes
comandos:
Ifconfig eth0 192.168.1.3 netmask 255.255.255.0
route add default gw 192.168.1.1 eth0
51
12.6. INSTALACIÓN DE GLADE Y GTK+
El diseñador de interfaces Glade y las librerías GTK+ actúan en conjunto, se debe asegurar que
queden instaladas y configuradas correctamente para poder diseñar la interfaz.
Secure Shell (SSH) es un protocolo que proporciona una conexión de acceso remoto segura para
dispositivos de red. La comunicación entre el cliente y el servidor está cifrada.
Para que la interfaz pueda acceder al router cisco, este debe tener configurada una sesión ssh, se
realiza de la siguiente manera:
router(config)#hostname cisco1941
(Es necesario configurar el nombre del Router sino no dejar configurar SSH)
cisco1941(config)#line vty 0 4
(Línea donde se aplicara el SSH)
cisco1941(config-line)#transport input ssh
(Activa el SSH en la Line VTY)
cisco1941(config-line)#login local
(Para que se haga uso del usuario)
53
12.9. DISEÑO INTERFAZ
La ventana de inicio de la interfaz (Ilustración 29), se diseñó de forma intuitiva y explicativa para
usuarios finales con un conocimiento muy básico acerca de la configuración de equipos
intermedios de red. Al ejecutar el programa inicialmente nos pide que elijamos el router a
configurar, si elegimos el router “QUAGGA” se solicita el usuario “admin” y la contraseña inicial
(Ilustración 30) configurada en el router embebido quagga, predeterminada “zebra”, de esta
manera se accede a la configuración principal.
54
Si no se colocan los datos de acceso correctos la interfaz no nos deja continuar a la siguiente
ventana, mostrando el siguiente mensaje (Ilustración 22):
Una vez ingresadas las credenciales correctas, entramos a la configuración principal (Ilustración
32), en la pestaña inicio si presionamos el botón “Consultar” en la zona (1) se muestran los
parámetros que se encuentran programados en el router, cada vez que se guarde una
configuración se puede verificar en esta sección para comprobar que quedó guardada
correctamente.
Adicional se da la opción de activar características para realizar una configuración más completa,
si se va a trabajar con Ipv6, el enrutamiento de paquetes con este direccionamiento no viene
activo de forma predeterminada por lo que se debe activar. Para configurar la parte fundamental
del router como lo es el enrutamiento que puede ser estático y dinámico, para este último se
tienen 4 protocolos (RIPv1, RIPv2, EIGRP, OSPF).
56
Para configurar los protocolos de routing tenga en cuenta las direcciones que asignó a las
interfaces, en el caso del protocolo RIP solo será necesario introducir la dirección IP de la interfaz,
su máscara de subred y la versión del protocolo, como se muestra en la Ilustración 25.
Para configurar el protocolo OSPF (Ilustración 26) se ingresa el parámetro router ID (este
parámetro identifica el dispositivo que origina o procesa la información del protocolo), luego se
ingresa la red y la máscara de subred en la que se quiere habilitar el protocolo y finalmente el
valor de área que integra el protocolo OSPF.
Para la configuración del enrutamiento estático (Ilustración 27) se debe tener en cuenta la
topología y el direccionamiento lógico, el primer parámetro que se nos solicita es la “Red de
destino”, esta hace referencia a la dirección de red destino a la cual queremos comunicarnos, la
“Máscara de red”, parámetro asociado a la red de destino y por último “Dirección siguiente salto”,
esta es la dirección IP del router directamente conectado por el cual queremos enrutar los
paquetes.
57
Ilustración 27. Configuración enrutamiento estático. Router Quagga
Para programar un ACL estándar (Ilustración 28) basta con asignarle un número y colocar la
dirección de red a la que queremos permitir o denegar el tráfico, la máscara wildcard para
identificar o ignorar los bits correspondientes a la dirección IP
En el caso de la ACL extendida, al igual que en la ACL estándar se asocia un número para poderla
identificar, (se selecciona el botón “Permitir” o “Denegar” según corresponda), por ejemplo, en
la Ilustración 29 se selecciona permitir el tráfico desde la red 192.168.0.0 a los hosts que se
encuentren en la red 209.32.16.0.
58
Ilustración 29. Configuración ACL extendida. Router Quagga
En la pestaña conectividad se tiene de manera intuitiva la herramienta Ping y Tracert para probar
si las configuraciones realizadas anteriormente se realizaron satisfactoriamente.
Para la configuración del router como servidor DHCP se requiere asignar tres parámetros básicos
para la asignación de direcciones IP de forma dinámica (Ilustración 31), reservar un rango de
direcciones las que no se tendrán dentro del pool disponibles para ser asignadas, se debe
determinar el rango de direcciones que estarán dentro del pool disponible, y luego asignar la
interface designada para la recepción de peticiones de solicitud para la asignación de parámetros
DCHP.
59
Ilustración 31. Parámetros DHCP
Una vez terminada la configuración en el router Quagga, se puede cerrar la ventana y volver a la
ventana de inicio (Ilustración 20), allí al presionar en el botón referente a CISCO se obtiene la
ventana de acceso a esta plataforma (recuerde que el router cisco debe tener configurada una
sesión SSH para poder acceder y configurarlo), una vez colocadas las credenciales correctas,
accedemos a la configuración, las aplicaciones a configurar son las mismas vistas en la
configuración Quagga, la diferencia más notable es el formato de las máscaras que en quagga es
con formato /24 y en cisco 255.255.255.0.
Para la creación de ACL’s se debe tener en cuenta el tipo de ACL que se creara, la interfaz a la que
se realizara la asignación y cuál será el sentido del flujo de paquetes al que se le realizara el
filtrado.
60
Para una ACL estándar los parámetros que se deben asignar son la dirección de red de origen del
tráfico que se va a filtrar, definiendo la wildcard que permitirá definir que bits de la dirección IP
que deben coincidir para permitir o denegar según se defina – sin olvidar el deny any implícito al
final de la ACL- el tráfico en ese router.
En las ACL’s Extendidas son más los parámetros que se deben tener en cuenta ya que este tipo
de ACL’s filtran de acuerdo a la dirección de origen, de destino, a los protocolos capa 4 –Modelo
OSI- o al puerto de origen y destino, estos parámetros son solicitados en una ventana emergente
(Ilustración 36) cuando es seleccionada la opción de ACL extendida en la interfaz.
61
Para configurar un router con el protocolo NAT, se debe tener claro el pool de direcciones públicas
asignadas y privadas dentro de nuestra red que van a ser objeto para la traducción, y la interfaz
por el que va a ingresar el tráfico y la de salida hacia el ISP y así poder realizar la salida a internet
o a una red externa por medio de una dirección pública. Los parámetros mínimos de configuración
que se requieren para habilitar NAT se muestran en la Ilustración 35.
62
13.1. ADMINISTRACION DE LA RED
Según el concepto de administración de la red el cual sugiere que los pasos para asignar
direcciones IP, mantener tabla de enrutamiento, aplicar los protocolos necesarios para generar
conectividad entre dispositivos terminales, además de configurar y mantener la disponibilidad,
integridad y confiabilidad de los servicios de red, para lo que se aplican las configuraciones en los
dispositivos de red de acuerdo a lo establecido.
63
Ilustración 38. Ejemplo implementación de comandos
64
14. RESULTADOS
65
Luego de implementar la topología de red (Ilustración 38), mediante protocolo ICMP, enviando
ping desde la interfaz hacia los equipos terminales, se puede verificar la conectividad de la red y
la correcta programación de los equipos intermedios, se procede a verificar características de la
red por medio del programa analizador de redes “iperf3”, proporcionando información del
rendimiento de la red, se realizaron las siguientes pruebas:
VALORES RECOMENDADOS:
El Jitter entre el punto inicial y final de la comunicación debiera ser inferior a 100 ms. Si el valor
es menor a 100 ms el Jitter puede ser compensado de manera apropiada. En caso contrario
debiera ser minimizado. (VoipForo, s.f.)
Haciendo una comparación entre la transmisión hecha por la red cableada y la inalámbrica se
evidencia un aumento considerable del Jitter (de 0,132ms a 4,607 ms), se confirma disminución
en el tiempo de llegada de los datagramas.
67
Ilustración 43. Equipo cliente transmitiendo a máxima capacidad
Mediante el sniffer WireShark se realiza la captura de paquetes del flujo generado por el iperf3
usando el protocolo de capa TCP donde se observan los campos, el tamaño y la longitud, del
paquete, evidenciando el tráfico generado y valores asignados a los campos según los valores
asignados por iperf3 al datagrama.
68
Ilustración 45. Estadísticas protocolo Netflow
Después de ingresar los comandos para la captura de tráfico mediante el protocolo NetFlow
se puede obtener estadísticas de acuerdo a la información presentada como lo son: los
protocolos usados de la capa de transporte y aplicación, se puede observar la cantidad de
paquetes por flujo y analizarlos por si se presentaran retardos en la transmisión o pérdida de
estos.
70
Ilustración 47. Lista de archivos PC servidor
El archivo de 2.2 Gb tardo en descargarse 2:56 segundos a una velocidad de 10.9 MB/s. La
descarga del archivo fue constante sin retrasos. Siendo el resultado muy similar al entregado
por el programa de análisis de tráfico iperf.
71
15. USO DE LA PLATAFORMA
15.1. DESCRIPCIÓN
Se describe el uso e interacción del usuario directo con la interfaz gráfica (referenciado de forma
de caso de uso para facilidad de comprensión) que le facilitara realizar la programación de dos
tecnologías de router’s, incluyendo módulos intuitivos de gestión de comandos, de manera
secuencial hasta llegar a la configuración inicial recomendada por el fabricante para realizar
interconexión de funcional entre dispositivos intermedios y finales de red.
Se debe realizar por parte del actor que va a hacer uso la ejecución de la interfaz por medio de
unos comandos en la terminal de Linux.
El sistema emerge una ventana en la cual se debe ingresar el usuario y password que debe
coincidir con los configurados en los router’s, para ingresar a la ventana de inicio, inicialmente no
se debe restringir el ingreso ya que no están configurados los router’s.
El ingreso inicial conecta a los router’s de manera de usuario básico, para ingresar al modo de
usuario privilegiado en el router quagga, se selecciona la opción “Quagga”, luego se despliega una
ventana que solicita la clave de ingreso, para el cisco se da click en ssh y se configuran los
parámetros y se obtiene acceso al CLI.
Para realizar una revisión en los router’s la configuración en ejecución es necesario emitir el
comando show running, con el resultado de este se podrá obtener información como interfaces
y los estados en que se encuentran, usuarios, etc.
72
15.2.5. Configuración de parámetros
Ya con la información necesaria y los permisos concedidos, se puede iniciar con la configuración,
ingresando los parámetros solicitados cumpliendo con los pasos y secuencia de forma correcta.
Al finalizar se debe dar click en enviar, finalizando la etapa de configuración.
Para la finalización del proceso se diseñó la etapa final basándose en el protocolo de control ICMP,
se ejecuta comandos para la prueba de conectividad y traza de rutas las cuales como resultado
mostraran el funcionamiento de los equipos.
Se puede configurar lo que estrictamente necesario, lo que significa que podría presentarse el
caso de no necesitar todos los parámetros presentados en la interfaz, lo que no presentara error
al enviar y terminara el proceso.
73
15.4. DIAGRAMA DEL CASO DE USO
74
16. DIAGRAMA DE FLUJO
El diagrama de flujo representa el algoritmo del código fuente de la plataforma cuando inicia su
ejecución, es la forma secuencial en que trabaja el algoritmo esperando las “señales” generadas
por los eventos ocurridos desde la interfaz, ejecutando el método asignado mediante el
namespaces relacionado en la clase inicial del programa.
75
Ilustración 50. Diagrama de flujo
76
17. CONCLUSIONES
Debido a la variedad de distribuciones Linux puede no ser tan intuitivo y viable para un
usuario promedio utilizar programas de routing en software libre, sin embargo, con la
implementación de la interfaz gráfica se logra de una manera amigable que los usuarios
administren su red sin necesidad de adentrarse en comandos propios del sistema
operativo y/o de la configuración del paquete de enrutamiento.
Añadiendo una tarjeta de red a una CPU y usando un software de enrutamiento se obtiene
un mejoramiento en las capacidades de la máquina, ya que aparte de ser usada para
tareas de oficina, simultáneamente puede usarse como un elemento eficiente de
networking, reduciendo costes y espacio, se mantiene la productividad con menos
hardware.
El uso del sistema operativo Ubuntu como base de la interfaz ofrece un funcionamiento
estable al ser soportado por la empresa canonical, adicionalmente es de destacar la
facilidad que provee el software libre para interactuar directamente sobre la terminal de
comandos y así poder generar programación y comunicación con dispositivos externos.
La eficiencia medible mediante el tiempo de programación de los equipos se reduce
mediante la eliminación de redundancia cíclica en los procedimientos para la inserción
código, cuando el programador debe ingresar continuamente a los diferentes modos de
usuario que existen en los IOS de los dispositivos de manera tradicional, procesos que se
automatizan en la interfaz.
Integrando software como cisco IOS y quagga se fomenta la interoperabilidad en redes y
se muestra al usuario final una herramienta que le permite interactuar con enrutadores
software y hardware conjuntamente, permitiendo de esta manera comparar, analizar y
extrapolar aspectos positivos y negativos de cada uno.
La puesta en marcha de la interfaz gráfica muestra al usuario lineamientos de
programación de redes de una manera organizada para facilitar la asimilación de los
mismos y así contribuir a un aprendizaje más dinámico si se usa en el entorno educativo
77
18. BIBLIOGRAFÍA
http://www.colombiavirtualizada.com/2013/09/24/protocolo-netflow-de-cisco/
content/uploads/2010/06/Seccion-3.pdf
http://blog.capacityacademy.com/2014/10/22/quagga-implementacion-de-enrutamiento-
dinamico-en-linux/
https://www.cisco.com/c/es_mx/support/docs/security/ios-firewall/23602-
confaccesslists.html
http://www.investigacion.frc.utn.edu.ar/labsis/Publicaciones/QueEsLinux/QueEsLinux.ht
ml
http://www.pygtk.org/pygtk2tutorial-es/index.html
conversion-de-direcciones-de-red-habilitacion-de-puertos-y
78
GNOME_Developer. (2005 - 2014). Manual del diseñador de interfaces de ususario Glade.
GNOME_Developer. (2005 - 2014). Part I GTK+ Overview. Obtenido de The GNOME Project:
https://developer.gnome.org/gtk3/3.22/gtk.html
http://bibing.us.es/proyectos/abreproy/11300/fichero/PROYECTO%252FCapitulo3.pdf
http://www.ieslosviveros.es/alumnos/asig8/carpeta812/PROTOCOLOS_DE_ENRUTAM
IENTO.pdf
ubuntu.com/index.php/Ubuntu
Lenguajes_de_programacion.pdf
Herrera, J., García, J., & Parramón, X. (2014). Aspectos avazados de seguridad en redes.
Hertzog, R., & Mas, R. (2012 - 2015). The Debian Administrator's Handbook. Free Software
Foundation.
Ishiguro, K. (Marzo de 2017). Savannah. Obtenido de A routing software package for TCP/IP
networks: http://www.nongnu.org/quagga/docs/quagga.pdf
Islas, M. (2006). Desarrollo de alicaciones con Python, PyGTK y Glade. Instituto de Ciencias
79
https://radiosyculturalibre.com.ar/biblioteca/PROGRAMACION/Python/Desarrollo%20d
e%20aplicaciones%20con%20Python%20PyGTK%20y%20Glade.pdf
http://www.fis.agh.edu.pl/wfitj/complab/doc/Quagga/www.quagga.net/docs/docs-
info.html#SEC126
Jorba, J., & Suppi, R. (2004). Administración Avanzada de GNU/Linux. Cataluña: Eureca Media.
Obtenido de http://www.utic.edu.py/citil/images/Manuales/Admin_GNULinux.pdf
Mier, E., & Mier, G. (2008). Protocolos de Enrutamiento. RIP, OSPF y EIGRP. Cartagena.
Obtenido de http://biblioteca.unitecnologica.edu.co/notas/tesis/0045016.pdf
http://recursospython.com/guias-y-manuales/como-empezar-con-python/.
http://www.ubuntumx.org/historia.php
80
19. ANEXOS
#!/usr/bin/env python
#-*- coding: utf-8 -*-
def valor_combobox(combobox):
model = combobox.get_model()
activo = combobox.get_active()
if activo < 0:
81
return None
return model[activo][0]
def Enviar_protocolo(txt_cmm):
textbuffer = Gtk.TextBuffer()
if prot == 'RIP':
x = 'ripd'
prot = 'rip'
if prot == 'OSPF':
x = 'ospfd'
prot = 'ospf'
child = pexpect.spawn(commands[0] + x)
child.timeout = 0.5
child.expect('Password: ')
child.sendline('zebra')
child.sendline(commands[1])
child.sendline(commands[2])
child.sendline('router ' + prot)
if prot == 'rip':
child.sendline('network ' + netrip)
child.sendline('version ' + version)
textbuffer.insert_at_cursor('router ' + prot + '\r' + 'network ' + netrip + '\r' +
'version ' + version)
if prot == 'ospf':
txt_cmm.set_buffer(textbuffer)
child.sendcontrol('z')
child.sendline(commands[7])
child.interact()
82
# Función para la autenticación y envío de comandos al Router Cisco ###################
global text_psw_ssh
if user == 1:
child.sendline(commands[pos] + '\r'*50)
child.sendline(commands[7])
next_line = child.readline()
while next_line != '' :
print (next_line.strip())
textbuffer.insert_at_cursor(next_line.strip() + '\r')
textviewcmm.set_buffer(textbuffer)
try:
next_line = child.readline()
except pexpect.TIMEOUT:
pass
break
if user == 3:
child.sendline(commands[2])
child.sendline('ipv6 unicast-routing' + '\r')
textbuffer.set_text('ipv6 unicast-routing' + '\r')
txt_cmm.set_buffer(textbuffer)
if user == 4:
child.sendline(cmmsend[i] + '\r')
next_line = child.readline()
83
while next_line != '' :
print (next_line.strip())
textbuffer.insert_at_cursor(next_line.strip() + '\r')
textviewcmm2.set_buffer(textbuffer)
try:
next_line = child.readline()
except pexpect.TIMEOUT:
pass
break
if user == 5:
child.sendline(commands[2])
if len(texto1) > 0:
child.sendline(commands[3] + texto1)
textbuffer.insert_at_cursor(commands[3] + texto1 +'\r')
txt_cmm.set_buffer(textbuffer)
if len(texto3) > 0:
child.sendline('username admin ' + commands[4] + texto3)
text_psw_ssh = texto3
textbuffer.insert_at_cursor(commands[4] + texto3 + '\r')
txt_cmm.set_buffer(textbuffer)
if len(texto4) > 0 and len(texto5) > 0:
child.sendline(commands[5] + texto4)
child.sendline(commands[6] + texto5)
child.sendline('no shutdown')
textbuffer.insert_at_cursor(commands[5] + texto4 + '\r' + commands[6] +
texto5 + '\r' + 'no shutdown' + '\r')
txt_cmm.set_buffer(textbuffer)
if user == 6:
child.sendline(commands[2])
child.sendline(commands[11] + nAcl1 +' '+ commands[pos] + addAcl1 +' ' +
wildAcl1 )
textbuffer.insert_at_cursor(commands[11] + nAcl1 + ' ' + commands[pos] +
addAcl1 + ' ' + wildAcl1 + '\r')
84
if len(intAcl) > 0:
child.sendline(commands[5] + intAcl)
child.sendline('ip access-group ' + nAcl1 + interAcl)
textbuffer.insert_at_cursor(commands[5] + intAcl + '\r' + 'ip access-group '
+ nAcl1 + interAcl)
txt_cmm.set_buffer(textbuffer)
if user == 7:
child.sendline(commands[2])
child.sendline(commands[11] + nAclx1 +' '+ commands[pos] + selprot +
addsAclx1 + ' ' + wildsAclx1 +' '+ selop1 + ports + ' ' + adddAclx1+' ' + wilddAclx1 +' '+ selop2 +
portd)
textbuffer.insert_at_cursor(commands[11] + nAclx1 +' '+ commands[pos] +
selprot + addsAclx1 + ' ' + wildsAclx1 +' '+ selop1 + ports + ' ' + adddAclx1 +' ' + wilddAclx1 +'
'+ selop2 + portd + '\r')
if len(intAclx) > 0:
child.sendline(commands[5] + intAclx)
child.sendline('ip access-group ' + nAclx1 + interAclx)
textbuffer.insert_at_cursor(commands[5] + intAclx + '\r' + 'ip access-group
' + nAclx1 + interAclx)
txt_cmm.set_buffer(textbuffer)
if user == 8:
child.sendline(commands[2])
child.sendline('router rip')
child.sendline('version ' + str(verrip))
child.sendline(commands[pos] + netrip1)
textbuffer.insert_at_cursor('router rip' + '\r' + 'version ' + str(verrip) + '\r' +
commands[pos] + netrip1)
if len(version1) > 0:
child.sendline('passive-interface ' + version1)
txt_cmm.set_buffer(textbuffer)
if user == 9:
child.sendline(commands[2])
85
child.sendline('ip dhcp excluded-address ' + add_start + ' ' + add_end)
child.sendline('ip dhcp pool ' + name_pool)
child.sendline('network ' + pooladd_start + ' ' + pooladd_end)
child.sendline('default-router ' + gateway)
if user == 10:
if nat == 'static':
child.sendline(commands[2])
child.sendline(commands[16] + 'source static ' + ippriv + ' ' + ippub)
textbuffer.insert_at_cursor(commands[16] + 'source static ' + ippriv + ' ' +
ippub)
child.sendline(commands[2])
child.sendline('ip nat pool ' + namenat + ' ' + pubst + ' ' + pubend + '
netmask ' + pubsub)
child.sendline(commands[11] + acc + ' permit ' + prist + ' ' + priwild)
child.sendline(commands[16] + 'source list ' + acc + ' pool ' + namenat + '
overload')
textbuffer.insert_at_cursor('ip nat pool ' + namenat + ' ' + pubst + ' ' +
pubend + ' netmask ' + pubsub)
textbuffer.insert_at_cursor(commands[11] + acc + ' permit ' + prist + ' ' +
priwild)
textbuffer.insert_at_cursor(commands[16] + 'source list ' + acc + ' pool ' +
namenat + ' overload')
if nat == 'dynamic':
child.sendline(commands[2])
child.sendline('ip nat pool ' + namenat + ' ' + pubst + ' ' + pubend + '
netmask ' + pubsub)
child.sendline(commands[11] + acc + ' permit ' + prist + ' ' + priwild)
child.sendline(commands[16] + 'source list ' + acc + ' pool ' + namenat)
textbuffer.insert_at_cursor('ip nat pool ' + namenat + ' ' + pubst + ' ' +
pubend + ' netmask ' + pubsub)
textbuffer.insert_at_cursor(commands[11] + acc + ' permit ' + prist + ' ' +
priwild)
textbuffer.insert_at_cursor(commands[16] + 'source list ' + acc + ' pool ' +
namenat)
86
child.sendline(commands[5] + ' ' + ethin)
child.sendline(commands[16])
child.sendline(commands[5] + ' ' + ethout)
child.sendline(commands[17])
txt_cmm.set_buffer(textbuffer)
if user == 11:
child.sendline(commands[2])
child.sendline('router ospf ' + process)
child.sendline('router-id ' + routerid1)
child.sendline('network ' + network1 + ' area ' + area1)
textbuffer.insert_at_cursor('router ospf ' + process + '\r' + 'router id ' + routerid1
+ '\r' + 'network ' + network1 + ' area' + area1)
txt_cmm.set_buffer(textbuffer)
if user == 12:
child.sendline(commands[2])
child.sendline('router eigrp ' + process)
child.sendline('eigrp router-id ' + routerid1)
child.sendline('network ' + network1 + ' ' + area1)
textbuffer.insert_at_cursor('router eigrp ' + process + '\r' + 'eigrp router id ' +
routerid1 + '\r' + 'network ' + network1 + area1)
txt_cmm.set_buffer(textbuffer)
if user == 13:
child.sendline(commands[2])
child.sendline(commands[pos] + netdes1 + ' ' + mask1 + ' ' + hop1)
textbuffer.insert_at_cursor(commands[pos] + netdes1 + ' ' + mask1 + ' ' + hop1)
txt_cmm.set_buffer(textbuffer)
child.sendcontrol('z')
child.sendline(commands[7])
child.interact()
global texto2,texto3,commands,pos,user,pos1,cmmsend,pos2
87
child = pexpect.spawn(commands[0] + '2601')
child.timeout = 0.5
child.expect('Password: ')
child.sendline(texto2)
child.sendline(commands[1])
if user == 1:
child.sendline(commands[pos])
textbuffer = Gtk.TextBuffer()
next_line = child.readline()
while next_line != '' :
print (next_line.strip())
textbuffer.insert_at_cursor(next_line.strip() + '\r')
textviewcmm.set_buffer(textbuffer)
try:
next_line = child.readline()
except pexpect.TIMEOUT:
pass
break
if user == 2:
child.sendline(commands[pos])
if user == 3:
child.sendline(commands[2])
child.sendline(commands[pos])
textbuffer3 = Gtk.TextBuffer()
textbuffer3.set_text(commands[pos] + '\r')
print commands[pos] + texto2
txt_cmm.set_buffer(textbuffer3)
if user == 4:
textbuffer1 = Gtk.TextBuffer()
next_line = child.readline()
while next_line != '' :
print (next_line.strip())
88
textbuffer1.insert_at_cursor(next_line.strip() + '\r')
textviewcmm2.set_buffer(textbuffer1)
try:
next_line = child.readline()
except pexpect.TIMEOUT:
pass
break
if user == 5:
child.sendline(commands[2])
textbuffer2 = Gtk.TextBuffer()
if len(texto1) > 0:
child.sendline(commands[3] + texto1)
textbuffer2.insert_at_cursor(commands[3] + texto1 +'\r')
txt_cmm.set_buffer(textbuffer2)
if len(texto3) > 0:
child.sendline(commands[4] + texto3)
texto2=texto3
textbuffer2.insert_at_cursor(commands[4] + texto3 + '\r')
txt_cmm.set_buffer(textbuffer2)
if len(texto4) > 0 and len(texto5) > 0:
child.sendline(commands[5] + texto4)
child.sendline(commands[6] + texto5)
textbuffer2.insert_at_cursor(commands[5] + texto4 + '\r' + commands[6]
+ texto5 + '\r')
txt_cmm.set_buffer(textbuffer2)
if user == 6:
child.sendline(commands[2])
textbuffer3 = Gtk.TextBuffer()
child.sendline(commands[11] + xentry_nAcl +' '+ commands[pos] +
xentry_addAcl +' ' + xentry_wildAcl )
textbuffer3.insert_at_cursor(commands[11] + xentry_nAcl +' '+ commands[pos]
+ xentry_addAcl +' ' + xentry_wildAcl )
txt_cmm.set_buffer(textbuffer3)
if user == 7:
child.sendline(commands[2])
textbuffer3 = Gtk.TextBuffer()
child.sendline(commands[11] + xentry_nAclx +' '+ commands[pos] +'ip '+
xentry_addsAclx +' ' + xentry_wildsAclx +' '+ xentry_adddAclx +' ' + xentry_wilddAclx)
89
textbuffer3.insert_at_cursor(commands[11] + xentry_nAclx +' '+ commands[pos]
+'ip '+ xentry_addsAclx +' ' + xentry_wildsAclx +' '+ xentry_adddAclx +' ' + xentry_wilddAclx)
txt_cmm.set_buffer(textbuffer3)
if user == 8:
textbuffer3 = Gtk.TextBuffer()
child.sendline(commands[2])
child.sendline(commands[pos] + netdes + ' ' + mask + ' ' + hop)
textbuffer3.insert_at_cursor(commands[pos] + netdes + ' ' + mask + ' ' + hop)
txt_cmm.set_buffer(textbuffer3)
child.sendcontrol('z')
child.sendline(commands[7])
child.interact()
if flag == 0:
if i == 0:
error('Credenciles erradas')
print 'Credenciales erradas'
ssh.show_all()
if i == 1:
child.sendline(commands[7])
window2.show()
child.interact()
elif flag == 1:
90
if texto_user_in == "admin":
child = pexpect.spawn(commands[0] + '2601')
child.TIMEOUT = 0.5
child.expect('Password: ')
child.sendline(texto2)
i = child.expect(['Password: ' , pexpect.TIMEOUT] , timeout = 1)
if i == 0:
elif i == 1:
window2.show()
child.sendline(commands[1])
child.sendline(texto2)
child.sendline(commands[2])
child.sendline('no ' + commands[1] + commands[4])
child.sendcontrol('z')
child.sendline(commands[7])
combox_prt.hide()
dialog_error.hide()
button_conf_nat.hide()
button_conf_dhcp.hide()
child.interact()
else:
error("El usuario esto errado")
print "El usuario esta errado"
ventana_in.show_all()
#Clase Principal
class MainGui():
# Funcion que llama widgets desde interface gráfica y se ejecuta ventana inicial ##########
def __init__(self):
self.builder = Gtk.Builder()
self.builder.add_from_file("Proyecto3.glade")
manejadores = {
91
"on_button_quagga_clicked": self.evento_quagga,
"on_window_in_destroy": self.event_close,
"on_button_cisco_clicked": self.evento_cisco,
"on_button_in_clicked": self.btt_in,
"on_button_sn2_clicked": self.on_button_sn2_clicked,
"on_button_cancel_clicked": self.btt_cancel,
"on_button_SSH_w_clicked": self.SSH_click,
"on_button_send1_clicked": self.send1_click,
"on_combobox_prot_changed": self.on_combox_prot,
"on_protocolo_delete_event": self.on_protocolo_delete,
"on_button_sendpro_clicked": self.sendpro_click,
"on_button_conf_dhcp_clicked": self.conf_dhcp_click,
"on_DHCP_delete_event":self.on_DHCP_delete_event,
"on_Acl_estandar_delete_event": self.on_Acl_estandar_delete_event,
"on_button_conf_acl_clicked": self.on_button_conf_acl_clicked,
"on_button_conf_nat_clicked": self.on_button_conf_nat_clicked,
"on_nat_overload_delete_event": self.on_nat_overload_delete_event,
"on_nat_static_delete_event": self.on_nat_static_delete_event,
"on_button_rqs1_clicked": self.on_button_rqs1_clicked,
"on_button_on_ipv6_clicked": self.on_button_on_ipv6_clicked,
"on_combobox_prot1_changed": self.on_combobox_prot1_changed,
"on_Acl_extendida_delete_event": self.on_Acl_extendida_delete_event,
"on_button_acl_estandar_clicked": self.on_button_acl_estandar_clicked,
"on_button_acl_extendida_clicked":
self.on_button_acl_extendida_clicked,
"on_button_ping_clicked": self.on_button_ping_clicked,
"on_button_tracert_clicked":self.on_button_tracert_clicked,
"on_ssh_delete_event": self.on_ssh_delete_event,
"on_button_dhcp_clicked": self.on_button_dhcp_clicked,
"on_button_nat_overload_clicked": self.on_button_nat_overload_clicked,
"on_button_static_clicked": self.on_button_static_clicked,
"on_button_sendpro1_clicked":self.on_button_sendpro1_clicked,
"on_protocolo1_delete_event": self.on_protocolo1_delete_event,
"on_button_acl_estandar1_clicked":
self.on_button_acl_estandar1_clicked,
"on_button_acl_extendida1_clicked":
self.on_button_acl_extendida1_clicked,
"on_Acl_estandar1_delete_event": self.on_Acl_estandar1_delete_event,
"on_Acl_extendida1_delete_event":
self.on_Acl_extendida1_delete_event,
"on_ventana_delete_event": self.on_ventana_delete_event,
"gtk_main_quit": self.gtk_main_quit
92
}
self.builder.connect_signals(manejadores)
self.window2 = self.builder.get_object("ventana")
self.notebook = self.builder.get_object("notebook")
self.textviewcmm = self.builder.get_object("textviewcmm")
self.textviewcmm2 = self.builder.get_object("textviewcmm2")
self.entry_cmm1 = self.builder.get_object("entry_cmm1")
self.entry_hs = self.builder.get_object("entry_hs")
self.entry_psw_st = self.builder.get_object("entry_psw_st")
self.entry_nm_int = self.builder.get_object("entry_nm_int")
self.entry_ip_int = self.builder.get_object("entry_ip_int")
self.txt_cmm = self.builder.get_object("text_cmm")
self.combox_prt = self.builder.get_object("combobox_prot")
self.combox_prt1 = self.builder.get_object("combobox_prot1")
self.combox3 = self.builder.get_object("combobox3")
self.combox4 = self.builder.get_object("combobox4")
self.combox5 = self.builder.get_object("combobox5")
self.button_conf_nat = self.builder.get_object("button_conf_nat")
self.button_conf_dhcp = self.builder.get_object("button_conf_dhcp")
self.radio_acl_stnd = self.builder.get_object("radio_acl_stnd")
self.radio_acl_extd = self.builder.get_object("radio_acl_extd")
self.protocolo = self.builder.get_object("protocolo")
self.overlay1 = self.builder.get_object("overlay1")
self.overlay2 = self.builder.get_object("overlay2")
self.overlay5 = self.builder.get_object("overlay5")
self.entry_routerid = self.builder.get_object("entry_routerid")
self.entry_net = self.builder.get_object("entry_net")
self.entry_area = self.builder.get_object("entry_area")
self.entry_netdes = self.builder.get_object("entry_netdes")
self.entry_mask = self.builder.get_object("entry_mask")
self.entry_hop = self.builder.get_object("entry_hop")
self.entry_netrip = self.builder.get_object("entry_netrip")
self.entry_version = self.builder.get_object("entry_version")
self.protocolo1 = self.builder.get_object("protocolo1")
self.overlay3 = self.builder.get_object("overlay3")
self.overlay4 = self.builder.get_object("overlay4")
self.overlay6 = self.builder.get_object("overlay6")
93
self.entry_routerid1 = self.builder.get_object("entry_routerid1")
self.entry_net1 = self.builder.get_object("entry_net1")
self.entry_area1 = self.builder.get_object("entry_area1")
self.entry_process = self.builder.get_object("entry_process")
self.entry_netdes1 = self.builder.get_object("entry_netdes1")
self.entry_mask1 = self.builder.get_object("entry_mask1")
self.entry_hop1 = self.builder.get_object("entry_hop1")
self.entry_netrip1 = self.builder.get_object("entry_netrip1")
self.entry_version1 = self.builder.get_object("entry_version1")
self.label_netwild = self.builder.get_object("label26")
self.label_area = self.builder.get_object("label72")
self.label_process = self.builder.get_object("label25")
self.entry_nAcl = self.builder.get_object("entry_nAcl")
self.entry_addAcl = self.builder.get_object("entry_addAcl")
self.entry_wildAcl = self.builder.get_object("entry_wildAcl")
self.radio_permit = self.builder.get_object("radio_permit")
self.radio_deny = self.builder.get_object("radio_deny")
self.entry_nAcl1 = self.builder.get_object("entry_nAcl1")
self.entry_addAcl1 = self.builder.get_object("entry_addAcl1")
self.entry_wildAcl1 = self.builder.get_object("entry_wildAcl1")
self.radio_permit1 = self.builder.get_object("radio_permit1")
self.radio_deny1 = self.builder.get_object("radio_deny1")
self.entry_intAcl = self.builder.get_object("entry_intAcl")
self.radio_inAcl = self.builder.get_object("radio_inAcl")
self.radio_outAcl = self.builder.get_object("radio_outAcl")
self.entry_nAclx = self.builder.get_object("entry_nAclx")
self.entry_addsAclx = self.builder.get_object("entry_addsAclx")
self.entry_wildsAclx = self.builder.get_object("entry_wildsAclx")
self.entry_adddAclx = self.builder.get_object("entry_adddAclx")
self.entry_wilddAclx = self.builder.get_object("entry_wilddAclx")
self.radio_permitx = self.builder.get_object("radio_permitx")
self.radio_denyx = self.builder.get_object("radio_denyx")
self.entry_nAclx1 = self.builder.get_object("entry_nAclx1")
self.entry_addsAclx1 = self.builder.get_object("entry_addsAclx1")
self.entry_wildsAclx1 = self.builder.get_object("entry_wildsAclx1")
self.combo_protAcl = self.builder.get_object("combo_protAcl")
self.combo_op1 = self.builder.get_object("combo_op1")
self.entry_ports = self.builder.get_object("entry_ports")
self.entry_adddAclx1 = self.builder.get_object("entry_adddAclx1")
94
self.entry_wilddAclx1 = self.builder.get_object("entry_wilddAclx1")
self.combo_op2 = self.builder.get_object("combo_op2")
self.entry_portd = self.builder.get_object("entry_portd")
self.entry_intAclx = self.builder.get_object("entry_intAclx")
self.radio_permitx1 = self.builder.get_object("radio_permitx1")
self.radio_denyx1 = self.builder.get_object("radio_denyx1")
self.radio_inAclx = self.builder.get_object("radio_inAclx")
self.radio_outAclx = self.builder.get_object("radio_outAclx")
self.entry_test = self.builder.get_object("entry_test")
self.text_ex = self.builder.get_object("text_ex")
self.entry_test = self.builder.get_object("entry_test")
self.txt_ex = self.builder.get_object("text_ex")
self.window = self.builder.get_object("ventana_inicio")
self.ventana_in = self.builder.get_object("window_in")
self.entry_psw = self.builder.get_object("entry_psw_in")
self.entry_user = self.builder.get_object("entry_user_in")
self.title_in = self.builder.get_object("title_in")
self.ssh = self.builder.get_object("ssh")
self.entry_address = self.builder.get_object("entry_address")
self.entry_user_ssh = self.builder.get_object("entry_user_ssh")
self.entry_psw_ssh = self.builder.get_object("entry_psw_ssh")
self.entry_cmm1 = self.builder.get_object("entry_cmm1")
self.dhcp = self.builder.get_object("DHCP")
self.entry_add_start = self.builder.get_object("entry_add_start")
self.entry_add_end = self.builder.get_object("entry_add_end")
self.entry_namepool = self.builder.get_object("entry_namepool")
self.entry_pooladd_start = self.builder.get_object("entry_pooladd_start")
self.entry_pooladd_end = self.builder.get_object("entry_pooladd_end")
self.entry_gateway = self.builder.get_object("entry_gateway")
self.Acl_estandar = self.builder.get_object("Acl_estandar")
self.Acl_extendida = self.builder.get_object("Acl_extendida")
self.Acl_estandar1 = self.builder.get_object("Acl_estandar1")
self.Acl_extendida1 = self.builder.get_object("Acl_extendida1")
self.nat_overload = self.builder.get_object("nat_overload")
self.nat_static = self.builder.get_object("nat_static")
95
self.radio_dynamic = self.builder.get_object("radio_dynamic")
self.radio_static = self.builder.get_object("radio_static")
self.entry_pubstart = self.builder.get_object("entry_pubstart")
self.entry_pubend = self.builder.get_object("entry_pubend")
self.entry_pubsubmask = self.builder.get_object("entry_pubsubmask")
self.entry_pristart = self.builder.get_object("entry_pristart")
self.entry_priwild = self.builder.get_object("entry_priwild")
self.entry_ethin = self.builder.get_object("entry_ethin")
self.entry_ethout = self.builder.get_object("entry_ethout")
self.entry_ippriv = self.builder.get_object("entry_ippriv")
self.entry_ippub = self.builder.get_object("entry_ippub")
self.entry_ethinst = self.builder.get_object("entry_ethinst")
self.entry_ethoutst = self.builder.get_object("entry_ethoutst")
self.entry_nacc_nat = self.builder.get_object("entry_nacc_nat")
self.entry_namenat = self.builder.get_object("entry_namenat")
self.check_overload = self.builder.get_object("check_overload")
self.combox_prt.set_active(0)
self.combox_prt1.set_active(0)
self.combo_op1.set_active(0)
self.combo_op2.set_active(0)
self.combo_protAcl.set_active(0)
self.window.show_all()
# Función que despliega ventana para ingreso credenciales Router Cisco ################
def evento_cisco(self,widget):
global flag
flag = 0
self.title_in.set_text("AUTORIZACION ROUTER CISCO")
self.ssh.show()
self.window.hide()
self.dialog_error.hide()
# Función que despliega ventana para ingreso credenciales Router Quagga ##############
def evento_quagga(self,widget):
global flag
96
flag = 1
self.title_in.set_text("AUTORIZACION ROUTER QUAGGA")
self.ventana_in.show()
self.window.hide()
self.dialog_error.hide()
global user,texto1,texto3,texto4,texto5
user = 5
texto3 = self.entry_psw_st.get_text()
texto1 = self.entry_hs.get_text()
texto4 = self.entry_nm_int.get_text()
texto5 = self.entry_ip_int.get_text()
if flag == 0:
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
if flag == 1:
ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
self.window2.hide()
self.window.show()
return True
97
# Función de envío de comandos manual #########################################
self.ventana_in.hide()
self.window.show_all()
self.ventana_in.hide()
self.window.show_all()
return True
98
#Función de ejecución del botón para el envio SSH ##################################
text_address = self.entry_address.get_text()
text_user_ssh = self.entry_user_ssh.get_text()
text_psw_ssh = self.entry_psw_ssh.get_text()
self.ssh.hide()
acceder(self.window2, self.error, self.ventana_in, self.dialog_error,
self.combox_prt, self.button_conf_nat, self.button_conf_dhcp, self.ssh)
self.window.show()
self.ssh.hide()
return True
global prot1
selec = valor_combobox(self.combox_prt)
self.protocolo1.show()
99
self.overlay3.hide()
self.overlay4.hide()
self.overlay6.show()
self.protocolo1.show()
self.label_netwild.set_text("Network/Wildcard")
self.label_area.set_text("Area")
self.label_process.set_text("Proceso")
self.overlay3.hide()
self.overlay4.show()
self.overlay6.hide()
self.protocolo1.show()
self.label_netwild.set_text("Network")
self.label_area.set_text("Wildcard")
self.label_process.set_text("AS")
self.overlay3.hide()
self.overlay4.show()
self.overlay6.hide()
self.protocolo1.show()
self.overlay3.show()
self.overlay4.hide()
self.overlay6.hide()
prot1 = selec
global prot
selec = valor_combobox(self.combox_prt1)
if selec == "RIP":
self.protocolo.show()
self.overlay1.hide()
self.overlay2.hide()
100
self.overlay5.show()
if selec == "OSPF":
self.protocolo.show()
self.overlay1.hide()
self.overlay2.show()
self.overlay5.hide()
prot = selec
self.protocolo.hide()
return True
global pos , user , routerid , network , area , netdes , mask , hop , netrip , version ,
prot
netdes = self.entry_netdes.get_text()
mask = self.entry_mask.get_text()
hop = self.entry_hop.get_text()
routerid = self.entry_routerid.get_text()
network = self.entry_net.get_text()
area = self.entry_area.get_text()
netrip = self.entry_netrip.get_text()
version = self.entry_version.get_text()
if prot == 'ESTATICO':
user = 8
pos = 14
101
ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
Enviar_protocolo(self.txt_cmm)
self.protocolo.hide()
return True
global pos , user , routerid1 , network1 , area1 , process , netdes1 , mask1 , hop1
, netrip1 , version1 , prot , verrip
netdes1 = self.entry_netdes1.get_text()
mask1 = self.entry_mask1.get_text()
hop1 = self.entry_hop1.get_text()
routerid1 = self.entry_routerid1.get_text()
network1 = self.entry_net1.get_text()
area1 = self.entry_area1.get_text()
netrip1 = self.entry_netrip1.get_text()
version1 = self.entry_version1.get_text()
process = self.entry_process.get_text()
if prot1 == 'RIPv1':
user = 8
pos = 18
verrip = 1
user = 8
pos = 18
verrip = 2
user = 12
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
user = 13
pos = 14
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
self.protocolo1.hide()
return True
self.protocolo1.hide()
return True
if self.radio_permit.get_active():
pos = 12
if self.radio_deny.get_active():
pos = 13
103
ingresar_quagga(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
self.Acl_estandar.hide()
return True
if self.radio_permitx.get_active():
pos = 12
if self.radio_denyx.get_active():
pos = 13
user = 6
nAcl1 = self.entry_nAcl1.get_text()
addAcl1 = self.entry_addAcl1.get_text()
wildAcl1 = self.entry_wildAcl1.get_text()
intAcl = self.entry_intAcl.get_text()
if self.radio_permit1.get_active():
104
pos = 12
if self.radio_deny1.get_active():
pos = 13
if self.radio_inAcl.get_active():
if self.radio_outAcl.get_active():
selprot = valor_combobox(self.combo_protAcl)
selop1 = valor_combobox(self.combo_op1)
selop2 = valor_combobox(self.combo_op2)
if selop1 == 'OPERADOR':
selop1 = ''
ports = ''
if selop2 == 'OPERADOR':
105
selop2 = ''
portd = ''
if self.radio_permitx1.get_active():
pos = 12
if self.radio_denyx1.get_active():
pos = 13
if self.radio_inAclx.get_active():
interAclx = ' in'
if self.radio_outAclx.get_active():
interAclx = ' out'
self.dhcp.show_all()
add_start = self.entry_add_start.get_text()
add_end = self.entry_add_end.get_text()
name_pool = self.entry_namepool.get_text()
pooladd_start = self.entry_pooladd_start.get_text()
pooladd_end = self.entry_pooladd_end.get_text()
gateway = self.entry_gateway.get_text()\
user = 9
self.dhcp.hide()
return True
global flag
if flag == 0:
if self.radio_acl_stnd.get_active():
self.Acl_estandar1.show_all()
if self.radio_acl_extd.get_active():
self.Acl_extendida1.show_all()
if flag == 1:
if self.radio_acl_stnd.get_active():
self.Acl_estandar.show_all()
if self.radio_acl_extd.get_active():
self.Acl_extendida.show_all()
self.Acl_estandar.hide()
return True
self.Acl_extendida.hide()
return True
self.Acl_estandar1.hide()
107
return True
self.Acl_extendida1.hide()
return True
if self.radio_dynamic.get_active():
self.nat_overload.show_all()
if self.radio_static.get_active():
self.nat_static.show_all()
global user , nat , pubst , pubend , pubsub , prist , priwild , ethin , ethout ,
namenat , acc
pubst = self.entry_pubstart.get_text()
pubend = self.entry_pubend.get_text()
pubsub = self.entry_pubsubmask.get_text()
prist = self.entry_pristart.get_text()
priwild = self.entry_priwild.get_text()
ethin = self.entry_ethin.get_text()
ethout = self.entry_ethout.get_text()
acc = self.entry_nacc_nat.get_text()
namenat = self.entry_namenat.get_text()
if self.check_overload.get_active():
nat = 'dynamic overload'
else:
nat = 'dynamic'
user = 10
ippriv = self.entry_ippriv.get_text()
ippub = self.entry_ippub.get_text()
ethin = self.entry_ethinst.get_text()
ethout = self.entry_ethoutst.get_text()
user = 10
nat = 'static'
ingresar_cisco(self.textviewcmm , self.textviewcmm2 , self.txt_cmm)
self.nat_static.hide()
return True
self.nat_overload.hide()
return True
self.nat_static.hide()
return True
textbuffer4 = Gtk.TextBuffer()
text_ping = self.entry_test.get_text()
p = pexpect.spawn('ping '+ text_ping)
109
next_line = p.readline()
q=0
while next_line != '' :
print (next_line.strip())
textbuffer4.insert_at_cursor(next_line.strip() + '\r')
self.text_ex.set_buffer(textbuffer4)
next_line = p.readline()
if q == 4:
p.sendcontrol('z')
break
q=q+1
textbuffer4 = Gtk.TextBuffer()
text_ping = self.entry_test.get_text()
p = pexpect.spawn('traceroute '+ text_ping)
next_line = p.readline()
Gtk.main_quit(*args)
def error(self,message):
global flag
"Display the error dialog "
self.dialog_error = Gtk.MessageDialog(parent=None, flags=0)
self.dialog_error.set_title("Error")
label = Gtk.Label(message)
self.dialog_error.vbox.pack_start(label, True, True, 0)
110
button = Gtk.Button(stock=Gtk.STOCK_OK)
if flag == 0:
button.connect("clicked", self.evento_cisco)
if flag == 1:
button.connect("clicked", self.evento_quagga)
self.dialog_error.vbox.pack_start(button, False, False, 0)
# Con show_all() mostramos el contenido del cuadro de dialogo (en este #######
# caso solo tiene la etiqueta) si no se hace el dialogo aparece vacío ############
self.dialog_error.show_all()
# El run y destroy hace que la ventana se cierre al apretar el botón ############
self.dialog_error.run()
self.dialog_error.hide()
#self.evento_quagga()
def main():
window = MainGui()
Gtk.main()
return 0
if __name__ == '__main__':
main()
111