Conjugando el inexistente verbo "subnetear" (Episodio II)

Hay dos razones por las que he decidido dar continuación al tema de la obtención de sub-redes (subnetear, pues, para los que insisten): una es la creciente cantidad de referencias de búsquedas que he visto desde Google hasta este blog, referentes a "subnetear" o "subredes"; y otra es por pedido específico de una lectora que recientemente pidió que ejemplificara el caso para una red de clase A y otro de clase B. Pues bien, en esta segunda parte explicaré el procedimiento con una red de clase B (posiblemente haga una tercera parte con un ejemplo de clase A, dependiendo del interés).

Ok, partamos de un caso concreto: tenemos la red 150.14.0.0/16. Hay que recordar que el sufijo /16 indica que los bits que representan la máscara de sub-red (que para las redes clase B, antes de ser "subneteadas", siempre es 16 o sea, 2 octetos de 8 bits). En una red de esta clase (clase B), la cantidad de hosts está determinada por los 16 bits restantes de la parte de hosts, por lo que 2¹⁶-2=65,534 hosts posibles... ni hablar del desperdicio de direcciones.

Nuestra máscara /16, que en decimal es lo mismo que 255.255.0.0, se representa en binario de la siguiente manera.

11111111.11111111.00000000.00000000
<-------------red*host------------>

Ahora la parte crucial: ¿cómo comenzar a dividir la red? Simple: debemos partir de una necesidad: ¿qué requerimos?, ¿cierta cantidad de redes o cierta cantidad de direcciones de host por red? Tal vez son ambas cosas. En este ejemplo supondremos que el requerimiento es obtener de la dirección dada por lo menos 500 sub-redes con capacidad para 100 hosts cada una. Vamos a aplicar una sencilla regla para determinar cuántos bits necesitamos pedir (recuerden que no es un préstamo, sino un obsequio :-D):

Como necesitamos que haya 500 sub-redes, necesitamos encontrar un número tal que elevando la base 2 a dicho número nos de la cantidad de sub-redes necesaria, o un poco más. Como ya lo mencioné anteriormente, podemos obtener la potencia por aproximación (al "ojo por ciento") o usando logaritmos. Al final puse una breve explicación de ambos procedimientos, para quien tenga interés.

Lo importante es que obtuvimos el número que buscamos: 9 bits. Con 9 bits podemos obtener 512 combinaciones, lo que nos da alegremente la posibilidad de obtener tranquilamente las 500 sub-redes que nos piden. Ahora sólo nos resta verificar que cada sub-red (de las 512) pueda efectivamente incluir al menos 100 hosts. Para esto basta con obtener la cantidad de combinaciones que nos dan los bits restantes. Recuerda que una dirección IP está formada por 32 bits, y para nuestro caso 16 bits ya están siendo usados por la dirección clase B, y 9 bits son los que acabamos de calcular que necesitamos para obtener las 512 sub-redes. Así que, si la aritmética no nos falla, nos quedan 7 bits para obtener direcciones de hosts (sí, mira: 32-16-9=7). Con 7 posiciones podemos obtener 128 combinaciones de "0" y "1" (bits), y aún restándole las 2 direcciones de ley (al total de direcciones de hosts siempre restamos dos, porque una será la dirección de la sub-red y otra será la dirección de broadcast) nos da un número (126) que nos permite cumplir, también tranquilamente, con el requerimiento de 100 direcciones. Con "bolitas y palitos" (literalmente) queda de la siguiente manera:

11111111.11111111.11111111.10000000
<--red original--><-subred->
<--nueva máscara de subred->
11111111.11111111.11111111.10000000

Y esta nueva máscara de sub-red en decimal sería: 255.255.255.128 (él último octeto sólo tiene un bit 1 en la posición más significativa, y es el número 128).

Lo interesante de este caso es obtener las direcciones de sub-red, pues hay que observar que los bits de sub-redes abarcan dos octetos (9 bits). No se asusten, no pondré las 512. Voy a poner sólo las primeras combinaciones de sub-redes para los dos últimos octetos. Así tenemos:

00000000.00000000 (es decir, 0.0)
00000000.10000000 (es decir, 0.128)
00000001.00000000 (es decir, 1.0)
00000001.10000000 (es decir, 1.128)
00000010.00000000 (es decir, 2.0)
00000010.10000000 (es decir, 2.128)

