No es ninguna sorpresa que en el mundo tecnológico actual, una de las empresas clave sea Google y si bloqueamos por accidente una IP suya en el firewall de nuestro servidor, puede convertirse en un problema.
¿Pero por qué podríamos haber bloqueado una IP de Google? Existen varios motivos, en primer lugar, debemos entender que Google utiliza la misma IP para varios servicios, como Gmail, el proxy de Chrome e incluso el crawler de su buscador.
Por lo tanto, podríamos bloquear la IP del crawler de forma automática debido a un uso abusivo de recursos, donde esto podría afectar, al menos en parte, la entrega de correos desde Gmail o dificultar la navegación en dispositivos Android.
Esto se debe a que Android utiliza servidores de Google como proxy, por eso si bloqueamos el crawler, también podríamos estar bloqueando a usuarios reales, donde además los errores de inicio de sesión de los usuarios en nuestro sistema podrían llevar al bloqueo de la IP de ese proxy, lo que dejaría a muchos usuarios que utilizan la misma IP sin poder acceder a nuestro sitio en consecuencia esto afectaría a Gmail y también generaría problemas de SEO al bloquear el crawler.
Otro caso es cuando se utiliza Gmail como cliente de correo de un dominio, con solo unos pocos intentos fallidos de inicio de sesión, podríamos estar bloqueando no una, sino varias IP de Google sin siquiera darnos cuenta, lo que agrava el problema y afectando la navegación y el correo de cientos de usuarios.
Google utiliza cientos de miles de IP, por lo que es fácil pasar por alto el hecho de que hemos bloqueado un par de ellas, pueden ocurrir errores de los que ni siquiera nos enteremos, al menos no a corto plazo, podríamos tener algun reporte aislado y por tanto, difícil de diagnosticar, todo lo que resultaría en la pérdida de visitas, correos electrónicos y posicionamiento, entre otros.
Google no publica la lista completa de IP, por lo que no podemos saber exactamente cuál se utiliza para cada servicio, excepto en el caso del correo. ¿Por qué? Porque cada IP que envía un correo debe estar registrada en su registro SPF y como sabemos que utiliza las mismas IP para varios servicios podemos a partir del SPF revisar si tenemos bloqueada alguna IP de Google, tal vez no podamos estás seguros que chequeamos todas, pero al menos es un comienzo.
¿Por dónde arrancamos? El primer paso es mediante el TXT/SPF del dominio de gmail, detrás de algo tan simple como el siguiente registro DNS se esconde gran parte de la infraestructura de Google o al menos los rangos de IP que tiene asignado Google:
v=spf1 redirect=_spf.google.com"
Mediante este registro podemos listar todo el rango de IPs utilizados por gmail y que comparte con otros servicios, casi 330.000 al momento de escribir este artículo
Dependencias
Para usar el script lo primero es tener instalado sipcalc, dependiendo de nuestra distro lo podemos instalar de la siguiente manera:
yum install sipcalc apt-get install sipcalc
El código
Luego el script podemos guardarlo un archivo de texto, por ejemplo /usr/sbin/googleips y damos permisos de ejecución
chmod +x /usr/sbin/googleips
El contenido del script es el siguiente:
#!/bin/bash
output=$(nslookup -q=TXT _spf.google.com 8.8.8.8) # Ejecutar el comando nslookup y guardar la salida en una variable
<h1>Usar grep para buscar todas las cadenas que comienzan con "include:" y luego usar awk para imprimir el segundo campo (la cadena después de "include:")</h1>
lst=$(echo "$output" | grep -o 'include:[^ ]*' | awk -F':' '{print $2}')
while read -r LINE; do
<pre><code>query=$(nslookup -q=TXT $LINE 8.8.8.8 | grep -o 'ip4:[^ ]*' | awk -F':' '{print $2}')
while read -r RANGE; do
if [ ! -z &quot;$RANGE&quot; ]; then
info=$(sipcalc $RANGE)
# Extraer el prefijo de red y la máscara de red del resultado
network=$(echo &quot;$info&quot; | awk '/Network address/ {print $NF}')
netmask=$(echo &quot;$info&quot; | awk '/Network mask \(bits\)/ {print $NF}')
IFS=. read -r a b c d &lt;&lt;&lt; &quot;$network&quot;
network_dec=$((a * 256 ** 3 + b * 256 ** 2 + c * 256 + d))
t=$((32 - netmask))
num_ips=$((2 ** $t))
first_ip_dec=$((network_dec + 1))
# Iterar sobre todas las IPs en el rango e imprimir una por una
for ((i=0; i&lt;num_ips; i++)); do
ip_dec=$((first_ip_dec + i))
a=$((ip_dec / 256 ** 3))
b=$((ip_dec / 256 ** 2 % 256))
c=$((ip_dec / 256 % 256))
d=$((ip_dec % 256))
ip=$(echo &quot;$a.$b.$c.$d&quot;)
##################################
#Desbloqueo desde el firewall
check=$(grep $ip /etc/csf/csf.deny)
if [ ! -z &quot;$check&quot; ]; then
csf -dr $ip
fi
##################################
done
fi
done &lt;&lt;&lt; &quot;$query&quot;
</code></pre>
done <<< "$lst"
Luego pare ejecutarlo
/usr/sbin/googleips
El script esta diseñado para funcionar en servidores con cPanel que utilizan ConfigServer Security and Firewall (CSF) sin embargo puede adaptarse para cualquier firewall, también hay que aclarar que no estoy considerando el chequeo de bloqueo temporal, para mis propósitos solo me interesaba los bloqueos permanentes.
Conclusión
En conclusión, bloquear accidentalmente una IP de Google en el firewall de nuestro servidor puede ocasionar diversos problemas dado que Google utiliza la misma IP para varios servicios, la gran cantidad de IP utilizadas por Google hace que sea fácil pasar por alto el bloqueo de algunas de ellas, lo que puede provocar pérdida de visitas, correos electrónicos y posicionamiento.
Para facilitar este proceso, se puede utilizar este script, aunque el script presentado está diseñado para funcionar en servidores con cPanel que utilizan ConfigServer Security and Firewall (CSF) se puede adaptar para otros firewalls según sea necesario.
Administrador de Sistemas, Programador, Docente y ahora resulta que también Blogger (peor es ser tictoker). Más de 20 años de experiencia en computación atendiendo nabos y resolviendo problemas que sino fuera por estos nabos no habrían ocurrido en primer lugar. Escribo más que nada sobre tecnología y herramientas en general además de algunos artículos con opiniones tan subjetivas como irrelevantes, así que si no te gustan mejor madura.