Page locked

This page is currently locked for editing by another user. You have to wait until this user finishes editing or the lock expires.
Currently locked by: 192.168.200.11,192.168.10.1
Lock expires at: 2026/04/11 20:08 (14 min)
This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Cisco ======

Para configurar un dispositivo Cisco, hay que entrar en modo de administración. Esto se hace con `enable`:
```
Router>enable
Router#
```

Una vez en modo administrativo, cambia el prompt de `>` a `#`. 

En este modo, podemos ver bastantes cosas y configurar alguna, pero por lo general, será insuficiente. 

===== Router =====

Los routers tienen varios interfaces. También, según modelo, tiene unos módulos precargados, con su firmware y sus interfaces. Usaremos básicamente 3 modelos:
  * El modelo 2901, que trae un módulo con 2 interfaces Gigabit. Para serial, hay que añadir un módulo adicional (`HWIC-2T`), en caso de ser necesario.
  * El modelo PT (o PT empty), que es totalmente configurable y puede tener muchos módulos Gigabit.
  * El modelo 2811, el único que soporta telefonía.

==== Comandos en modo administrativo ====

Como ayuda, siempre podremos pulsar la interrogación `?` (no hace falta ni pulsar Enter) para ver los comandos disponibles:

```
Router#?
Exec commands:
  <1-99>      Session number to resume
  auto        Exec level Automation
  clear       Reset functions
  clock       Manage the system clock
  configure   Enter configuration mode
  connect     Open a terminal connection
  copy        Copy from one file to another
  debug       Debugging functions (see also 'undebug')
  delete      Delete a file
  dir         List files on a filesystem
  disable     Turn off privileged commands
  disconnect  Disconnect an existing network connection
  enable      Turn on privileged commands
  erase       Erase a filesystem
  exit        Exit from the EXEC
  logout      Exit from the EXEC
  mkdir       Create new directory
  more        Display the contents of a file
  no          Disable debugging informations
  ping        Send echo messages
  reload      Halt and perform a cold restart
  resume      Resume an active network connection
  rmdir       Remove existing directory
  send        Send a message to other tty lines
  setup       Run the SETUP command facility
  show        Show running system information
  ssh         Open a secure shell client connection
  telnet      Open a telnet connection
  terminal    Set terminal line parameters
  traceroute  Trace route to destination
  undebug     Disable debugging functions (see also 'debug')
  vlan        Configure VLAN parameters
  write       Write running configuration to memory, network, or terminal
```

También se puede usar dentro de cada opción, para ver las opciones secundarias.


Podemos usar el tabulador para completar un comando después de escribir al menos los 3 primeros caracteres:

```
Router#conf
Router#configure ter
Router#configure terminal 
Enter configuration commands, one per line.  End with CNTL/Z.
Router(config)#
```

En este modo, principalmente se pueden usar comandos `show`:

=== Ver las ip de las interfaces ===


```
Router#show ip interface brief
Interface              IP-Address      OK? Method Status                Protocol 
GigabitEthernet0/0     192.168.10.1    YES manual up                    up 
GigabitEthernet0/1     192.168.20.1    YES manual up                    up 
Vlan1                  unassigned      YES unset  administratively down down
```

=== Ver la configuración actual ===

```
Router#show running-config 
Building configuration...

Current configuration : 984 bytes
!
version 16.6.4
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname Router
!
!
interface GigabitEthernet0/0
 ip address 192.168.10.1 255.255.255.0
 duplex auto
 speed auto
!
interface GigabitEthernet0/1
 no ip address
 duplex auto
 speed auto
!
interface Vlan1
 no ip address
 shutdown
!
!
end
```

Se han omitido algunas líneas.

=== Guardar la configuración ===

Se usa el comando `write memory` (sólo en este modo):

```
Router#write memory 
Building configuration...
[OK]
Router#
```



==== Entrar en modo configuración ====

Desde el modo administración, entraremos al modo configuración con `configure terminal`:

```
Router#
Router#configure terminal
Enter configuration commands, one per line.  End with CNTL/Z.
Router(config)#
```

En general, observaremos que el prompt cambia según estemos en un modo u otro. También, dentro del modo de configuración, cambiará el prompt según el submenú en el que estemos.


==== Asignar una ip a una interfaz ====

=== Sin VLAN específica ===


En general, para trabajar con una interfaz, primero tenemos que entrar en esa opción mediante el comando `interface` seguido de la interfaz. Se puede usar el nombre largo o el nombre corto(`int`), que se muestra al tener un cable conectado. El nombre NO es sensible a mayúsculas:

```
Router(config)#interface gig0/0
Router(config-if)#exit
Router(config)#int gigabitEthernet 0/0
Router(config-if)#
```

Las dos formas entran en el mismo interfaz, `gig0/0` o `gigabitEthernet 0/0` (se puede omitir el espacio entre el nombre y el número dentro del interfaz). Vemos que cambia el prompt a `(config-if)`.

Ahora, asignamos la ip principal, con su máscara de red:

```
Router(config-if)# ip address 192.168.1.1 255.255.255.0
Router(config-if)#
```

Si todo ha ido correcto, no muestra ningún error.

Después de asignar la ip, conviene decirle al dispositivo que levante la interfaz, que por defecto está bajado. Esto se hace con el comando `no shutdown`. Veremos mensajes relativos al cambio de estado de la interfaz, si estuviera bajada:

```
Router(config-if)#no shutdown

Router(config-if)#
%LINK-5-CHANGED: Interface GigabitEthernet0/0, changed state to up

%LINEPROTO-5-UPDOWN: Line protocol on Interface GigabitEthernet0/0, changed state to up
```
=== Múltiples IP es la misma interfaz lógica ===

Se pueden asignar más de una ip a la misma interfaz, haciendo lo mismo, pero añadiendo al final `secondary`.

=== Encapsulado para VLAN ===

