Documento Proyecto de Grado

Crawler Para la Deep Web

Cristian Bernardo Acuña Silva

Asesor
Yezid Donoso

Departamento de Ingeniería de Sistemas y Computación

Universidad de los Andes
Bogotá D.C.
Junio de 2024
Contents
0 RESUMEN .................................................................................................................................. 3
1 INTRODUCCION ......................................................................................................................... 3
2 DESCRIPCIÓN GENERAL ............................................................................................................ 4
2.1 Objetivos................................................................................................................................ 4
2.2 Identificación del problema y de su importancia ..................................................................... 4
3 IMPLEMENTACION...................................................................................................................... 4
3.1 Descripción de la implementación ...................................................................................... 4
3.1.1 Crawler....................................................................................................................................... 4
3.1.2 Parámetros.................................................................................................................................. 5
3.1.3 Variables .................................................................................................................................... 6
3.1.4 Ejecución.................................................................................................................................... 6
3.2 Resultados esperados .............................................................................................................. 8
4 VALIDACIÓN ............................................................................................................................. 9
4.1 Verificador .................................................................................................................................... 9
4.2 Parámetros y variables ................................................................................................................ 10
4.3 Ejecución..................................................................................................................................... 10
4.4 Resultados del verificador ........................................................................................................... 11
5 CONCLUSIONES ....................................................................................................................... 12
5.1 Discusión............................................................................................................................... 12
5.2 Trabajo futuro ....................................................................................................................... 12
6 REFERENCIAS .......................................................................................................................... 13

2
0 RESUMEN

Hoy en día la gran mayoría del tránsito de internet que ocurre en el mundo es a través de la world wide
web. Para navegar a través de la web la manera más común y práctica es a través de navegadores tales
como Google o Yahoo!. Sin embargo, estos motores de búsqueda no siempre logran indexar e identificar
los dominios con información valiosa, cuando esto ocurre consideramos que la información se encuentra
en la Deep web. Este proyecto tiene como objetivo proponer un crawler que pueda indexar e identificar
esta información de la Deep web para que los usuarios puedan tener acceso a la mayor cantidad de
información posible.
1 INTRODUCCIÓN

El internet es una red de redes descentralizadas de escala mundial que se usa para diversos fines como
comunicarse, almacenar información y muchos otros. Se estima que más de 4 billones de usuarios
utilizan el internet y se estima que hasta el 2011 la humanidad había producido 600 exabytes de archivos
en el internet1. Uno de los servicios más populares y utilizados del internet es la World Wide Web que
a través de un conjunto de protocolos permiten a los usuarios acceder a los diferentes archivos a
través de navegadores web para consumir los recursos buscados.

A pesar de que lo motores de búsqueda hacen un gran trabajo para mostrarle al usuario contenido web
relacionado a la búsqueda hay mucha información que los motores de búsqueda no pueden percibir,
definiremos este tipo de información Deep web. Uno de las razones por las cuales algunos motores de
búsqueda no ofrecen una buena cantidad o calidad de resultados puede ser por los criterios que usan
para buscar la información, por ejemplo Google indexa las páginas teniendo en cuenta un criterio de
popularidad en vez de un criterio de calidad2. Se estima que la información pública en la Deep web es
de 400 a 550 veces mayor que la encontrada en la World Wide Web. Teniendo lo anterior en cuenta
resulta de gran importancia y utilidad entender cómo funcionan lo motores de búsqueda modernos y
posiblemente crear un crawler que logre encontrar mejor cantidad y calidad de información para que el
usuario la pueda consumir.

