198 lines
6.7 KiB
ReStructuredText
198 lines
6.7 KiB
ReStructuredText
Como pinguear vía UDP
|
|
=====================
|
|
|
|
El protocolo UDP es diferente al de TCP, no existe SYN, SYN ACK y RST
|
|
(Llamado 3-Way Handshake), por lo cual es difícil tener una respuesta de
|
|
un servidor UDP sin enviar datos validos al servidor
|
|
|
|
Como encontrar datos para enviar
|
|
--------------------------------
|
|
|
|
Se puede usar ``netcat`` / ``nc`` con el argumento ``-u`` para hacer una
|
|
conexión UDP al servidor
|
|
|
|
.. code:: language-bash
|
|
|
|
nc -u <IP> <puerto>
|
|
Copy
|
|
|
|
Una vez netcat este conectado al servidor, puedes usar "Wireshark" para
|
|
capturar el trafico de red
|
|
|
|
| Necesitaras poner los filtros de ``ip.addr == <IP> && udp`` para poder
|
|
excluir otros paquetes innecesarios y luego empiezas a capturar el
|
|
trafico
|
|
| (Recuerda que tienes que reemplazar ``<IP>`` por la IP del servidor)
|
|
|
|
.. image:: /home/fijxu/Documents/Obsidian/wiresharkFilter.png
|
|
:alt: wiresharkFilter.png
|
|
:class: internal-embed
|
|
|
|
Luego puedes empezar a escribir números u cualquier otra cosa dentro de
|
|
NetCat para revisar si el servidor responde a los datos enviados, en mi
|
|
caso, yo envié un ``1`` al servidor y me responde con un ``.`` (que en
|
|
hexadecimal es ``0e`` y al ASCII es ``SO``)
|
|
|
|
| |Pasted image 20220114185921.png|
|
|
| Ahora que ya tenemos datos para enviar, ahora lo usaremos una de estas
|
|
2 herramientas, una llamada ``nping`` o ``hping3``, estos dos sirven
|
|
para generar paquetes personalizados.
|
|
|
|
nping
|
|
~~~~~
|
|
|
|
Usar nping es bastante simple, y para poder hacer un ping UDP, hay que
|
|
escribir esto en la consola:
|
|
|
|
.. code:: language-bash
|
|
|
|
nping --udp --data-string "1" -p <puerto> <IP>
|
|
Copy
|
|
|
|
(Si necesitas información sobre que hace cada comando, escribe
|
|
``nping --help`` o lee los manuales con ``man nping``)
|
|
|
|
| Con este comando, se enviara un ``1`` al servidor cada segundo, así
|
|
siendo posible estimar la latencia entre cliente y servidor
|
|
| |Pasted image 20220114202442.png|
|
|
|
|
hping3 (Recomendado)
|
|
~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Al igual que nping, hping3 también sirve para ejecutar pings, pero este
|
|
tiene opciones más útiles y da más información acerca de la latencia, no
|
|
tienes que esperar a que termine el comando para ver la latencia como
|
|
nping
|
|
|
|
Primero que todo, hay que crear un archivo con los datos que queremos
|
|
enviar, si sabemos que el servidor responde a ``1``, se crea un archivo
|
|
con un ``1`` dentro usando este comando:
|
|
|
|
.. code:: language-bash
|
|
|
|
echo "1" > data
|
|
Copy
|
|
|
|
Luego usamos este comando de hping para mandar pings al servidor
|
|
|
|
.. code:: language-bash
|
|
|
|
hping3 -2 -d 1 -E data -p <puerto> <IP>
|
|
Copy
|
|
|
|
(El argumento ``-d`` es dinámico y hay que cambiarlo dependiendo de lo
|
|
largo que sean los datos)
|
|
|
|
.. image:: /home/fijxu/Documents/Obsidian/Pasted%20image%2020220114204056.png
|
|
:alt: Pasted image 20220114204056.png
|
|
:class: internal-embed
|
|
|
|
Y listo, así podemos obtener la latencia entre cliente y servidor a
|
|
través de un puerto UDP
|
|
|
|
Problemas Comunes
|
|
-----------------
|
|
|
|
Que hacer en caso de que el servidor no responda
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
Aveces, hay servidores que no entregan ninguna respuesta a la hora de
|
|
mandar datos aleatorios, para eso necesitamos el software que interactua
|
|
con el servidor (cliente)
|
|
|
|
En este caso tomare como ejemplo, servidores comunitarios de CS:GO
|
|
|
|
Iniciamos Wireshark y ponemos los filtros de ``ip.addr == <IP> && udp``,
|
|
reemplazando ``<IP>`` por la IP del servidor comunitario y empezamos a
|
|
capturar trafico
|
|
|
|
| Ahora le das a Refresh para tener respuesta del servidor
|
|
| |Pasted image 20220214220004.png|
|
|
|
|
Ahora volvemos a Wireshark y veremos si el servidor nos da una respuesta
|
|
|
|
.. image:: /home/fijxu/Documents/Obsidian/Pasted%20image%2020220214221154.png
|
|
:alt: Pasted image 20220214221154.png
|
|
:class: internal-embed
|
|
|
|
Como podemos ver, lo que necesitamos enviar para poder obtener respuesta
|
|
es ``....TSource Engine Query`` pero hay que estar atento, por que los
|
|
puntos ``....`` pueden no ser los correctos y no funcionaran a la hora
|
|
de hacer ping, esto es debido a que la mayoria de los paquetes envian
|
|
caracteres en Hexadeciamal, entonces lo que tenemos que hacer para
|
|
obtener los datos correctos, es darle click al primer paquete enviado
|
|
por nosotros (Donde el Source es la IP local), ir a la parte de abajo,
|
|
expandir lo que dice Data, darle **Click derecho > Copy > ...as
|
|
Printable Text** y tendremos copiado los datos.
|
|
|
|
.. image:: /home/fijxu/Documents/Obsidian/Pasted%20image%2020220214233215.png
|
|
:alt: Pasted image 20220214233215.png
|
|
:class: internal-embed
|
|
|
|
Yo en mi caso consigo ``ÿÿÿÿTSource Engine Query``, y como se puede ver,
|
|
los ``....`` fueron cambiados por ``ÿÿÿÿ``, que son los datos correctos
|
|
para poder enviar un ping.
|
|
|
|
Estos datos se pueden copiar a un archivo para usarlos con ``hping3`` o
|
|
directamente copiarlos entre comillas con en el argumento
|
|
``--data-string`` de ``nping``
|
|
|
|
He usado las explicaciones de arriba y sigo sin recibir respuesta
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
A veces, usar la opción de **Copy > ...as Printable Text** puede no
|
|
funcionar si lo copiamos en un archivo de texto (para ``hping3``) o
|
|
usándolo con ``--data-string`` de ``nping`` , en ese caso, lo que hay
|
|
que hacer, es copiar el Valor. Entonces en vez de ir a **Copy > ...as
|
|
Printable Text**, seleccionas **Value**, así obtenemos los datos en
|
|
Hexadecimal
|
|
|
|
.. code:: language-hex
|
|
|
|
ffffffff54536f7572636520456e67696e6520517565727900
|
|
Copy
|
|
|
|
es lo mismo que
|
|
|
|
.. code:: language-text
|
|
|
|
ÿÿÿÿTSource Engine Query
|
|
Copy
|
|
|
|
Ya teniendo el valor en Hexadecimal, lo podemos usar directamente desde
|
|
``nping`` con el argumento ``--data "<valor>"`` en vez de usar
|
|
``--data-string``
|
|
|
|
Ej:
|
|
|
|
.. code:: language-shell
|
|
|
|
nping --udp --data "ffffffff54536f7572636520456e67696e6520517565727900" -p <puerto> <IP>
|
|
Copy
|
|
|
|
Con ``hping3`` es algo más complicado ya que en hping3 no hay un
|
|
equivalente a ``--data`` como nping, si se necesitan enviar datos
|
|
personalizados, se necesitan escribir en un archivo primero. Entonces
|
|
¿Como escribo Hexadecimal directamente en un archivo?
|
|
|
|
Eso se puede hacer utilizando este comando:
|
|
|
|
.. code:: language-shell
|
|
|
|
echo '<datos>' | xxd -r -p > <nombre del archivo>
|
|
Copy
|
|
|
|
(Necesitaras tener instalado el paquete de ``vim`` o ``xxd-standalone``
|
|
desde AUR en caso que uses una distro basada en Arch Linux)
|
|
|
|
Reemplaza ``<datos>`` por el valor en Hexadecimal y
|
|
``<nombre del archivo>`` por el nombre que quieras y ya tendrás un
|
|
archivo con los datos necesarios para usarlos con ``hping3``
|
|
|
|
.. |Pasted image 20220114185921.png| image:: /home/fijxu/Documents/Obsidian/Pasted%20image%2020220114185921.png
|
|
:class: internal-embed
|
|
.. |Pasted image 20220114202442.png| image:: /home/fijxu/Documents/Obsidian/Pasted%20image%2020220114202442.png
|
|
:class: internal-embed
|
|
.. |Pasted image 20220214220004.png| image:: /home/fijxu/Documents/Obsidian/Pasted%20image%2020220214220004.png
|
|
:class: internal-embed
|