Cuando hay que configurar múltiples ip para distintas VLAN, hay que encapsular. Para ello, procedemos de la siguiente forma:
  - Accedemos a la interfaz principal, y no le asignamos ip: `no ip address`. Opcionalmente, la levantamos con `no shutdown`.
  - Después, accedemos a la subinterfaz añadiendo `.<VLAN>`. Es decir, para la interfaz gig0/0 y la VLAN 10, sería `interface gig0/0.10`. Debería levantarse inmediatamente.
  - En la subinterfaz, asignamos primero la encapsulación con el número de VLAN, es decir `encapsulation dot1Q 10`.
  - Por último, asignamos la dirección ip, igual que si fuera la principal, con `ip address <ip> <mask>`.
  - Repetimos los pasos para las otras subinterfaces, pero con su VLAN, con su número y su dirección IP.
  - Si no levantamos la interfaz principal en su momento, lo hacemos ahora con `no shutdown`. Debería levantar todas las subinterfaces.


```
Router(config)#int gig0/0
Router(config-if)#no ip address
Router(config-if)#no shutdown
Router(config-if)#int gig0/0.10
Router(config-subif)#encapsulation dot1Q 10
Router(config-subif)#ip address 192.168.1.1 255.255.255.0
Router(config-subif)#int gig0/0.20
Router(config-subif)#encapsulation dot1Q 20
Router(config-subif)#exit
```


==== Enrutado ====

Hay varios tipos de enrutado.

=== Enrutado estático ===

Consiste en decirle de forma explícita por dónde tiene que enrutar a una red de destino. La salida puede ser una ip o el interfaz local. No hay que entrar en ninguna interfaz:

```
Router(config)# ip route 0.0.0.0 0.0.0.0 Gig0/0
Router(config)# ip route 10.1.0.0 255.255.0.0 172.16.1.1
```

=== Enrutado por RIPv2 ===

El enrutado por RIPv2 está basado en que en una red donde hay varios routers, se comunican y se anuncian las redes que cada cual conoce, para aprenderlas de forma dinámica. A pesar de que el router conozca sus redes, tiene que habilitar la opción que se va a comunicar con otros routers y decirles qué redes conoce.

```
Router(config)#router rip
Router(config-router)#version 2
Router(config-router)#network 192.168.10.0
```

=== Enrutado por Eigrp ===

El enrutado eigrp se basa en crear un "Sistema autónomo" (AS), con una numeración única entre 1 y 65535. Cada AS anuncia las redes que tiene a los routers vecinos que lo requieran, siendo lo más habitual que cada router que quiera tener conocimiento de un AS, tiene que configurarse con ese AS y anunciar todas las rutas asociadas a sus interfaces. Se inicia con el comando `router eigrp <AS>` en modo configuración. No hay que asociarlo a ningún interfaz. Ejemplo básico:

```
Router(config)#router eigrp 10
Router(config-router)#network 192.168.10.64 0.0.0.31
Router(config-router)#network 192.168.10.132 0.0.0.3
Router(config-router)#network 192.168.10.136 0.0.0.3
Router(config-router)#no auto-summary

```

El segundo parámetro de `network` es la //wildmask//. La forma más simple de entenderlo es que es justo lo contrario de la máscara de subred, es decir, cada octeto es el resultado de restar a 255 el octeto de la máscara de subred. En firmware modernos, es posible que se acepte la máscara de subred directamente, y ya el firmware la traduce a una wildmask. Finalmente, conviene añadir siempre el comando `no auto-summary`. Esto impide que, en casos de subnetting, se unifiquen esas subredes en redes más amplias, ignorando la especificidad que se pudiera haber definido de forma explícita.


Desde el punto de vista de eigrp, sólo "conoce" las redes que, de forma explícita, se configuran dentro del AS. Esto quiere decir que, a pesar de conocer las rutas locales que tiene por asociar ip al interfaz, si no se incluyen de forma explícita, no se distribuyen por eigrp. Esto incluye la interfaz que puede conectar directamente dos routers.

En otro router, se inicia otra sección con el mismo AS, y cuando se dé de alta la interfaz común, se conectarán por eigrp y se compartirán las rutas anunciadas. Estas rutas podrán verse con el comando `show ip route` en modo administrativo (`do show ip route` en modo configuración).

```
R2(config)#do show ip route
Codes: L - local, C - connected, S - static, R - RIP, M - mobile, B - BGP
       D - EIGRP, EX - EIGRP external, O - OSPF, IA - OSPF inter area
       N1 - OSPF NSSA external type 1, N2 - OSPF NSSA external type 2
       E1 - OSPF external type 1, E2 - OSPF external type 2, E - EGP
       i - IS-IS, L1 - IS-IS level-1, L2 - IS-IS level-2, ia - IS-IS inter area
       * - candidate default, U - per-user static route, o - ODR
       P - periodic downloaded static route

Gateway of last resort is not set

     192.168.10.0/24 is variably subnetted, 9 subnets, 4 masks
D       192.168.10.0/26 [90/2172416] via 192.168.10.133, 00:05:05, Serial0/0/0
C       192.168.10.64/27 is directly connected, GigabitEthernet0/0.20
L       192.168.10.65/32 is directly connected, GigabitEthernet0/0.20
D       192.168.10.96/27 [90/2172416] via 192.168.10.138, 00:05:08, Serial0/0/1
D       192.168.10.128/30 [90/2172416] via 192.168.10.133, 00:05:05, Serial0/0/0
C       192.168.10.132/30 is directly connected, Serial0/0/0
L       192.168.10.134/32 is directly connected, Serial0/0/0
C       192.168.10.136/30 is directly connected, Serial0/0/1
L       192.168.10.137/32 is directly connected, Serial0/0/1
```

Las líneas que comienzan por `D` o `EX` son las 'heredadas' por eigrp de otros routers.

== Configuración con distintos AS ==

