1

Guias/Hostear una instancia de SearxNG.md

@@ -0,0 +1,150 @@
+# Como alojar una instancia de SearxNG ;)
+Buscas tener un motor de búsqueda enfocado a la privacidad? Quieres que tus búsquedas sean realmente privadas y que no sean vendidas a empresas de terceros para colocarte anuncios molestos?
+Entonces deberías alojar tu propia instancia de SearxNG :).
+
+SearxNG (según su pagina web) es: *"SearXNG es un metabuscador de Internet gratuito que agrega resultados de más de 70 servicios de búsqueda. Los usuarios no son rastreados ni perfilados."* (Traducido del ingles al español)
+
+Esto actua al igual que otro motor de busqueda, pero saca los resultados de otros motores de busqueda como Google, Bing, DuckDuckGo y cuida tu privacidad; Ya que todo lo que se busca, se hace desde el servidor que aloja la instancia, enmascarando tu IP y otros datos que se utilizan para seguimiento (Como las cookies)
+
+(Es una buena practica hacer tu instancia **totalmente publica**, si piensas hacerla privada y solo para ti, no tendria sentido ya que todo lo que busques saldra de la misma IP del servidor, las busquedas seran tuyas y no seran mixtas, lo cual hace facil identificarte. Seria como literalmente buscar lo que siempre buscas, pero con otra IP, tal cual como una VPN o Proxy)
+## Que es lo que se necesita para poder alojar una instancia?
+- Una **VPS** (Virtual Private Server / Servidor Virtual Privado que contenga su propia ip) que incluya estas especificaciones como minimo:
+	- Sistema operativo Linux
+	- 1GB de RAM
+	- Un procesador de un nucleo
+	- 20GB de almacenamiento (Recomendado)
+	- Un ancho de banda de más de 50Mbps (Si es que planeas hacer una instancia publica)
+
+- Un dominio. Puede ser un `.com` `.xyz` `.net`. Estos se compran por un año y los dominios .xyz son los mas baratos (solo por primer año) pero son reconocidos por ser dañinos. Recomiendo comprar un dominio .com o un dominio de tu propio país como un *.cl* . Obviamente son más caros pero valen la pena si es que te animas a alojar mas servicios, como un servidor de correo o un servidor DAV (Para los contactos y calendario)
+- Conocimientos previos sobre Linux
+- Conocimientos sobre NGINX (Servidor Web, el cual se usara como "reverse proxy")
+- Copiar y pegar comandos, asi de simple
+
+En este tutorial proveere comandos que funcionan en **Arch Linux** y en **Debian/Ubuntu**
+
+## Instalación
+### SearxNG
+Una vez ya tengas una VPS o simplemente un servidor de pruebas (como una maquina virtual) ya puedes empezar a instalar los programas necesarios para instalar SearxNG. **Ejecuta el comando indicado para la distribución que instalaste**
+
+Debian/Ubuntu:
+```bash
+sudo -H apt-get install -y \
+    python3-dev python3-babel python3-venv \
+    uwsgi uwsgi-plugin-python3 \
+    git build-essential libxslt-dev zlib1g-dev libffi-dev libssl-dev \
+    shellcheck
+```
+
+Arch Linux:
+```bash
+sudo -H pacman -S --noconfirm \
+    python python-pip python-lxml python-babel \
+    uwsgi uwsgi-plugin-python \
+    git base-devel libxml2 \
+    shellcheck
+```
+
+Esto instalara los paquetes necesarios para **uWSGI** el cual se usa para ejecutar SearxNG.
+
+#### Creación de usuario
+SearxNG ocupa su propio usuario aislado de los demás, esto se hace por seguridad, ya que si se aprobechan de una falla de seguridad, esta no tendrá efecto ya que esta dentro de un usuario con poco acceso a los archivos del servidor.
+
+```bash
+sudo -H useradd --shell /bin/bash --system \
+    --home-dir "/usr/local/searx" \
+    --comment 'Privacy-respecting metasearch engine' searx
+
+sudo -H mkdir "/usr/local/searx"
+
+sudo -H chown -R "searx:searx" "/usr/local/searx"
+```
+
+#### Instalación de SearxNG y dependencias
+```bash
+sudo -H -u searx -i
+```
+Este comando abrira una consola dentro de el usuario `searx`. Luego solo copia estos comando dentro de el
+```bash
+python3 -m venv "/usr/local/searx/searx-pyenv"
+
+echo ". /usr/local/searx/searx-pyenv/bin/activate" >>  "/usr/local/searx/.profile"
+```
+Esto creara un entorno virtual de Python3 y sirve para evitar el conflicto entre dependencias.
+
+Ahora sale de la consola del usuario searx con el comando `exit` y vuelve a entrar a ella.
+```bash
+sudo -H -u searx -i
+```
+Y dentro de la consola, empieza a copiar estos comandos
+```bash
+command -v python && python --version
+```
+Esto sirve para verificar que la version de python es la correcta, procura ver que la version de python sea mayor a 3.8.
+
+Ejemplo:
+```bash
+/usr/local/searx/searx-pyenv/bin/python
+Python 3.8.1
+```
+
+Ahora puedes seguir con los siguentes comandos (copia uno por uno):
+```bash
+pip install -U pip
+pip install -U setuptools
+pip install -U wheel
+pip install -U pyyaml
+```
+Luego se que se hayan instalado, puedes seguir con la instalacion de las dependencias de SearxNG
+```
+cd "/usr/local/searx/searx-src"
+pip install -e .
+```
+
+Y listo, searxng ya esta instalado, pero no listo para usar ;)
+
+### Configuración de SearxNG
+Ejecuta estos 2 comandos dentro del usuario searx si es que no has cerrado la consola con el usuario. Si lo cerraste, solo vuelve a ejecutar
+`sudo -H -u searx -i`
+
+```bash
+sudo -H mkdir -p "/etc/searxng"
+
+sudo -H cp "/usr/local/searx/searx-src/utils/templates/etc/searxng/settings.yml" \
+             "/etc/searxng/settings.yml"
+```
+
+Esto copiara un plantilla de la configuración en `/etc/searxng/settings.yml` de SearxNG el cual podras editar más tarde. Es una configuración bastante minima asi más adelante mostrare que es lo más importante que hay que cambiar y modificar
+
+Ahora ejecuta este comando:
+```bash
+sudo -H sed -i -e "s/ultrasecretkey/$(openssl rand -hex 16)/g" "/etc/searxng/settings.yml"
+```
+Esto creara una llave secreta y totalmente aleatoria (como lo dice en el nombre `ultrasecretkey`) la cual tienes que mantener segura
+
+Ahora como ultimo comando, escribe `exit` para salir de la consola de searx
+
+#### Probar si SearxNG funciona :)
+
+A este punto, SearxNG ya deberia estar instalado y configurado **solo para uso personal**. Así que probaremos si todo funciona correctamente con estos comandos
+
+```bash
+sudo -H sed -i -e "s/debug : False/debug : True/g" "/etc/searxng/settings.yml"
+```
+Esto activa el modo debug para verificar que todo esta bien.
+Ahora ejecuta estos comandos uno por uno:
+```bash
+sudo -H -u searx -i
+
+cd /usr/local/searx/searx-src
+export SEARXNG_SETTINGS_PATH="/etc/searxng/settings.yml"
+python searx/webapp.py
+```
+Esto iniciara searxng para probar si realmente funciona. Ahora metete a el navegador y entra a la IP en el puerto 8888 del servidor (Si es una VPS, entra por la IP publica, y si es un servidor local, entra por la IP local).
+
+http://ip:8888 (Reemplaza `ip` por la IP del servidor)
+
+Si puedes ingresar sin problemas por la ip y el puerto, significa que esta funcionando, ahora detén el proceso y coloca esto para desactivar el modo debug: 
+
+```bash
+sudo -H sed -i -e "s/debug : True/debug : False/g" "/etc/searxng/settings.yml"
+```