El proyecto consiste en desarrollar un crawler que sea capaz de detectar dominios, información y
resultados que no sean detectados por motores de búsqueda populares, como el buscador de Google. El
procedimiento básicamente consiste en partir de una url proporcionada por el usuario, la cual
recursivamente visita todos los subdominios contenidos en determinada página, los cuales son anotados
en una lista de indexación. El crawler tendrá algunos parámetros como tiempo de búsqueda y orden de
recorrido. El parámetro de tiempo de búsqueda tiene como propósito que el usuario pueda elegir el
tiempo destinado a la ejecución del crawl, teniendo en cuenta que algunos dominios pueden tener una
gran cantidad de subdominios lo cual sumado al tiempo de espera de las peticiones puede incrementar
el tiempo del crawl de manera considerable, por lo que el usuario puede limitar este tiempo a su
conveniencia. El parámetro de recorrido le permite al usuario seleccionar la forma en la que el crawler
revisa los subdominios, puede seleccionar entre un modo First In First Out, que realiza una búsqueda a
lo ancho de los dominios, también puede seleccionar el modo Fisrt In Last Out que realiza una búsqueda
priorizando la profundidad. Con los resultados obtenidos se hace una verificación para detectar si los
dominios encontrados se encuentran indexados en Google. Después de esto el usuario podrá ver los
resultados obtenidos.