Para anunciar rutas entre distintos AS, tenemos el comando `redistribute`, que se ubica dentro de la configuración del AS. La sintaxis es:
```
redistribute eigrp <AS> metric <bandwith> <delay> <reliability> <load> <MTU>
```

  * **AS**: Sistema autónomo de origen que se quiere redistribuir.
  * **bandwidth**: Normalmente `10000`. Ancho de banda (en kilobits por segundo) — se usa para calcular la velocidad del enlace.
  * **delay**: Normalmente `100`. Retardo (en decenas de microsegundos). Ejemplo: 100 = 1 ms.
  * **reliability**: Normalmente `255`. Confiabilidad del enlace (1–255). 255 = 100% confiable.
  * **load**: Normalmente `1`. Carga actual (1–255). 1 = enlace sin congestión.
  * **MTU**: Normalmente `1500`. Tamaño máximo de unidad de transmisión (bytes). Solo se incluye para compatibilidad; EIGRP no lo usa en el cálculo.

Cuando tenemos varios routers con distintos AS, el principio es parecido, pero con dos diferencias:
  - Añadir en la sección del AS propio una línea para redistribuir las rutas del AS anterior (de cara a otros routers):

```
Router(config)#router eigrp 200
Router(config-router)#redistribute eigrp 100 metric 10000 100 255 1 1500 
Router(config-router)#network 10.1.12.0 0.0.0.3
Router(config-router)#network 10.1.23.0 0.0.0.3
Router(config-router)#network 10.102.2.0 0.0.0.255
```
  - En el mismo router, añadir una sección haciendo referencia al AS anterior, pero tiene que importar las rutas propias para poder tenerlas. Aquí hay que poner la interfaz que comunica los AS.

```
Router(config)#router eigrp 100
Router(config-router)#redistribute eigrp 200 metric 10000 100 255 1 1500 
Router(config-router)#network 10.1.12.0 0.0.0.3
```






=== OSPF ===

El enrutamiento OSPF (Open Shortest Path First) es un protocolo de enrutamiento dinámico. Calcula el camino más corto usando el algoritmo SPF (Dijkstra).
El principio básico es que se parte de un área (la 0) y los routers del mismo área se comunican las rutas.

Cada router, en OSPF, tiene un router ID (RID). 
El RID es un identificador lógico único dentro del dominio OSPF, no del área.

Es un número de 32 bits con formato de dirección IP (por ejemplo, 1.1.1.1 o 192.168.255.1),
pero no tiene por qué ser una IP real o asignada a ninguna interfaz.

Se puede configurar manualmente en un process ID. Usaremos el process ID 10 como ejemplo:

```
R1(config)#router ospf 10
R1(config-router)#router-id 1.1.1.1
```
<note>
El process ID es un número entre 1 y 65535 que cada router usa internamente para su base de datos. Para comunicarse con otros routers, lo que se usa es el área 0. El process ID no tiene por qué coincidir entre routers del mismo área.
</note>
<note>
No se puede configurar mediante `router ospf <processID>` sin tener ninguna interfaz configurada, ya que el packet tracer muestra error.
</note>


Si el RID no está configurado, usa la IP más alta de una interfaz Loopback (si existe).

Si no hay loopback, usa la IP más alta de las interfaces activas.

<note>
Si el RID cambia, hay que reiniciar el proceso OSPF (`clear ip ospf process`) para que se aplique.
</note>

Cuando hay varios routers en el mismo área, el que tenga el RID más alto, toma el rol de router designado (DR) y el siguiente menos alto es el backup del router designado (BDR). El resto de routers toman el rol DROTHER. El DR se encarga de recoger las rutas y, para no cargar el tráfico, es el que se encarga de repartir las rutas a los routers del mismo área. Si por algún motivo el DR no está disponible, el BDR se convierte en DR, y el DROTHER con RID siguiente se convierte en BDR.

OSPF tiene 2 modos: área única y multiárea.




== OSPF de área única ==

Hay 2 formas de configurar el enrutamiento: usando `ip ospf <processID> area <area>` en cada interfaz, o definiendo las rutas explícitamente, de forma muy parecida a eigrp.

En cada interfaz:

```
R1(config)#interface GigabitEthernet 0/0/0 
R1(config-if)#ip address 192.168.10.1 255.255.255.0
R1(config-if)#ip ospf 10 area 0
R1(config-if)#no shutdown
R1(config-if)#interface GigabitEthernet 0/0/1 
R1(config-if)#ip address 192.168.11.1 255.255.255.0
R1(config-if)#no shutdown
R1(config-if)#ip ospf 10 area 0 
```

Opcionalmente, y siempre después de haber asignado direciones ip, asignamos el router-id:

```
R1(config)#router ospf 10
R1(config-router)#router-id 1.1.1.1
```


La otra forma, publicando manualmente las rutas, con wildmask y área:
```
R1(config)#router ospf 10
R1(config-router)#router-id 1.1.1.1
R1(config-router)#network 192.168.10.0 0.0.0.255 area 0
R1(config-router)#network 192.168.11.0 0.0.0.255 area 0
R1(config-router)#exit
```

<note>
Se puede usar una contraseña para proteger la distribución de las rutas. Para ello, en cada interfaz de cada router, hay que poner:
```
Router(config-if)#ip ospf message-digest-key 1 md5 clavesecreta
Router(config-if)#ip ospf authentication message-digest
```

donde //clavesecreta// es la clave en claro. No hay forma de ocultarla después al ver la configuración.
</note>

== OSPF multiárea ==

Mientras que en redes pequeñas es más sencillo usar un area única, cuando el tamaño de las redes crece, se hace más necesario, y a veces imprescindible, usar más de un área. Esto es por varios motivos:
  * Los recursos de un único router sin limitados, y muchas rutas pueden llegar a agotar la memoria
  * El tiempo empleado en usar el algoritmo SPF cuando hay un cambio, puede hacer que ralentice la operativa o que el propio router se sature.
  * El router recibe un número de peticiones LSA que no puede asumir.

Por ello, se establece un mecanismo donde haya varias áreas, y al dividir el trabajo, la carga y las responsabilidades, se reduce la cantidad de información que tiene que manejar cada router, y el resultado es una mayor eficacia.

En general, la implementación es muy parecida a la de área única. La diferencia principal es que se establece un área 0, que hace de intermediario entre todas las áreas.

<note>Si no hay un área 0, no habrá comunicación de enrutamiento entre el resto de áreas.
</note>




==== Servidor DHCP ====