Misc/Programas y comandos.md

@@ -0,0 +1,51 @@
+# WEAS TOTALMENTE UTILES
+
+## Alternativas a programas.
+- jq = jtc
+- cURL = xh
+- 
+
+
+## Programas
+- RESP.app (Interfaz grafica para Redis)
+- NBTExplorer (Para modificar los archivos de guardado del minecraft)
+- MarkText (Otra alternativa a Obsidian OSS)
+- TarTube (Para archivar videos de youtube)
+- Net activity viewer (netactview)
+- Ostinato
+- Pingnoo
+
+## IPFS
+### Convertir archivo a `.car` ^[https://web3.storage/docs/how-tos/work-with-car-files/]
+1. Instalar `npm install -g ipfs-car`
+2. Ejecutar `ipfs-car --path <nombredelarchiv> --output <salidadelarchivo>`
+3. Subir a web3.storage usando https://web3.storage/docs/how-tos/work-with-car-files/
+
+## YT-DLP
+### Descargar weas de manera paralela
+1. Extraer la lista de links de los videos con `yt-dlp --flat-playlist -i --print-to-file url file.txt <linkdecanaloplaylist>`
+2. Usar el comando `parallel` para ejecutar varias instancias de yt-dlp para cada uno de los links dentro del archivo `file.txt`: `parallel --line-buffer --jobs 8 -a file.txt yt-dlp --download-archive archive.txt {}`. El argumento `--jobs` es la cantidad de instanacias paralelas de yt-dlp ;)
+
+## Pipelining
+### Poner audio en stdout
+1. Usar el comando `sox <nombredelarchivo> -t <tipo> -`
+2. Pipearlo a cualquier otro programa como MPV
+
+## DHCP Info
+### Conseguir toda la información relacionada a un servidor DHCP
+1. `sudo nmap --script broadcast-dhcp-discover`
+
+## Decompilación
+*Programas necesarios para decompilar diferentes lenguajes de programacion y juegos.*
+
+#### C# (Unity) (Assembly-CSharp.dll)
+- ILSpy
+- DnSpy
+
+### C# (Unity IL2CPP)
+- Cpp2IL
+- IL2CppDumper
+
+#### Android (Java)
+- JADX (Terminal)
+- apktool (Terminal)