Quiero hacer notar una cosa: el bit menos significativo de la nueva máscara es precisamente el que está en la posición 128 del cuarto octeto (y, por cierto, 128 es el número que resulta de 2⁷, antes de restarle 2). Si lo que queremos es obtener más rápido las direcciones de red (¿quién no quiere?), puede hacerse con incrementos de 128 (el bit menos significativo de la máscara) en el octeto correspondiente. Sólo que hay un detalle: comenzamos con 0 (cero), luego sumamos 128, pero si sumamos 128 a 128 nos da 256, que no puede expresarse con sólo 8 bits (256=100000000, 9 bits). Lo que hacemos es exactamente lo mismo que con las horas y minutos del reloj: después de 59 minutos se incrementa en 1 la hora, y los minutos quedan en cero; por lo tanto, si tenemos 0.128, el siguiente número NO es 0.256, sino 1.0. ¿Está claro?

Ahora sí, poniendo las direcciones completas, quedarían:

150.14.0.0/25
150.14.0.128/25
150.14.1.0/25
150.14.1.128/25
150.14.2.0/25
150.14.2.128/25
etc.

"¡Espera! ¿De dónde salió el '/25'?". Originalmente teníamos 16 bits en la parte de la red, pero como pedimos 9 bits a la parte de hosts, sumando 16 mas 9 nos quedan ni más ni menos que 25 bits, por eso la nueva máscara es /25.

Muy bien, hasta este momento hemos obtenido las combinaciones de sub-redes. Ahora necesitamos obtener las direcciones de host para cada una de las sub-redes obtenidas. Eso es fácil. Hagámoslo primero en binario. Para cada sub-red vamos a calcular su dirección de broadcast:

00000000.01111111 (este es 0.127)
00000000.11111111 (este es 0.255)
00000001.01111111 (este es 1.127)
00000001.11111111 (este es 1.255)
00000010.01111111 (este es 2.127)
00000010.11111111 (este es 2.255)
etc.

No hay que olvidar la regla: "las direcciones de red tienen todos los bits de host en cero (0), y las direcciones de broadcast tienen todos los bits de host en uno (1)".

De esta manera, obtener los rangos de direcciones de host válidas es mucho más sencillo, pues la primera dirección válida será una más que la dirección de red, y la última dirección válida será una menos que la dirección de broadcast. Sencillo, ¿no?

Para la sub-red 150.14.0.0/25
150.14.0.0/25 (dirección de red)
150.14.0.1/25 (primera dirección de host válida)
150.14.0.126/25 (última dirección de host válida)
150.14.0.127/25 (dirección de broadcast)

Para la sub-red 150.14.0.128/25
150.14.0.128/25 (dirección de red)
150.14.0.129/25 (primera dirección de host válida)
150.14.0.254/25 (última dirección de host válida)
150.14.0.255/25 (dirección de broadcast)

Para la sub-red 150.14.1.0/25
150.14.1.0/25 (dirección de red)
150.14.1.1/25 (primera dirección de host válida)
150.14.1.126/25 (última dirección de host válida)
150.14.1.127/25 (dirección de broadcast)

Si observan, la cantidad de direcciones entre la primera y la última válida son exactamente las 128 que dijimos (aunque sólo necesitamos 100, pero no es lo mismo "desperdiciar" 28 que 15,000).

Y con esto hemos terminado de "subnetear" la red de clase B (¡perdón!, la palabra "subnetear" sigue sin existir en español) sin desperdiciar muchas direcciones.

(Ningún bit salió lastimado durante esta división de sub-redes).
:-D


:wq!

---

Procedimiento usando logaritmos

Me voy a permitir hacer un pequeño recordatorio matemático y pondré el procedimiento para obtener la potencia usando logaritmos:

Sabemos que:
x=bⁿ

y que:
n=log_bx

Si la base (b) fuera 10, obtener n con la calculadora es directo. El problema con una calculadora sería obtener n siendo la base (b) diferente de 10, como en nuestro caso que es 2. Para esto podemos usar la siguiente identidad:

log₂ x=(log x)/(log 2)

De tal manera que la fórmula quedaría:
n=(log x)/(log 2)

Sustituyendo:
n=(log x)/(log 2) = (log 500)/(log 2)
n=2.7/0.3
n=9

Porque:
2⁹=512