Para configurar un router como servidor DHCP, el procedimiento consta de los siguientes pasos:
  - Configurar la interfaz (es decir, que tenga su ip) por la que se va a recibir una petición DHCPREQUEST.
  - Definir los rangos de exclusión. Esto se hace con `ip dhcp excluded-address <iporigen> [<ipfinal>]`.
  - Definir un pool con nombre. Dentro del pool definimos:
    - La red que cubre
    - El gateway de la red
    - Opcionalmente, el servidor dns.
    - Existen muchas opciones avanzadas, opcionales también.


```
Router(config)#ip dhcp excluded-address 192.168.0.1 192.168.0.10

Router(config)#ip dhcp pool POOL
Router(dhcp-config)#network 192.168.0.0 255.255.255.0
Router(dhcp-config)#default-router 192.168.0.1
Router(dhcp-config)#dns-server 192.168.1.5
```

Podemos definir múltiples `pool`. Una vez definidos, ya entran automáticamente a funcionar, sin aplicar a ninguna interfaz.

=== DHCP Relay ===


También se puede hacer DHCP relay a otro servidor DHCP que está en otro sitio. El servidor DHCP tiene que tener previamente configurados los pool correspondientes a las redes que va a recibir peticiones. En este caso, además de tener conexión con ese servidor, hay que hacer dos cosas:
  - Averiguar la dirección IP del servidor DHCP para cada red a la que esté conectada el router.
  - En la interfaz o subinterfaz que tiene la ip de gateway y que sirve a la red, poner una línea `ip helper-address <ipservidor>`, poniendo la ip del servidor dhcp.

<note>**IMPORTANTE:** Por defecto, una ACL impide que funcione el servicio DHCP, que funciona por udp y los puertos 67 y 68. Para evitar esto, hay que poner dos líneas:
```
permit udp <origen> <destino> eq 67
permit udp <origen> <destino> eq 68
```
</note>

==== NAT ====

NAT (Network Address Translation) es una técnica que consiste en reescribir o traducir una dirección (a veces también el puerto) en otra con la intención de que la dirección reescrita esté al alcance del siguiente salto. De esta forma, se permite comunicar redes sin tener que habilitar todas las rutas en todos los sentidos.

En este proceso, se distinguen cuatro conceptos:

|Inside Local (IL)|La dirección IP privada (RFC 1918) asignada a un host dentro de la red local (inside) que inicia la comunicación. Esta es la dirección real del dispositivo antes de cualquier traducción.|
|Inside Global (IG)|La dirección IP pública que representa al host de la red interna (inside) cuando se comunica con la red externa (Internet). Es la dirección después de que el router ha realizado la traducción.|
|Outside Local (OL)|La dirección IP del host de destino en la red externa (outside) vista por el host interno. En la práctica, suele ser la dirección IP real (pública) del host de destino.|
|Outside Global (OG)|La dirección IP del host de destino en la red externa (outside) vista por el resto de la red global. En la mayoría de los casos, la Outside Local y la Outside Global son idénticas (la IP pública del servidor web), ya que el dispositivo externo no necesita ser traducido por el NAT de su red.|

Desde el punto de vista de Cisco, hay tres tipo de NAT: estático, dinámico y con sobrecarga.

En un router, de forma general, hay que configurar el interfaz que comunica la red interna con `ip nat inside`, para traducir el tráfico que le llega desde el interior con destino al exterior. Por otro lado, el interfaz que comunica con el exterior, hay que configurarlo con `ip nat outside`, para recoger el tráfico que proviene del exterior y hacer la traducción que coresponda, así como enviar el tráfico traducido hacia el exterior. El interfaz con `ip nat inside` gestiona las "Local", y el interfaz con `ip nat outside` gestiona las "Global", según su tabla de direcciones NAT.


Se puede ver la tabla de traducciones con `[do] show ip nat translation`.


=== NAT estático ===

El NAT estático está diseñado principalmente para el mapeo bidireccional entre una dirección IP privada y una IP pública.

Su uso más común es recibir tráfico del exterior. El tráfico que llega a una IP pública específica (IG) se traduce a una IP privada interna fija (IL), generalmente para publicar un servidor o servicio.

El mismo host interno, al generar tráfico saliente al exterior, utiliza su IP privada (IL), y el router la traduce a la misma IP pública fija (IG).


**IMPORTANTE**: Normalmente, el router nunca tendrá asignadas ni la IL ni la IG, pero sí tiene que hacer referencia a ambas para la tabla de NAT.


Ejemplo: Un servidor en la red que tiene la ip 192.168.10.254 (IL), se le quiere asociar con la ip pública 209.165.201.5 (IG). Para ello, en el router R2, que es el que hace de frontera (border), y que tiene enrutamiento hacia el servidor (aunque esté en otra subred). En la interfaz de R2 que comunica con el interior, tiene que configurarse con el siguiente salto, que será un dispositivo del ISP.

```
R2(config)# ip nat inside source static 192.168.10.254 209.165.201.5
R2(config)#
R2(config)# interface serial 0/1/0
R2(config-if)# ip address 192.168.1.2 255.255.255.252
R2(config-if)# ip nat inside
R2(config-if)# exit
R2(config)# interface serial 0/1/1
R2(config-if)# ip address 209.165.200.1 255.255.255.252
R2(config-if)# ip nat outside
```