Networking/UDP Ping.md

@@ -0,0 +1,106 @@
+# How to ping via UDP
+UDP protocol is different from TCP, there is no SYN, SYN ACK and RST (3-Way Handshake), so it is difficult to get a response from a UDP server without sending valid data to the server.
+
+## How to find data to send
+You can use `netcat` / `nc` with the `-u` argument to make a UDP connection to the server
+
+```bash
+nc -u <IP> <port>
+```
+
+Once netcat is connected to the server, you can use "Wireshark" to capture network traffic.
+
+You will need to set the `ip.addr == <IP> && udp` filters in order to exclude other unnecessary packets and then start capturing the traffic.
+(Remember that you have to replace `<IP>` with the server IP)
+
+![[wiresharkFilter.png]]]
+
+Then you can start typing numbers or anything else inside NetCat to check if the server responds to the data sent, in my case, I sent a `1` to the server and it responds with a `.` (which in hexadecimal is `0e` and in ASCII is `SO`) 
+
+![[Pasted image 20220114185921.png]]
+Now that we have data to send, we will use one of these 2 tools, one called `nping` or `hping3`, these two are used to generate custom packets.
+
+### nping
+
+Using nping is quite simple, and in order to do a UDP ping, you have to type this in the console: 
+
+```bash
+nping --udp --data-string "1" -p <port> <IP>
+```
+(If you need information about what each command does, type `nping --help` or read the manuals with `man nping`)
+
+With this command, a `1` will be sent to the server every second, thus being possible to estimate the latency between client and server
+![[Pasted image 20220114202442.png]]
+
+### hping3 (Recommended)
+Like nping, hping3 also serves to execute pings, but this one has more useful options and gives more information about the latency, you don't have to wait for the command to finish to see the latency like nping.
+
+First of all, you have to create a file with the data you want to send, if you know that the server responds to `1`, you create a file with a `1` inside using this command:
+```bash
+echo "1" > data
+```
+
+Then we use this hping command to send pings to the server
+
+```bash
+hping3 -2 -d 1 -E data -p <port> <IP>
+```
+(The `-d` argument is dynamic and has to be changed depending on the length of the data.)
+
+![[Pasted image 20220114204056.png]]
+
+And that's it, so we can get the latency between client and server through a UDP port.
+
+## Common problems
+### What to do in case the server is not responding
+Sometimes, there are servers that do not deliver any response when sending random data, for that we need the software that interacts with the server (the client).
+
+In this case I will take as an example the CS:GO community servers.
+
+We start Wireshark and set the `ip.addr == <IP> && udp` filters, replacing `<IP>` with the IP of the community server and start capturing traffic.
+
+Now hit Refresh to get a response from the server
+![[Pasted image 20220214220004.png]]]
+
+Now we go back to Wireshark and see if the server gives us a response.
+
+![[Pasted image 20220214221154.png]]
+
+As we can see, what we need to send in order to get a response is `....TSource Engine Query` but we must be careful, because the `.... ` may not be correct and will not work when pinging, this is because most of the packets send Hexadeciamal characters, so what we have to do to get the correct data, is to click on the first packet sent by us (where the Source is the local IP), go to the bottom, expand the Data section, **Right click > Copy > ...as Printable Text** and we will have copied the data.
+
+![[Pasted image 20220214233215.png]]
+
+In my case I get `ÿÿÿÿTSource Engine Query`, and as you can see, the `....` was changed to `ÿÿÿÿ`, which is the correct data to be able to send a ping.
+
+This data can be copied to a file for use with `hping3` or directly copied in quotes with in the `--data-string` argument of `nping`. 
+(If this doesn't work, see bellow)
+
+### I have used the explanations above and still get no response.
+
+Sometimes, using the **Copy > ...as Printable Text** option may not work if we copy it to a text file (for `hping3`) or using it with `--data-string` of `nping` , in that case, the thing to do, is to copy the Value. Then instead of going to **Copy > ...as Printable Text**, you select **Value**, so we get the data in Hexadecimal
+
+```hex
+ffffffff54536f7572636520456e67696e6520517565727900
+```
+is the same as
+```text
+ÿÿÿÿÿTSource Engine Query
+```
+
+Already having the value in Hexadecimal, we can use it directly from `nping` with the argument `--data "<value>"` instead of using `--data-string`.
+
+Ex: 
+```shell
+nping --udp --data "ffffffffff54536f7572636520456e67696e652051756565727900" -p <port> <IP>
+```
+
+With `hping3` it is a bit more complicated since in hping3 there is no equivalent to `--data` like nping, if you need to send custom data, you need to write it to a file first. So how do I write Hexadecimal directly to a file?
+
+That can be done using this command:
+
+```shell
+echo '<data>' | xxd -r -p > <filename>
+```
+(You will need to have the `vim` or `xxd-standalone` package installed from AUR in case you are using an Arch Linux based distro) (If you are using other distro other than Arch Linux, just install the `vim` package)
+
+Replace `<data>` with the Hexadecimal value and `<filename>` with the name you want and you will have a file with the data needed to use it with `hping3`.

Networking_ES/UDP Ping.md

@@ -0,0 +1,106 @@
+# Como pinguear vía UDP
+El protocolo UDP es diferente al de TCP, no existe SYN, SYN ACK y RST (El 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
+
+```bash
+nc -u <IP> <puerto>
+```
+
+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)
+
+![[wiresharkFilter.png]]
+
+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: 
+
+```bash
+nping --udp --data-string "1" -p <puerto> <IP>
+```
+(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:
+```bash
+echo "1" > data
+```
+
+Luego usamos este comando de hping para mandar pings al servidor
+
+```bash
+hping3 -2 -d 1 -E data -p <puerto> <IP>
+```
+(El argumento `-d` es dinámico y hay que cambiarlo dependiendo de lo largo que sean los datos)
+
+![[Pasted image 20220114204056.png]]
+
+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 (el cliente)
+
+En este caso tomare como ejemplo los 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
+
+![[Pasted image 20220214221154.png]]
+
+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 la sección de Data, darle **Click derecho > Copy > ...as Printable Text** y tendremos copiado los datos.
+
+![[Pasted image 20220214233215.png]]
+
+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` 
+(Si esto no funciona, ve la siguiente sección)
+
+### 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
+
+```hex
+ffffffff54536f7572636520456e67696e6520517565727900
+```
+es lo mismo que
+```text
+ÿÿÿÿTSource Engine Query
+```
+
+Ya teniendo el valor en Hexadecimal, lo podemos usar directamente desde `nping` con el argumento `--data "<valor>"` en vez de usar `--data-string`
+
+Ej: 
+```shell
+nping --udp --data "ffffffff54536f7572636520456e67696e6520517565727900" -p <puerto> <IP>
+```
+
+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:
+
+```shell
+echo '<datos>' | xxd -r -p > <nombre del archivo>
+```
+(Necesitaras tener instalado el paquete de `vim` o `xxd-standalone` desde AUR en caso que uses una distro basada en Arch Linux) (Si estas usando otra distribución que no sea Arch Linux, solo instala el paquete `vim`)
+
+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`

Networking_ES/UDP Ping.rst

@@ -0,0 +1,197 @@
+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

Weas robadas/HOW TO BAN EASY INSTAGRAM ACCOUNTS 3 STEPS.md

@@ -0,0 +1,17 @@
+-Target account must have <10k followers, the fewer the better  
+  
+-Target should have a human profile picture (i.e. a picture of a human)  
+  
+-Instagram account with over 30k followers (can be fake, process is automated the majority of the time)  
+  
+Steps:  
+  
+1. Change your account name to something closesly resembling your target. So if your target is hhh, change yours to hhh_ or hhh1. Change your account picture to theirs, and if you're feeling super excited upload a couple of their pictures to your acc. also.  
+  
+2. Fill out this form for impersonation: [https://help.instagram.com/446663175382270](https://help.instagram.com/446663175382270)  
+  
+3. Wait patiently  
+  
+close  
+  
+Note: I didn't try or create this method, I just found it and it had good reviews so I decided to share it!

Weas robadas/MOST COMMONG HACKING METHODS USED UHQ TECHNIQUES YOU SHOULD KNOW ABOUT.md

@@ -0,0 +1,109 @@
+http://breached65xqh64s7xbkvqgg7bmj4nj7656hcb7x4g42x753r7zmejqd.onion/Thread-MOST-COMMONG-HACKING-METHODS-USED-UHQ-TECHNIQUES-YOU-SHOULD-KNOW-ABOUT
+
+1. Bait and Switch  
+  
+  
+  
+Using Bait and Switch hacking technique, an attacker can buy advertising spaces on the websites. Later, when a user clicks on the ad, he might get directed to a page that’s infected with malware. This way, they can further install malware or adware on your computer. The ads and download links shown in this technique are very attractive and users are expected to end up clicking on the same.  
+  
+  
+  
+The hacker can run a malicious program that the user believes to be authentic. This way, after installing the malicious program on your computer, the hacker gets unprivileged access to your computer.  
+  
+  
+  
+2. Cookie theft  
+  
+The cookies in our browser store personal data such as browsing history, username, and passwords for different sites we access. Once the hacker gets access to your cookie, he can even authenticate himself as you on a browser. A popular method to carry out this attack is to manipulate a user’s IP packets to pass through attacker’s machine.  
+  
+  
+  
+Also known as SideJacking or Session Hijacking, this attack is easy to carry out if the user is not using SSL (HTTPS) for the complete session. On the websites where you enter your password and banking details, it’s of utmost importance for them to make their connections encrypted.  
+  
+  
+  
+3. ClickJacking Attacks  
+  
+ClickJacking is also known by a different name, UI Redress. In this attack, the hacker hides the actual UI where the victim is supposed to click. This behavior is very common in-app download, movie streaming, and torrent websites. While they mostly employ this technique to earn advertising dollars, others can use it to steal your personal information.  
+  
+  
+  
+In other words, in this type of hacking, the attacker hijacks the clicks of the victim that aren’t meant for the exact page, but for a page where the hacker wants you to be. It works by fooling an internet user into performing an undesired action by clicking on the hidden link.  
+  
+  
+  
+4. Virus, Trojan, etc.  
+  
+Viruses or Trojans are malicious software programs that get installed into the victim’s system and keep sending the victim’s data to the hacker. They can also lock your files, serve fraud advertisement, divert traffic, sniff your data, or spread on all the computers connected to your network.  
+  
+  
+  
+You can read the comparison and difference between various malware, worms, trojans, etc., to know more.  
+  
+  
+  
+5. Phishing  
+  
+Phishing is a hacking technique using which a hacker replicates the most-accessed sites and traps the victim by sending that spoofed link. Combined with social engineering, it becomes one of the most commonly used and deadliest attack vectors.  
+  
+  
+  
+Once the victim tries to login or enters some data, the hacker gets the private information of the target victim using the trojan running on the fake site. Phishing via iCloud and Gmail account was the attack route taken by hackers who targeted the “Fappening” leak, which involved numerous Hollywood female celebrities.  
+  
+  
+  
+6. Eavesdropping (Passive Attacks)  
+  
+Unlike other attacks that are active in nature, using a passive attack, a hacker can monitor the computer systems and networks to gain some unwanted information.  
+  
+  
+  
+The motive behind eavesdropping is not to harm the system but to get some information without being identified. These types of hackers can target email, instant messaging services, phone calls, web browsing, and other methods of communication. Those who indulge in such activities are generally black hat hackers, government agencies, etc.  
+  
+  
+  
+7. Fake WAP  
+  
+Just for fun, a hacker can use software to fake a wireless access point. This WAP connects to the official public place WAP. Once you get connected to the fake WAP, a hacker can access your data, just like in the case above.  
+  
+  
+  
+It’s one of the easier hacks to accomplish and one needs a simple software and wireless network to execute it. Anyone can name their WAP as some legit name like “Heathrow Airport WiFi” or “Starbucks WiFi” and start spying on you. One of the best ways to protect yourself from such attacks is by using a quality VPN service.  
+  
+  
+  
+8. Waterhole attacks  
+  
+If you are a big fan of Discovery or National Geographic channels, you could relate easily with the waterhole attacks. To poison a place, in this case, the hacker hits the most accessible physical point of the victim.  
+  
+  
+  
+For example, if the source of a river is poisoned, it will hit the entire stretch of animals during summer. In the same way, hackers target the most accessed physical location to attack the victim. That point could be a coffee shop, a cafeteria, etc.  
+  
+  
+  
+Once the hacker is aware of your timings, they can use this type of attack to create a fake Wi-Fi access point. Using this they can modify your most visited website to redirect them to you to get your personal information. As this attack collects information on a user from a specific place, detecting the attacker is even harder. One of the best ways to protect yourself again such types of hacking attacks is to follow basic security practices and keep your software/OS updated.  
+  
+  
+  
+9. Denial of Service (DoS\DDoS)  
+  
+A Denial of Service attack is a hacking technique of taking down a site or server by flooding that site or server with a huge amount of traffic so that the server is unable to process all the requests in real-time and finally crashes down.  
+  
+  
+  
+In this popular technique, the attacker floods the targeted machine with tons of requests to overwhelm the resources, which, in turn, restricts the actual requests from being fulfilled.  
+  
+  
+  
+For DDoS attacks, hackers often deploy botnets or zombie computers that have only one task, that is, to flood your system with request packets. With each passing year, as the malware and types of hackers keep getting advanced, the size of DDoS attacks keeps increasing.  
+  
+  
+  
+10. Keylogger  
+  
+A keylogger is a simple software that records the key sequence and strokes of your keyboard into a log file on your machine. These log files might even contain your personal email IDs and passwords. Also known as keyboard capturing, it can be either software or hardware. While software-based keyloggers target the programs installed on a computer, hardware devices target keyboards, electromagnetic emissions, smartphone sensors, etc.  
+  
+  
+  
+Keylogger is one of the main reasons why online banking sites give you an option to use their virtual keyboards. So, whenever you’re operating a computer in a public setting, try to take extra caution.