El resultado indica que necesitamos 9 bits para obtener las sub-redes. Este procedimiento es el más complejo y requiere usar calculadora o tablas de logaritmos, pero sirve por lo menos para impresionar a más de dos. ;-) Esto me recuerda lo que decía mi maestro de Ecuaciones Diferenciales, cuando nos motivaba a comprar el libro de texto. Él decía: "muchachos: compren el libro. Les aseguro que si no aprenden, por lo menos podrán impresionar a las muchachas con el puro título". :-D ¡Cuánta razón tenía!.

Procedimiento por aproximación

Perdón por haber puesto el procedimiento anterior, pero varios se habían quedado con la duda de cómo se resolvía por logaritmos, si es que realmente se podía. La realidad es que muchos de los que regularmente calculan sub-redes no usan ese procedimiento (y muchos ni siquiera lo conocen). Mejor hagámoslo de la manera tradicional, aunque no se vea tan nerd.

Si lo que necesitamos es un número al que podamos elevar (potencia) el 2 (la base) para que nos dé 500 redes, yéndonos por potencias de 2 podemos encontrarlo relativamente rápido:

n=9, pues
2⁹=512 (porque 2*2*2*2*2*2*2*2*2=512)

El "secreto" es ir multiplicando 2*2, llevando la cuenta de cuántos "2" llevas, hasta que encuentres el número que buscas... ;) Este procedimiento es más práctico que el anterior; tal vez no impresiones a nadie (o ¿quién sabe?), pero al menos llegarás rápido al número que necesitas. ;-)

:wq!

Aka Knaverit

Hace un tiempo me preguntó un amigo si yo tenía algún nickname o seudónimo con el que me conocieran en la red, o si yo era alguien "importante", de esos que colaboran en muchos foros y responden preguntas, o encuentran vulnerabilidades y hacen alarde de ello, etc. La realidad es que no soy nadie importante en la red (al menos eso creo), sólo alguien que gusta de compartir cosas que sabe (algunas sencillas, otras no tanto), o cosas que considera que podrían interesarle a alguien. Y respecto a encontrar vulnerabilidades, sí he encontrado algunas de vez en cuando, y el código de ética de CEH me obliga a no divulgarlas, sino a reportarlas directamente a los responsables de los sitios para que las solucionen, con mi valor agregado: la recomendación de solución. Eso sí me gusta. Ahorita, por ejemplo, estoy haciendo un white hat hacking que una empresa me pidió hacer para ella misma (y mis planes de fin de semana largo se fueron por la borda). Si no fuera por estas pausas que me doy para escribir de vez en cuando, ya hace rato me hubiera ido a dormir.

Para los que tengan curiosidad, en todas mis entradas de mis blogs firmo como Knaverit, aunque no es nada parecido a los seudónimos que usan los hackers o los crackers. Mi seudónimo se remonta a hace muchos años, cuando dibujaba, y es el nombre que le puse al personaje principal de una historieta que nunca vio la luz, mas que de mi lámpara de mi mesa de dibujo. Mis personajes están por ahí en algún lugar entre mis viejos libros, pero Knaverit siempre fue mi favorito, así que esa es la razón por la que firmo así. De hecho si buscan "knaverit" en Google (o sea, si "googlean" :-D) seguramente me van a encontrar a mi (quiero decir, a mis blogs), y también descubrirán que hace tiempo compré unos limpiadores para la pantalla de mi laptop (no me gusta que pongan los dedos en la pantalla), y alguna referencia a un sitio donde próximamente estaré subiendo mis podcasts: así es, dentro de poco comenzaré a subir algunos de mis entradas de los blogs que escribí en 2007, en formato MP3, leídos por el de la voz (o sea por mi, para que me entiendan). Aún no sé si esta forma de comunicar lo que escribo sea de interés para alguien, pero voy a probar. Incluso se me ocurren dos o tres ideas para aprovechar el podcasting... luego les platico.

Sólo una nota aclaratoria, en caso de que ISC2 me investigue ahora que soy candidato a CISSP: No pertenezco a ninguna agrupación de hacking ni oculto mi identidad con otro nombre; sólo me gusta cómo se oye y, como escritor novel me puedo permitir tener algún seudónimo, ¿no?, . :-D

Así que ya lo saben, me llamo Romeo (para los cuates), pero también soy conocido (aka=also known as) como Knaverit... KnaverIT (léase con la pronunciación conocida de: "my name is Bond, James Bond"). :-D

:wq!