Se realizó una prueba de crawl al dominio del Departamento Administrativo Nacional de Estadística
(https://www.dane.gov.co/), el Instituto Colombiano del Bienestar Familiar (https://www.icbf.gov.co/)
y de la Universidad de los Andes (https://uniandes.edu.co/). El crawl logró encontrar todos los
subdominios y adicionalmente identificó cuales de estos no están indexados por el motor de búsqueda
de Google.

3
2 DESCRIPCIÓN GENERAL

2.1 Objetivos

El objetivo es crear un crawler que logre indexar resultados que no sean detectados por motores de
búsqueda populares. Se espera que al realizar comparaciones entre los resultados obtenidos con el
crawler y los resultados obtenidos con algún buscador web comercial se debe poder apreciar que algunos
resultados del crawler no se encuentran en los resultados del buscador tradicional, por ende, pertenecen
a la Deepweb. Adicionalmente se espera poder indexar estos resultados para que puedan ser consultados
por los usuarios a manera de motor de búsqueda. Adicionalmente también se espera que el buscador
muestre al usuario los resultados de la Surface web para darle la mayor cantidad de información posible
al usuario.
2.2 Identificación del problema y de su importancia

A pesar de que lo motores de búsqueda hacen un gran trabajo para mostrarle al usuario contenido web
relacionado a la búsqueda hay mucha información que los motores de búsqueda no pueden percibir,
definiremos este tipo de información Deep web. Una de las razones por las cuales algunos motores de
búsqueda no ofrecen una buena cantidad o calidad de resultados puede ser por los criterios que usan
para buscar la información, por ejemplo, Google indexa las páginas teniendo en cuenta un criterio de
popularidad en vez de un criterio de calidad. Se estima que la información pública en la Deep web es de
400 a 550 veces mayor que la encontrada en la World Wide Web3. Teniendo lo anterior en cuenta resulta
de gran importancia y utilidad entender cómo funcionan los motores de búsqueda modernos y
posiblemente crear un crawler que logre encontrar mejor cantidad y calidad de información para que el
usuario la pueda consumir.

3 IMPLEMENTACIÓN

La implementación consiste en un archivo de python llamado crawler.py el cual se encarga de recorrer

de manera recursiva los subdominios de un dominio proporcionado por el usuario para encontrar la
información disponible del dominio. Este programa genera un archivo con todos los urls de los
subdominios encontrados durante la ejecución del crawler. Posteriormente, otro archivo llamado
verificador.py contiene un programa que toma como parámetro los resultados obtenidos de la ejecución
del crawler y confirma si la url identificada se encuentra indexada en Google y se encuentra en la Surface
web o si no se encuentra en Google y se encuentra en la Deep web. Por último, estos resultados se
muestran al usuario para que pueda consultar la información que está buscando.

3.1 Descripción de la implementación

3.1.1 Crawler

El crawler desarrollado se realizó en el archivo crawler.py, el cual contiene el programa que tiene como
parámetro la url del dominio al que se le hará el crawl, el tiempo de ejecución del crawl y el orden de
recorrido del crawl. Al ejecutarse el archivo visitará de manera recurrente todos los subdominios que se
encuentren en las páginas, teniendo en cuenta que solo tendrá en cuenta los subdominios del dominio
suministrado por parámetro. El crawler se encarga de verificar la estructura de la url encontrada, ya que
en algunas ocasiones los subdominios encontrados en una página no cuentan con la url de su dominio,
por lo que en estos casos el programa le agrega la url base apropiada para que se pueda consultar esa
url. Este programa agrega todas las urls identificadas a un archivo que puede ser consultado por el

4
usuario. A continuación, se muestra el código del crawler, que será explicado a mayor detalle a
continuación.

Figure 1. Código programa crawler

3.1.2 Parámetros

El código tiene parámetros enfocados en ofrecer resultados en función de las necesidades del usuario.
Para esto el código tiene varios parámetros que se pueden apreciar en la imagen a continuación. El
parámetro “modoBusqueda” hace referencia al recorrido de los subdominios que se hará, si este
parámetro es igual a “profundidad” las urls tendrán una estructura de pila y se buscará cada dominio a
profundidad primero. En caso de que el parámetro sea distinto se buscarán los subdominios a lo ancho.
El parámetro “urlBase” contiene el dominio al que cual realizaremos el crawl, en la imagen del ejemplo
vemos el subdominio de la Universidad de los Andes, que fue uno de los subdominios a los cuales
realizamos ejecuciones de prueba. El parámetro “palabrasIgnorados” contiene palabras que queremos
ignorar en las urls de los subdominios, en la imagen a continuación podemos ver que la palabra
“calendario” se encuentra en este parámetro ya que el calendario aparece en muchos subdominios y

5
generalmente no contiene información relevante y por eso se prefiere ignorar esta palabra. El parámetro
minutos hace referencia al tiempo que el usuario quiera ejecutar el programa, ya que los dominios
pueden tener hasta cien mil subdominios asociados, lo cual podría elevar el tiempo de ejecución y es
importante poder limitarlo de acuerdo a las preferencias del usuario.
3.1.3 Variables

Al inicio del programa se definen algunas variables para la ejecución de este. La variable “urls” es una
lista que guardará todas las urls de los subdominios que se encuentren durante la ejecución y basados
en esta lista se hará el recorrido de los subdominios. La variable “historial” es una variable que guardará
todos los subdominios visitados durante la ejecución del programa, con el objetivo de no visitar
subdominios visitados previamente y caer en bucles infinitos. Por último, la variable llamada
“patternURLS” contiene la expresión regular con la cual identificaremos los subdominios presentes en
cada una de las páginas web de los subdominios encontrados. Start time hace referencia al momento en
el que empieza la ejecución, esta variable es importante para limitar el tiempo de búsqueda deseado por
el usuario. Maxtime hace referencia al tiempo máximo de ejecución del programa, teniendo en cuenta
los minutos especificados por el usuario.

Figure 2.Parámetros y variable programa crawler

3.1.4 Ejecución

En la línea 17 de la imagen a continuación encontramos la función “timeChek()”, esta función revisa si

el tiempo de ejecución ha superado el tiempo de ejecución especificado por el usuario y en caso de que
el tiempo de ejecución sea superior, detiene la ejecución de programa. A grandes rasgos el programa
consiste en un ciclo que itera por cada url encontrada. En la línea 21 está el ciclo que itera cada url
presente en la lista “urls”, lo primero que se hace es agregar la url a la lista “historial”. Luego se llama
a la función “timeChek()” la cual verifica el tiempo de ejecución. Luego hace print del url actual, para
ponerlo en el archivo resultante de la ejecución del programa, esto se hace dentro de un try debido a que
algunas urls están codificadas en formatos que generan excepciones al momento de intentar ponerlas en
el archivo de resultado y para que no detengan la ejecución del programa se hace este manejo de

6
excepciones. Dentro de este try también se realiza la petición del url actual y se guarda en la variable
“respuesta” la cual tiene el contenido de la petición que se hace a la url actual en formato de texto plano,
se pone dentro del try por que es posible que alguna url no reciba una respuesta válida y genere una
excepción. Luego, en la línea 29 se crea la variable urlsEncontrados, la cual contiene todas las urls que
se encuentren en la respuesta de la petición a la url actual. Luego para esos urls encontrados en la
respuesta del url actual se evalúa si empiezan por el url base, en caso de que no, se les agrega el url base
al principio de la url para que después se puedan consultar. También se evalúa si pertenecen a otro
dominio diferente al del url base, en caso de que sean distintos no se tienen en cuenta debido a que es
otro dominio. También se evalúa que no se encuentren en el historial, ya que si se están en el historial
significa que ya fueron visitados previamente. Por último, se valida que no contengan las palabras que
queremos ignorar en el url. Después de estas verificaciones se agrega a la lista de urls y después de
verificar los urls encontrados se saca el url actual de la lista de urls para seguir con el siguiente y de esta
manera hasta que no hayan urls en la lista y se de fin a la ejecución del programa. La manera de ejecutar
el programa es la siguiente, nos ubicamos en la carpeta que contiene el programa y por consola
ejecutamos la siguiente línea de código “python crawlerVersionFinal.py > resultados.txt” de esta manera
los resultados quedan guardados en el archivo “resultados.txt” el cual puede tener el nombre que el
usuario elija. En la imagen se muestran los resultados de la ejecución del programa.

Figure 3.ejecución programa crawler

7
Figure 4. resultados programa crawler

3.2 Resultados esperados

Se espera que el programa del crawler pueda obtener los resultados de todos los subdominios del
dominio proporcionado por el usuario, teniendo en cuenta el tiempo de ejecución. También se hace la
aclaración de que el crawler solo accedería a los subdominios que se encuentren en las páginas. También
se espera que haya algunas urls que se encuentren en la Deep web, que no se encuentren en Google. Se
realizaron pruebas al dominio del DANE, del ICBF y de la universidad de los andes. Se encontraron
10426, 991 y 3636 urls respectivamente, en los dominios en los que se realizó la prueba. A continuación,
vemos una gráfica demostrativa de los resultados.

8
Figure 5.Resultados pruebas

4 VALIDACIÓN

4.1 Verificador

Después de la ejecución del crawler es sumamente valioso entender y detectar si los resultados obtenidos
se encuentran en la Deep web o no. Esta tarea es realizada por el archivo verificador.py el cual contiene
el programa que se encarga de tomar la lista de urls resultantes del crawl y verificar si se encuentran en
Google o no. Este programa tiene como parámetro de entrada la lista de resultados del crawl y los revisa
uno por uno. Lo primero que hace el programa para cada url es codificarla como parámetro de entrada
para realizar la petición a Google para que sea equivalente a buscar “site:<url a verificar>”. Cuando la
url no se encuentra en Google la respuesta a esta petición contiene un texto que dice “documento no
encontrado”. Adicional a esto se hizo uso de un proxy desarrollado por OxyLabs el cual sirve para
resolver los captchas que pone Google cuando se realizan muchas peticiones. Al final el programa
genera un archivo con todas las urls que no se encuentran en Google. A continuación, vemos el código
del verificador.

9
Figure 6. Código verificador

4.2 Parámetros y variables

Para el verificador se tiene el parámetro de tiempo. El cual funciona de manera similar que en el
programa del crawler, el usuario puede ingresar el número de minutos que desee permitir de la ejecución
del verificador. El parámetro “web_unlocker” es un diccionario que guarda los valores del proxy que
nos ayuda a pasar el captcha que nos muestra Google al realizar tantas peticiones al servidor.

Figure 7. Variables y parámetro verificador

4.3 Ejecución

Primero tenemos el método “timeChek()” usado previamente en el programa del crawler y cuya función
es verificar que el tiempo de ejecución sea menor al tiempo máximo determinado por parámetro. Luego,
en la línea 24, se abre el archivo que contiene las urls previamente encontradas que serán revisadas, se
guardan las urls a revisar en una lista llamada “input_lines”. Luego, para cada línea en el archivo de
entrada se codifica la url para ponerla en formato url para poder realizar la búsqueda con formato
“site:<url a verificar>”, se hace la petición a través del proxy de OxyLabs que nos permite pasar los
captchas. Por último, revisamos si el resultado contiene la url buscada, o si no la encontró, en caso de

10
que no se encuentre imprimimos la url ya que se encuentra en la Deep web. Para correr el código
debemos ubicarnos en la carpeta que contiene el programa y correr la siguiente línea de código “python
verificador.py > resultados.txt” los resultados quedarán en el archivo resultados.txt el cual podrá tener
el nombre que el usuario considere mejor. Por último, se muestra una imagen de los resultados de este
programa.

Figure 8. Ejecución verificador

Figure 9. Archivo de resultados verificador

4.4 Resultados del verificador

Se espera que el programa verificador sea capaz de revisar todas las urls. También se espera que este
programa logre pasar las pruebas de captcha que realiza Google para poder seguir realizando toda la
verificación. Para realizar pruebas se realizaron crawls al dominio del DANE, del ICBF y de la
Universidad de los Andes. Asimismo, también se realizó la verificación de cuantos de los resultados

11
obtenidos no se encontraron en la Surface web. A continuación, se muestra una gráfica mostrando la
proporción de resultados que se encuentran en la Deep web de cada una de las pruebas realizadas.

Porcentaje de subdominios en la deep web

6.00%

5.00%

4.00%

3.00%

2.00%

1.00%

0.00%
DANE ICBF Uniandes

Figure 10. Resultados pruebas verificador

5 CONCLUSIONES

5.1 Discusión

Se logró construir un crawler que encuentra los subdominios de una url base proporcionada por el
usuario. Se logró construir un verificador que puede consultar si una url se encuentra en Google. Un
problema que se encontró fue el uso de captchas por parte de Google al momento de realizar varias
peticiones. Este problema se logró solucionar con la ayuda de la inteligencia artificial a través de un
programa desarrollado por OxyLabs, a través de un proxy que dirigía el tráfico primero a los servidores
de OxyLabs se pudo solucionar este problema de los captchas. Los resultados obtenidos son
satisfactoriamente cercanos a lo esperado ya que al ser paginas de instituciones importantes no se
esperaba que hubiera muchos resultados en la Deep web, lo que concuerda con los resultados obtenidos.
5.2 Trabajo futuro

Teniendo en cuenta que se lograron identificar las páginas no indexadas y pertenecientes a la Deep web
de los sitios que se les hizo el crawl, posteriormente se podría plantear realizar un scrapper. Un scrapper
es una herramienta que registra todo el contenido e información presente en una página web. Los
scarppers tienen muchas utilidades, entre ellas, encontrar información o recursos valiosos de manera
automática dentro de una o varias páginas web. Teniendo lo anterior en cuenta se podría implementar
un scrapper que funcionara de manera conjunta con el crawler propuesto anteriormente, para además de
detectar las páginas de la Deep web, poder también usar un scrapper para revisar su contenido de manera
automática.

12
6 REFERENCIAS

Bergman, M. K., (Agosto 2001), White Paper: The Deep Web: Surfacing Hidden Value, Volume 7,
Issue 1. Recuperado de : https://quod.lib.umich.edu/cgi/t/text/idx/j/jep/3336451.0007.104/--white-
paper-the-deep-websurfacing-hidden-value?rgn=main;view=fulltext

Qinghua Z., Zhaohui W., Xiaocheng C., Lu J., Jun L., (2013), Information Systems, Volume 38, Issue
6, P. 801-819, Learning to crawl deep web. Recuperado de :
https://www.sciencedirect.com/science/article/abs/pii/S0306437913000288 (Glenda Brown, 2004)
Brown G, Jermey J., ( 2004). WEBSITE INDEXING, Adelaide, South Australia: Auslib Press.
Recuperado de :
https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=3963370a25a094b11b595c8ffb2e1
9a1134ea72b
M, P. S., Raja, S. V., Arkoli, F. K., & M, J. (2011 November). A Survey of Web Crawler Algorithms.
IJCSI International Journal of Computer Science Issues, 309-313. Recuperado de :
https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=9eb15cbf5a07e425bef664fa3366f9
885516051b#page=328
Lu, J., Li, D. Estimating deep web data source size by capture–recapture method. Inf Retrieval 13,
70–95 (2010). Recuperado de : https://doi.org/10.1007/s10791-009-9107-y
HE, B., PATEL, M., ZHANG, Z., & CHANG, K. C.-C. (2007). ACCESSING THE DEEP WEB.
COMMUNICATIONS OF THE ACM/Vol. 50, No. 5, 95-101. Recuperado de :
https://dl.acm.org/doi/pdf/10.1145/1230819.1241670

13