También se puede usar el NAT estático para redirigir de una IP pública y un puerto a una IP privada y un puerto privado (conocido también como //Port Forwarding//). El formato es:

```
ip nat inside source static tcp <IP_privada> <puerto_interno> <IP_pública> <puerto_externo>
```

Ejemplo:
```
R2(config)#ip nat inside source static tcp 192.168.1.100 80 203.0.113.5 8080
```
Esto redirige el tráfico que llega al puerto 8080 de la IP pública 203.0.113.5 hacia el puerto 80 del servidor interno 192.168.1.100. Pero para ello, hay que configurar el NAT en las interfaces:

```
R2(config)#interface GigabitEthernet0/0
R2(config-if)#ip address 192.168.1.1 255.255.255.0
R2(config-if)#ip nat inside
R2(config-if)#exit
R2(config)#interface GigabitEthernet0/1
R2(config-if)#ip address 203.0.113.1 255.255.255.0
R2(config-if)#ip nat outside
```

=== NAT dinámico ===

El NAT dinámico es básicamente igual que el estático, pero en lugar de tener una única ip pública, se tiene un pool de direcciones ip públicas. La diferencia es que está orientado al tráfico de salida más que el de entrada. Se asigna una ip del pool (mientras haya libres), y cuando éstas se agotan, no hay nuevas asignaciones hasta que haya un timeout por inactividad en alguna, y libere esa asignación.

Para la configuración, hay que definir el pool de ips públicas, y el pool o lista de ips locales. Luego se hace el mismo NAT, con la diferencia de que en lugar de hacer una asignación estática (`static`) se hace al pool definido.


Ejemplo: Hay un pool de direciones asignadas por el ISP que van desde la 209.165.200.226 hasta la 209.165.200.240, para proporcionar salida al exterior a un rango de equipos.

```
R2(config)# ip nat pool NAT-POOL1 209.165.200.225 209.165.200.254 netmask 255.255.255.224
R2(config)# access-list 1 permit 192.168.0.0 0.0.0.255
R2(config)# ip nat inside source list 1 pool NAT-POOL1
R2(config)# interface serial 0/1/0
R2(config-if)# ip nat inside
R2(config-if)# interface serial 0/1/1
R2(config-if)# ip nat outside
```



=== PAT o NAT con sobrecarga ===

El PAT (Port Address Translation) se utiliza para eliminar la restricción que supone usar una asignación 1:1 entre equipo e ip pública. En este caso, al llegar al router, éste traduce la dirección a origen junto a un puerto, de tal manera que esa combinación, junto con lo mismo para una ip pública, permite tener más "canales" de comunicación.

El escenario más sencillo es que el border traduzca las direcciones al salir por su interfaz exterior. Esto hace que nos despreocupemos de la IG, y nos centremos en la red local. Al final, después de la lista, añadimos el interfaz y la palabra clave `overload`.


```
R2(config)#ip nat inside source list 1 interface serial 0/1/1 overload
R2(config)#access-list 1 permit 192.168.0.0 0.0.255.255
R2(config)#interface serial0/1/0
R2(config-if)#ip nat inside
R2(config-if)#exit
R2(config)#interface Serial0/1/1
R2(config-if)#ip nat outside
```

Otro escenario, en lugar de tener una única ip, es tener un pool de ips. Aplicamos lo ya visto en el dinámico y aplicamos `overload`:

```
R2(config)#ip nat pool NAT-POOL1 209.165.200.225 209.165.200.254 netmask 255.255.255.224
R2(config)#access-list 1 permit 192.168.0.0 0.0.255.255
R2(config)#ip nat inside source list 1 NAT-POOL1 overload
R2(config)#interface serial0/1/0
R2(config-if)#ip nat inside
R2(config-if)#exit
R2(config)#interface Serial0/1/1
R2(config-if)#ip nat outside
```


===== Switches =====

Usamos por defecto el modelo 2960, que tiene dos interfaces gigabit y 24 fast ethernet.

<note>
**IMPORTANTE**: Es en los switches donde se definen las VLAN, mientras que en los routers, si acaso, se define la encapsulación, que debe coincidir con la VLAN.
</note>

Tenemos el modo comando con `enable`. Ahí tenemos múltiples comandos, siendo quizá el más interesante `show vlan brief`:

```
Switch#show vlan brief 

VLAN Name                             Status    Ports
---- -------------------------------- --------- -------------------------------
1    default                          active    Fa0/1, Fa0/2, Fa0/3, Fa0/4
                                                Fa0/5, Fa0/6, Fa0/7, Fa0/8
                                                Fa0/9, Fa0/10, Fa0/11, Fa0/12
                                                Fa0/13, Fa0/14, Fa0/15, Fa0/16
                                                Fa0/17, Fa0/18, Fa0/19, Fa0/20
                                                Fa0/21, Fa0/22, Fa0/23, Fa0/24
                                                Gig0/1, Gig0/2
```

Al igual que con los router, entramos a configurar con `configure terminal`.

==== Crear una VLAN ====

Para crear una VLAN, simplemente usamos el comando `vlan <num>`, donde `<num>` es un número entre 1 y 4094:

```
Switch(config)#vlan 10
```

Opcionalmente, podemos darle un nombre:

```
Switch(config)#vlan 10
Switch(config-vlan)#name VENTAS
```

Si no ponemos nombre, le asigna el número de VLAN con 4 dígitos, precedido de `VLAN`. En el ejemplo, sería `VLAN0010`.

En modo configuración, podemos entrar en una interfaz, o en un rango:
```
Switch(config)#int gig0/1
Switch(config-if)#
Switch(config-if)#exit
Switch(config)#int range gig0/1-2
Switch(config-if-range)#
```

Después, configuramos la vlan correspondiente, o el modo trunk.

==== Modo para una única VLAN ====

Para configurar una interfaz o rango para que pueda acceder una única vlan, una vez dentro, tenemos que combinar dos comandos:

```
Switch(config)#int range fa0/1-24
Switch(config-if-range)#switchport mode access
Switch(config-if-range)#switchport access vlan 10
```

Cualquier otro escenario donde tenga que pasar tráfico de más de una VLAN por una interfaz, hay que poner la interfaz en modo trunk.


==== Modo trunk ====

La configuración básica de una interfaz en modo trunk es muy sencilla, ya que con una línea es suficiente:

```
Switch(config)#int range gig0/1-2
Switch(config-if-range)#switchport mode trunk
```

<note>
El modo trunk no significa "que pase todo", sino "que pasen todas las VLAN definidas en la base de datos". Por ello, si tiene que pasar la VLAN 10 y no está definida en el switch, aunque el interfaz esté en modo trunk, no pasará. Hay que crear la VLAN con `vlan 10`, y ya está.
</note>

También podemos restringir las VLAN que pueden pasar por un interfaz en modo trunk:

```
Switch(config)#int g1/0/22
Switch(config-if)#switchport mode trunk
Switch(config-if)#switchport trunk allowed vlan 1,99
```

En este caso, sólo pasarán las VLAN 1 y 99, y la 10 (si existe), no pasará.


=== Trunk native ===

Por último, hay casos donde hay que etiquetar una interfaz trunk con una VLAN nativa ("native"). Si en el extremo del interfaz hay un dispositivo que, por sí mismo, no etiqueta el tráfico, este tráfico llegará a la interfaz y usará la vlan nativa por defecto, que es la 1, en lugar de la correspondiente a la ip del dispositivo. Para conseguir que ese dispositivo que no etiqueta, cuando envíe tráfico por el switch, este tráfico salga con la etiqueta correspondiente a la vlan (por ejemplo, la 20), hay que usar la siguiente técnica:

```
Switch(config)#int g1/0/22
Switch(config-if)#switchport mode trunk
Switch(config-if)#switchport trunk native vlan 20
```

De esta forma, le llega todo el tráfico. Si no tiene etiqueta, se asigna a la vlan 20.


==== VTP ====

El modo VTP (VLAN Trunking Protocol) de un switch permite aislar o sincronizar la base de datos de VLAN entre switches. Se puede averiguar el modo de VTP con `show vtp status`. Hay 3 modos:
  * `server`: en este modo, que es el predeterminado, se pueden configurar las vlan para que luego un `client` las herede.
  * `client`: en este modo, no se pueden editar las vlan, sino que se sincronizan de un `server` con el número de revisión más alto.
  * `transparent`: este modo es independiente, donde se pueden editar las vlan y no se sincronizan de un `server`.

Se configura el modo con `vtp mode server|client|transparent`. Se configura el dominio con `vtp domain <dominio>`. El dominio por defecto viene vacío. Las reglas son:

  * Si un cliente no tiene dominio, sincroniza el dominio del server con la revisión más alta.
  * Un cliente sincroniza la base de datos con el server que tenga el mismo dominio y la revisión más alta.

<note danger>Si se reutiliza un switch antiguo que tiene un número de revisión alto, puede borrar toda la configuración VLAN que tengan los `client` que tengan el mismo dominio.</note>

==== Switch de capa 3 (L3) ====

Lo que hemos visto es para switch de capa 2, donde nos limitamos a esa capa (direcciones MAC) y no usamos enrutamiento a nivel ip (capa 3). Para esto, existen los switches L3, que combinan el número elevado de puertos (para poder conectar muchos dispositivos) con las capacidades de enrutamiento, combinando un switch "tradicional" con un router "tradicional". Esto quiere decir que las funcionalidades básicas de un router (enrutamiento, dhcp, etc) las puede realizar exactamente de la misma forma que un router.

Para proporcionar enrutamiento entre VLAN, los switches L3 utilizan
SVIs. Los SVIs se configuran utilizando el mismo comando `interface
vlan vlan-id` utilizado para crear el SVI de administración en un switch de capa
2. Se debe crear un SVI de Capa 3 para cada una de las VLAN enrutables.

En principio, la gestión de los puertos a nivel de capa 2 no supone ninguna diferencia respecto a un switch de capa 2. La diferencia surge cuando configuramos el switch L3 como un router. En packet tracer hay 2 modelos: el 3560-24PS y el 3650-24PS. La diferencia es que el primero tiene la mayoría de puertos FastEthernet, mientras que el segundo tiene mayoría de puertos GigabitEthernet (aunque siempre hay al menos un par de puertos gigabit).

El switch L3 tiene por defecto la misma configuración que uno L2, es decir, que por defecto asume que los puertos van a ser "tipo switch". Si queremos asignar una dirección ip a un puerto, procederemos de la siguiente forma:

```
Sw3(config)#int g0/1
Sw3(config-if)#no switchport
Sw3(config-if)#ip address 192.168.10.1 255.255.255.0
...
```

Y ya ese interfaz está en "modo router".

=== VLAN en L3 ===


Aunque la primera parte es igual que en L2 (es decir, tener todas las VLAN definidas en la base de datos del switch), hay diferencias en la gestión de VLAN. Si queremos asignar un ip al switch para que gestione la VLAN 10, se la asignamos al SVI:

```
Sw3(config)#int vlan 10
Sw3(config-if)#no shutdown
Sw3(config-if)#ip address 192.168.10.1 255.255.255.0
...
```

Aquí podemos definir un enrutado `ospf` o cualquier otra cosa relacionada con el enrutamiento que se hace en el interfaz de un router.

<note warning>
En el packet tracer, se puede usar `ip ospf X area Y` en el SVI, pero no se persisten los cambios. Por ello, para que sean permanentes las redes definidas en el SVI, hay que poner las `network <wildmask>` correspondientes en la sección `router ospf X`.
</note>

<note>Una vez definidas todas las funcionalidades de un router, hay que usar el comando `ip routing` para que entren en funcionamiento.
</note>

===== Listas de control de acceso (ACL) =====

Las listas de control de acceso (ACL) sirven para permitir o denegar el tráfico por una interfaz de un dispositivo. Valen tanto para routers como para switches.

Por defecto, sin ninguna ACL todo el tráfico está permitido. Sin embargo, cuando se crea una ACL, al final de la misma, lleva implícita una denegación de todo el tráfico que pase por la interfaz en que se aplica, por lo que previamente hay que combinar todas las reglas para que el resultado sea el esperado.

Las ACL pueden tener un número o un nombre. Cada ACL es un conjunto de ACEs (Access Control Entry) que permiten (`permit`) o deniegan (`deny`). También pueden tener un comentario (`remark`). Cada ACE se evalúa en el orden que se ha introducido, y cuando una ACE se cumple, el resto se ignoran. La ACE usa una wildmask para indicar la máscara de subred, y también puede usar la palabra `host` para indicar una única ip en lugar de la wildmask `0.0.0.0`.


Las ACL numéricas pueden crearse de dos formas:
  - Líneas completas con el número. Ej: `access-list X <permit|deny> <args>`.
  - Una línea `ip access-list <tipo> <num|nombre>`, y después de pulsar enter, se entra en modo configuración de la ACL. Ahí se ponen las claúsulas `permit` o `deny` hasta que se pone `exit` para indicar que ya no hay mas ACEs y terminar la ACL. **IMPORTANTE**: En caso de usar un nombre, éste es sensible a mayúsculas.


==== ACL estándar ====

Una ACL estándar puede usarse cuando únicamente depende del origen.

Una ACL estándar númerica tiene el rango de 1 a 99 o de 1300 a 1999. Ejemplo:
```
Switch(config)#access-list 10 permit 192.168.10.0 0.0.0.255
Switch(config)#
```
o

```
Switch(config)#ip access-list standard 10
Switch(config-std-nacl)#permit 192.168.10.0 0.0.0.255
Switch(config-std-nacl)#exit
Switch(config)#
```

También se puede crear una ACL estándar con un nombre con `ip access-list standard <nombre>`. El resto es igual que con un número.

==== ACL extendida ====

Una ACL extendida permite tener ACEs complejas, con origen, destino, protocolo, puerto, etc. En su formato numérico, tiene el rango de 100 a 199, o de 2000 a 2699.

```
Router(config)#access-list 110 permit ...
```

o lo que es lo mismo

```
Router(config)#ip access-list extended 110 
Router(config-ext-nacl)#permit ...
Router(config-ext-nacl)#exit
```

Para crear una extendida con nombre, es `ip access-list extended <nombre>`.

La sintaxis de cada línea es:

```
permit|deny <proto> <origen> <destino> [eq <puerto>|established]
```

Donde:
  * <proto>: es el protocolo. Puede ser:
    * `udp`: para udp
    * `tcp`: para tcp
    * `ip`: para cualquier protocolo
    * `icmp`: para icmp.
    * etc
  * <origen>: origen de la petición. Puede ser:
    * `any`: para cualquier origen
    * `host` seguido de la ip, la ip de origen
    * <rango_red> <wildmask> para un rango de red
  * <destino>: destino de la petición. Tiene las mismas reglas que <origen>.
  * <puerto>: el puerto numérico o algún alias como `www` para el 80. El protocolo tiene que ser tcp o udp.
  * `established`. Para protocolo `tcp` o `udp`. Permite que el tráfico interno salga de la red privada interna y permite que el tráfico de respuesta devuelta entre en la red privada interna. Se deniega el tráfico TCP generado por un host externo e intentando comunicarse con un host interno.


==== Aplicación de ACL ====


Las ACL se definen a nivel global, pero no entran en funcionamiento hasta que se aplican a un interfaz. Esto permite tener múltiples ACLs inactivas, para pruebas. Las ACL existentes se pueden ver con `[do] show access-lists`, y también con la configuración global.

Para aplicar una ACL, tenemos que entrar primero en la interfaz que vaya a aplicarla.:

```
Router(config)#int gig0/0
Router(config-if)#ip access-group 110 in
Router(config-if)#exit
Router(config)#
```

Usamos `ip access-group <nombre|num> [in|out]`, donde se indica si se va a aplicar con tráfico entrante (`in`) o saliente (`out`). Lo normal es a la entrada.
<note>
**IMPORTANTE**: Sólo puede haber una ACL por interfaz y sentido (`in`|`out`)
</note>
<note>
Al aplicarla, el nombre de la ACL debe coincidir **EXACTAMENTE** en mayúsculas y minúsculas. Si se pone un nombre distinto, no sale ningún error, lo que puede hacer creer que la ACL existe.
</note>

===== Telefonía IP =====

Para usar la telefonía IP, tenemos que tener en cuenta 2 prerrequisitos:
  - Hay que tener una VLAN dedicada para la telefonía de voz. Vamos a elegir la VLAN 2.
  - Hay que usar el router 8211 para configurar la telefonía, que es el único dentro de packet tracer que soporta los comandos de telefonía.


Vamos a configurar primero el switch:
  - Configuramos como trunk el interfaz por el que llega el router, porque también va a servir a la red.
  - Configuramos los puertos donde vayan los terminales con la vlan de voz.

```
Switch(config)#int gig0/1
Switch(config-if)#switchport mode trunk
Switch(config-if)#int range fa0/1-3
Switch(config-if)#switchport voice vlan 2
```

Opcionalmente, podemos dar nombre a la vlan 2.

Vamos a configurar el router. Lo primero, vamos a configurarlo como servidor DHCP para la red de telefonía.
```
Router(config)#ip dhcp excluded-address 192.168.0.1
Router(config)#ip dhcp pool VOZ
Router(dhcp-config)#network 192.168.0.0 255.255.255.0
Router(dhcp-config)#default-router 192.168.0.1
Router(dhcp-config)#option 150 ip 192.168.0.1
Router(dhcp-config)#exit
```

Asignamos la ip para la vlan 2:
```
Router(config)#int fa0/0
Router(config-if)#no ip address
Router(config-if)#no shutdown
Router(config-if)#int fa0/0.2
Router(config-if)#encapsulation dot1Q 2
Router(config-if)#ip address 192.168.0.1 255.255.255.0
Router(config-if)#exit
```

Hasta ahora, nada nuevo que no pudiéramos hacer en cualquier otro router. Ahora tenemos que configurar:
  * El número máximo de números a usar (`max-dn`)
  * El número máximo de terminales telefónicos (`max-ephones`)
  * Puerto e ip origen para las llamadas
  * Asignar automáticamente las direcciones ip

Vamos a usar 2 terminales de ejemplo:

```
Router(config)#telephony-service
Router(config-telephony)#max-dn 2
Router(config-telephony)#max-ephones 2
Router(config-telephony)#ip source-address 192.168.0.1 port 2000
Router(config-telephony)#auto assign 1 to 2
Router(config-telephony)#exit
```

Ahora tenemos que configurar las extensiones de los terminales. Vamos a poner que son la 501 y la 502.

```
Router(config)#ephone-dn 1
Router(config-ephone-dn)#number 501
Router(config-ephone-dn)#ephone-dn 2
Router(config-ephone-dn)#number 502
Router(config-ephone-dn)#exit
Router(config)#
```

Ya está. Para probarlo, tenemos que conectar dos `IP Phone` a las bocas del switch que tengan la vlan de voz. Hay que poner el cable de corriente, esperar a que cojan ip y salga el número de la extensión en el terminal. Entonces podemos descolgar y marcar el número del otro terminal, y ver que parpadea.

==== Comunicación entre centralitas ====

Lo anterior vale para una centralita que tiene su rango de números, pero también podemos comunicar dos centralitas diferentes. Una vez configurada cada centralita individualmente, hay que añadir una sección en cada router para poder comunicarse con otra centralita. Hay que definir los siguientes parámetros:
  * Las extensiones que gestiona la otra centralita. Esto se hace con `destination-pattern` seguido de la plantilla, donde hay que poner un punto (`.`) por cada carácter comodín que represente las extensiones de la otra centralita. El valor `2...` indica que empiezan por 2 y pueden tener cualquier dígito, es decir, de 2000 a 2999.
  * La dirección ip de la centralita, con `session target ipv4:ip`.
  * Se usa el codec g711ulaw, pero no todas las versiones de firmware lo soportan.

Ejemplo de dos centralitas. La centralita del router 1 (10.10.10.1) gestiona las extensiones de 1000 a 1999, y la del router 2 (10.10.10.2), de 2000 a 2999.

ROUTER 1:
```
Router1(config)#dial-peer voice 1 voip
Router1(config-dial-peer)#destination-pattern 2...
Router1(config-dial-peer)#session target ipv4:10.10.10.2
Router1(config-dial-peer)#codec g711ulaw
```

ROUTER 2
```
Router2(config)#dial-peer voice 1 voip
Router2(config-dial-peer)#destination-pattern 1...
Router2(config-dial-peer)#session target ipv4:10.10.10.1
Router2(config-dial-peer)#codec g711ulaw
```

===== VPN =====

Dentro de lo que soporta packet tracer, tenemos dos opciones:

  - Cifrado de la conexión directamente en el interfaz.
  - Cifrado de los datos que viajan en la conexión a través de un túnel.

Las dos opciones tienen en común el cifrado mediante IPSec, pero difieren en la estructura, su complejidad y facilidad para gestionarlas. Por el uso que se hace de ambas en la realidad, además de permitir no redundar en explicaciones, las veremos en orden inverso.

==== Conexión a través de túnel ====

La conexión a través de túnel exige que previamente esté funcionando la conexión WAN, y sobre este funcionamiento, sin supeditarlo, se añade una conexión punto a punto con el otro extremo. Simplemente necesitamos asignar una red /30 a la conexión punto a punto en un rango privado, y establecer la comunicación a través de esta conexión. Esta conexión se genera a través de una interfaz virtual llamada `tunnel X`, y que puede manejarse básicamente como cualquier interfaz.

En un extremo:
```
interface Tunnel0
 ip address 10.10.10.2 255.255.255.252
 tunnel source 64.100.13.2
 tunnel destination 209.165.118.2
 tunnel mode gre ip
```

y en el otro
```
interface Tunnel0
 ip address 10.10.10.1 255.255.255.252
 tunnel source 209.165.118.2
 tunnel destination 64.100.13.2
 tunnel mode gre ip
```

<note>En `tunnel source` se puede sustituir la ip del interfaz por el nombre de la interfaz.</note>

Después, se puede usar una ruta estática apuntando a la red remota y el otro extremo del túnel como gateway:

En el primer extremo (siendo la red remota 192.168.30.0/24):

```
ip route 192.168.30.0 255.255.255.0 10.10.10.1
```

Y en el segundo, para acceder a la 192.168.10.0/24:

```
ip route 192.168.10.0 255.255.255.0 10.10.10.2
```

Una vez hecho esto, desde cualquiera de las redes de ambos lados se puede acceder al otro lado.

<note>**IMPORTANTE**: Principalmente de cara a packet tracer, la LAN al interior de cada extremo NO puede publicarse por OSPF, eigrp, etc.</note>

==== Cifrado IPSec ====

El cifrado IPSec requiere que el router (básicamente la serie 29xx) pueda incorporar el módulo de seguridad `securityk9`. Esto podemos verlo con el comando `show version` en modo admin:


```
R1#show version
----------------------------------------------------------------
Technology	Technology-package 		Technology-package
 			Current		Type 		Next reboot
-----------------------------------------------------------------
ipbase		ipbasek9	Permanent	ipbasek9
security	None		None		None
uc 			None 		None 		None
data 		None 		None 		None
```

Para activar el módulo hay que seguir estos pasos:

```
R1(config)# license boot module c2900 technology-package securityk9
R1(config)# end
R1# copy running-config startup-config
R1# reload
```

Después de reiniciar, volvemos a comprobar con `show version`.

```
R1#show version
----------------------------------------------------------------
Technology	Technology-package 		Technology-package
 		Current		Type 		Next reboot
-----------------------------------------------------------------
ipbase		ipbasek9	Permanent	ipbasek9
security	securityk9 	Evaluation 	securityk9
uc 		None 		None 		None
data 		None 		None 		None
```

Estos pasos hay que repetirlos con cada router que vaya a usar el cifrado.

Ahora, tenemos los routers R1 y R2.

Primero tenemos que crear una ACL para el "tráfico interesante" (el que será cifrado):

```
R1(config)# access-list 110 permit ip 192.168.10.0 0.0.0.255 192.168.30.0 0.0.0.255
```

```
R2(config)# access-list 110 permit ip 192.168.30.0 0.0.0.255 192.168.10.0 0.0.0.255
```

A continuación, los parámetros en fase 1 para cada router:

```
R1(config)# crypto isakmp policy 10
R1(config-isakmp)# encryption aes
R1(config-isakmp)# authentication pre-share
R1(config-isakmp)# group 2
R1(config-isakmp)# exit
R1(config)# crypto isakmp key cisco address 209.165.118.2
```