DEV Community: rooyca

HTTP request from Obsidian notes

rooyca — Sun, 02 Jun 2024 02:59:26 +0000

Are you an Obsidian user looking to elevate your note-taking experience with dynamic data integration? Look no further than APIR (api-request) – an Obsidian plugin designed to streamline HTTP requests directly into your notes.

⚡ How to Use

With APIR, integrating HTTP requests into your notes is a breeze. Simply create a code-block within your note, specifying the language as req. Inside this code-block, customize parameters such as URL, method, body, headers, and more to tailor your request precisely to your needs.

👨🏻‍💻 Example Code-block

```req
url: https://my-json-server.typicode.com/typicode/demo/comments
method: post
body: {"id":1}
headers: {"Accept": "application/json"}
format: <h1>{}</h1>
req-id: id-persona
disabled
```

This example demonstrates how to send a POST request to a server, displaying the response 'id' field within an HTML heading tag. For more info about all the flags you can visit APIR docs.

Ready to revolutionize your note-taking workflow? Try APIR today! 🌟

P.S. If you find any bug, have any problem, doubt or want to add any functionality don't hesitate to write me. (You can also leave your issue at https://github.com/Rooyca/obsidian-api-request/issues)

Creando un acortador de enlaces en 12 lineas de código usando Cloudflare Workers + Bonus

rooyca — Sun, 19 Mar 2023 16:32:21 +0000

Post original aquí

Cloudflare Workers

Cloudflare Workers, de forma muy resumida, es un entorno serverless que corre Javascript. Básicamente, escribes código que se ocupa de peticiones HTTP, similar a Node.js. El código es desplegado globalmente en toda la red de Cloudflare, lo que significa que siempre está corriendo lo más cerca posible del usuario final.

Crear un acortador de enlaces con esta herramienta es muy fácil, aquí un pequeño tutorial de cómo hacerlo.

Para este proyecto, al ser algo pequeño, con el plan gratis será más que suficiente. Si te interesa hacer algo más grande te vendría bien revisar los planes de pago.

KV Storage

Primero, necesitaremos un lugar para almacenar nuestra información. Usaremos Workers KV, el cual no es más que un almacenamiento de llave - valor (key-value, en inglés) proporcionado por Cloudflare Workers. Nos dirigimos a Workers > KV damos click en Create namespace. Seleccionamos un nombre y damos click en Add:

Damos click en View en la lista de namespace para acceder a nuestro nuevo namespace, y añadimos algunas entradas. La llave será el "token" para nuestro enlace corto, y el valor será la URL a la que se redirecionará.

Creando el servicio worker

Ahora, nos dirigimos a la parte de Workers > Overview, y damos click en Create a service. Escogemos un nombre, seleccionamos la platilla de HTTP handler con el modulo sintaxis, y finalmente damos click en Create service:

Debería redireccionarnos a nuestro nuevo servicio:

Asignando el KV namespace a una variable

Antes de comenzar a programar, necesitamos asignar nuestro KV namespace a una variable, de tal manera que podamos accederlo desde nuestro código. Vamos a la pestaña de Settings, luego a la sección de Variables:

En KV Namespace Bindings damos click en Add binding, ingresamos kv como nombre de variable (tú puedes seleccionar otro nombre, si gustas), seleccionamos el KV namespace que creamos antes, y damos Save.

El código

Estamos listo para comenzar a programar! Regresamos a la pestaña de Resources, y damos click en el botón de Quick edit:

En la izquierda encontramos un simple editor de Javascript, y en la derecha una UI para testear nuestro worker. Puedes enviar peticiones al worker y verificar cómo responde. Esto hará que testear nuestro código sea muy sencillo!

Remplazamos el código con el siguiente:

export default {
  async fetch(request, env) {

    if (request.method != "GET") {
      return new Response("Forbidden", { status: 403 });
    }

    const { pathname } = new URL(request.url);
    const key = pathname.split('/')[1];
    if (!key) {
      return new Response("Not found", { status: 404 });
    }

    const dest = await env.kv.get(key);
    if (dest) {
      return new Response("Redirecting...", { status: 302, headers: { "Location": dest }});
    }

    return new Response("Not found", { status: 404 });
  }
}

Rápida explicación del código:

Tenemos dos parámetros:
- request, el cual representa la petición HTTP que acabamos de recibir
- env, el cual nos da acceso a las variables de entorno y al KV namespace bindings
Solo queremos procesar peticiones del tipo GET, por lo que respondemos 403 Forbidden si la petición no es tipo GET.
Extraemos la dirección de la URL, y luego tomamos la primera parte de la dirección; este es el token (o llave) para el enlace corto.
Accedemos al KV namespace para encontrar nuestra URL de destino, la cual está asociada con nuestro token.
Si lo encontramos, respondemos con 302 Found para redireccionar a nuestra URL (esto lo especificamos en el header Location)
De lo contrario, respondemos con un 404 Not Found

Testeando y desplegando

Puedes hacer un test usando el panel HTTP:

Una vez que estamos satisfechos con los resultados y hemos comprobado que todo funciona correctamente podemos desplegar la instancia dando click en el botón de Save and deploy.

Cuando lo hemos desplegado, podemos ingresar la dirección del panel de test directamente en nuestro navegador y nos redireccionará a nuestra URL de destino.

Bonus - Añadiendo un subdominio para nuestro worker

Nos dirigimos a la pestaña de Triggers, damos click en el botón Add Custom Domain:

Luego ingresamos nuestro subdominio, del tipo radio.example.com:

Y listo, al ingresar a nuestro subdominio con un token valido, nos redireccionará a nuestra URL.

Conclusión

Acabamos de crear un acortador de enlaces en 12 lineas de código (claro, sin contar los espacios en blanco ni los corchetes) Nada mal. Es bastante minimalista, pero es un buen comienzo. Recordemos que siempre podemos añadir más URL desde el KV editor.

PicoCTF Writeup – Reverse Engineering (asm2)

rooyca — Thu, 01 Sep 2022 04:21:47 +0000

Primeramente me gustaría dejar claro que esta publicación no es más que una traducción. Por lo que todos los creditos van para MRegra Silva

Información:

Nombre de la plataforma: PicoCTF

Nombre del reto: asm2

Categoría: Ingeniería Inversa

Puntos: 250

PicoCTF 2019.

Descripción del reto:

¿Qué retorna asm2(0xb, 0x2e)? Envía la bandera como un valor hexadecimal (comienza con '0x'). NOTA: El envío para este reto NO será en el formato normal de las banderas. Código.

Pista: Condiciones en ensamblador

Writeup (Inicio)

En este reto, tenemos el código fuente en ensamblador. El archivo se llama test.S y acontinuación puedes ver el código en cuestion:

asm2:
    <+0>:   push   ebp
    <+1>:   mov    ebp,esp
    <+3>:   sub    esp,0x10
    <+6>:   mov    eax,DWORD PTR [ebp+0xc]
    <+9>:   mov    DWORD PTR [ebp-0x4],eax
    <+12>:  mov    eax,DWORD PTR [ebp+0x8]
    <+15>:  mov    DWORD PTR [ebp-0x8],eax
    <+18>:  jmp    0x509 <asm2+28>
    <+20>:  add    DWORD PTR [ebp-0x4],0x1
    <+24>:  sub    DWORD PTR [ebp-0x8],0xffffff80
    <+28>:  cmp    DWORD PTR [ebp-0x8],0x63f3
    <+35>:  jle    0x501 <asm2+20>
    <+37>:  mov    eax,DWORD PTR [ebp-0x4]
    <+40>:  leave  
    <+41>:  ret

Como dige anteriormente, esto es código en ensamblador, ya solucioné un reto sobre ensamblador por lo que podría ser parecido, vamos a probar.

Para entender el programa decidí ir línea por línea.

    <+0>:   push   ebp
    <+1>:   mov    ebp,esp

Como ya sabemos asm2(0xb, 0x2e) está siendo puesto en el stack. Esto pasa en las primeras dos líneas. La primera hace push de asm2 hacia ebp y después se mueve dicho valor hacia esp.

Después de estas dos instrucciones, el estado del stack es el siguiente:

Direccion	Valor	Instrucción
0xc	0x2e	ebp+0xc
0x8	0xb	ebp+0x8
0x4	ret	ebp+0x4
0x0	ebp

Saber esto nos ayuda bastante. Ahora vamos a ver la siguiente instrucción:

<+3>:   sub    esp,0x10

En esta instrucción, simplemente estamos a asignando espacio para algunas variables locales, por lo que el stack quedaría así:

Direccion	Valor	Instrucción
0xc	0x2e	ebp+0xc
0x8	0xb	ebp+0x8
0x4	ret	ebp+0x4
0x0	ebp
-0x4	local1	ebp-0x4
-0x8	local2	ebp-0x8
-0xc	local3	ebp-0xc
-0x10	local4	ebp-0x10

Continuamos con:

    <+6>:   mov    eax,DWORD PTR [ebp+0xc]
    <+9>:   mov    DWORD PTR [ebp-0x4],eax
    <+12>:  mov    eax,DWORD PTR [ebp+0x8]
    <+15>:  mov    DWORD PTR [ebp-0x8],eax
    <+18>:  jmp    0x509 <asm2+28>

Vamos instrucción por instruccion:

Primero, le asignamos al registro eax el valor de ebp+0xc que sería 0x2e, según el stack actual.
Después, movemos el valor del registro eax a ebp-0x4, que en nuestro caso sería local1, es decír la variable local1 tendría el valor 0x2e.
Luego movemos el contenido de epb+0x8 a eax, es decír, su valor sería 0xb
En la linea +15 movemos el contenido del registro eax hacia ebp-0x8, es decír la variable local2 tendría el valor 0xb.
Finalmente hacemos un salto hacia asm2+28.

El estado actual del stack es:

Direccion	Valor	Instrucción
0xc	0x2e	ebp+0xc
0x8	0xb	ebp+0x8
0x4	ret	ebp+0x4
0x0	ebp
-0x4	0x2e	ebp-0x4
-0x8	0xb	ebp-0x8
-0xc	local3	ebp-0xc
-0x10	local4	ebp-0x10

Pasemos a la siguiente instrucción:

    <+28>:  cmp    DWORD PTR [ebp-0x8],0x63f3
    <+35>:  jle    0x501 <asm2+20>

Como sabrás, la anterior instrucción nos hizo saltar hacia asm2+28, la cual es una comparación seguida de un salto si el resultado es menor o igual que. En este caso, comparamos ebp-0x8 (es decir, la variable local2 que tiene el valor 0xb) y 0x63f3. Sabemos que 0xb es menor que 0x63f3 por lo que hacemos el salto hacia asm2+20.

    <+20>:  add    DWORD PTR [ebp-0x4],0x1
    <+24>:  sub    DWORD PTR [ebp-0x8],0xffffff80

En la linea +20 tenemos una istrucción add, añadimos 1 a ebp-0x4, convirtiéndolo en 0x2f.
En la linea +24 tenemos una instrucción sub, restamos 0xffffff80 a ebp-0x8. Esto es x86 por lo que tenemos que truncar el resultado, para ello simplemente realizamos esta operación en Python:

local2 = (local2 - 0xffffff80) & 0xffffffff

Ahora el valor de local2 es: 0x8b

Continuando con la siguiente linea nos encontramos nuevamente en la +28 y sabemos que 0x8b es menor que 0x63f3 por lo que volvemos a dar el salto. Para facilitar el proceso creé un script en Python que no es más que una "traducción" de este código en ensamblador. El script en cuestión es el siguiente:

'''
Stack:
[  local4 ]  <--- ebp-0x10
[  local3 ]  <--- ebp-0xc
[  local2 ]  <--- ebp-0x8
[  local1 ]  <--- ebp-0x4
[   ebp   ]
[   ret   ]  <--- ebp+0x4
[   arg1  ]  <--- ebp+0x8
[   arg2  ]  <--- ebp+0xc
'''
#We know that asm2 receives two arguments
def asm2(arg1, arg2):
#asm2:
    #<+0>:  push   ebp
    #<+1>:  mov    ebp,esp
    #<+3>:  sub    esp,0x10

    #<+6>:  mov    eax,DWORD PTR [ebp+0xc]
    eax = arg2

    #<+9>:  mov    DWORD PTR [ebp-0x4],eax
    local1 = eax

    #<+12>: mov    eax,DWORD PTR [ebp+0x8]
    eax = arg1

    #<+15>: mov    DWORD PTR [ebp-0x8],eax
    local2 = eax

    #<+18>: jmp    0x509 <asm2+28>
    #<+20>: add    DWORD PTR [ebp-0x4],0x1
    #<+24>: sub    DWORD PTR [ebp-0x8],0xffffff80
    #<+28>: cmp    DWORD PTR [ebp-0x8],0x63f3
    #<+35>: jle    0x501 <asm2+20>
    while(local2 <= 0x63f3):
        local1 = (local1 + 1) & 0xffffffff              #This truncates the result to 32 bits.
        local2 = (local2 - 0xffffff80)  & 0xffffffff    #This truncates the result to 32 bits.           
    '''
       It is necessary to truncate the restuls because in python does not have
       buffer overflow but 0x86 can have so we have to truncate it.
       '''

    #<+37>: mov    eax,DWORD PTR [ebp-0x4]
    #<+40>: leave
    #<+41>: ret
    return hex(local1)

print(asm2(0xb, 0x2e))

Como dige anteriormente, el script es una "traducción" como hice antes pero con sintáxis de Python 3. Después de ejecutar el código obtendremos la bandera.

Espero les haya sido de tanta utilidad como a mí, cualquier duda no duden en enviarme un mensaje.

Link del post original: https://mregraoncyber.com/picoctf-writeup-asm2/

Enviar correos desde Gmail usando tu propio dominio

rooyca — Sun, 17 Jul 2022 22:03:21 +0000

¿Cansado de pagarle a tu proveedor mes a mes para poder usar tu(s) correo(s)? Pues ya no más porque hoy aprenderemos a configurar nuestras cuentas de correo con Gmail en cuatro sencillos pasos.

Primero - Redireccionar el trafico

Lo primero que debemos hacer es redireccionar el trafico de nuestro cuenta de correo electrónico (en este caso me@rooyca.xyz) hacia Gmail. Para ello vamos a nuestro proveedor de dominio o nuestro CDN de preferencia, en mi caso CloudFlare. Ahora nos dirigimos a la parte de Email > Routes > Create address.

Creamos nuestra dirección apuntando al Gmail con el que vamos a configurar nuestra cuenta.

Listo, con esto habríamos finalizado el primer paso. Ahora mismo deberíamos estar recibiendo todos los correos enviados al correo que configuramos (en mi caso me@rooyca.xyz) en nuestra cuenta de Gmail. Es recomendable ensayar que todo está funcionando correctamente enviándote un correo desde otra cuenta. Si todo funciona de manera correcta continuamos. (Si presentas algún inconveniente no dudes en dejarme un comentario).

Segundo - Creando la contraseña

A continuación necesitaremos crear las credenciales con las que ingresaremos más tarde. Para ello damos clic en nuestra imagen de perfil y después en Gestionar tu cuenta de Google.

Vamos a la pestaña de Seguridad, en el panel de la izquierda y bajamos un poco hasta encontrar la opción Contraseñas de aplicaciones

Creamos unas nuevas credenciales. En tipo ponemos correo y en dispositivo ponemos otra.

Ahora ponemos la cuenta que creamos en el paso uno.

Listo, se generarán nuestras credenciales, guárdalas en algún lugar porque las necesitaremos más adelante.

Tercero - Importando nuestra cuenta

Ahora nos vamos a configuración > ver todos los ajustes.

Después nos dirigimos a Cuentas e importación > Añadir otra dirección de correo electrónico

Nos aparecerá una ventana emergente en la que debemos ingresar el nombre de nuestra cuenta (el que aparecerá cuando enviemos un correo) y nuestra dirección de correo creada en el primer paso. Es importante asegurarnos de que la opción Tratar como alias está deshabilitada.

Aquí es IMPORTANTE ingresar:

smtp.google.com

En la parte de Servidor SMTP

En Nombre de usuario ponemos la cuenta de gmail que estamos usando pero sin el @gmail.com, en mi caso sería rooyca. Por último, en contraseña ingresamos la que creamos en el anterior paso. Lo demás lo dejamos tal cual está.

Después de dar en añadir cuenta nos aparecerá una ventana en la que nos pedirá un código de verificación.

Revisamos nuestro bandeja de entrada y deberíamos tener un coreo con el código de verificación y un enlace para completar la verificación.

Copiamos y pegamos el código en la ventana. Y después damos click en el enlace.

Se nos abriría una nueva pestaña en la que confirmaremos que deseamos enviar correos con la cuenta que creamos.

Si nos dirigimos a la parte de Redactar podremos observar que ya podemos enviar correos desde nuestra dirección.

Y eso sería todo, así de fácil es configurar una dirección de correo con nuestro dominio. Recuerda, si tienes alguna duda, queja, sugerencia o reclamo no dudes en hacérmela saber.

PD: Disculpas por la calidad de las imágenes :(

Discord: rooyca#6075
Telegram: @seiseiseis

Alojar Wordpress en la nube (Google Cloud)

rooyca — Sat, 09 Jul 2022 22:05:16 +0000

¿Has pensado en alojar tu sitio con WordPress en la nube, pero no sabes cómo? Hoy aprenderemos juntos el proceso para correr nuestro sitio en Google Cloud, pero un proceso similar podría utilizarse para correrlo en cualquier otra plataforma como AWS o Azure.

Creando la Máquina Virtual

"WordPress es un sistema de gestión de contenidos lanzado el 27 de mayo de 2003, enfocado a la creación de cualquier tipo de página web". Según estas veinte estadísticas sobre WordPress para el 2022 encontramos que WordPress es usado por el 43.2% de todas las páginas en Internet.

Para poder correr WordPress en Google Cloud (GCloud de ahora en adelante), primeramente debemos crear una máquina virtual con una de las imágenes con las que cuenta GCloud. Para ello vamos a la parte superior izquierda, damos clic en "Más Productos" y buscamos "Marketplace".

Se nos abrirá una ventana en la que buscaremos WordPress y le daremos a la primera opción (openlitespeed-wordpress)

A continuación vamos a darle a "Iniciar", después de esto se nos abrirá una ventana en la que podremos modificar las características que tendrá nuestra máquina virtual, mi recomendación es que la dejemos tal como se ve en la siguiente imagen (por supuesto escogiendo un nombre diferente). Todo lo demás que no se alcanza a ver en la imagen es porque deberemos dejarlo tal cual está. Presionamos, aceptar Términos y Condiciones y luego crear.

Y listo, eso sería todo, ya tenemos configurada nuestra máquina virtual. El resultado final debería ser algo como lo siguiente:

Iniciando sesión en nuestra MV

Para poder completar la instalación de WordPress y demás complemento en nuestra máquina virtual, es necesario completar una serie de pasos.

Primeramente, debemos instalar Google Cloud CLI, en el siguiente link encontrarás una guía completa con todo el proceso, pero si lo que deseas es únicamente instalarlo puedes abrir una Power Shell como Administrador y ejecutar el siguiente comando:

(New-Object Net.WebClient).DownloadFile("https://dl.google.com/dl/cloudsdk/channels/rapid/GoogleCloudSDKInstaller.exe", "$env:Temp\GoogleCloudSDKInstaller.exe")

& $env:Temp\GoogleCloudSDKInstaller.exe

Una vez hecho esto e instalado el CLI vamos a Inicio y buscamos "gcloud" abrimos el primer resultado y ejecutamos:

gcloud auth login

Se abrirá una ventana del navegador en la que tendremos que escoger nuestra cuenta de Google con la que creamos la máquina virtual. Damos aceptar a todo y listo.

Una vez la consola nos diga que estamos logeados de manera exitosa tendremos que correr el siguiente comando:

gcloud compute ssh --zone "TU_ZONA" "NOMBRE_MAQUINA_VIRTUAL"  --project "NOMBRE_PROYECTO"

Nos abrirá una ventana en la que deberemos ingresar nuestro dominio y un correo para poder configurar el SSL.

Después de realizar este proceso nos dirigimos a:

http://NUESTRA_IP/wp-admin

Para instalar WordPress.

"Aumentando" la memoria RAM

Es muy poca la memoria RAM que configuramos para nuestra máquina virtual, por lo que es altamente recomendable hacer Swap. "El Swap es el espacio que el disco duro tiene para intercambiar la memoria física con la memoria virtual". Para ello vamos a ejecutar los siguientes comandos, en orden:

sudo fallocate -l 1GB /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
free -m

#Para que cuando se reinicie el servidor conservemos el archivo SWAP
echo '/swapfile none swap sw 00' | sudo tee -a /etc/fstab

Y eso sería todo, así de sencillo es correr WordPress en Google Cloud.

Recuerden que si tienen alguna duda pueden escribirme por:

Discord: rooyca#6075
Telegram: @seiseiseis

Hasta la próxima. Que tengan un excelente día.

Hacer Deploy de FastAPI y Celery (con RabbitMQ y PostgreSQL) en Heroku

rooyca — Sat, 09 Jul 2022 22:05:02 +0000

Como ya es conocido por todos, plataformas como Heroku y Netlify nos permiten desplegar nuestros proyectos y páginas web sin costo alguno. El día de hoy haremos uso de Heroku para desplegar un proyecto de Scraping hecho con FastAPI.

Heroku

Heroku es una Plataforma como Servicio (PaaS) que le permite a los desarrollados construir, ejecutar y operar aplicaciones enteramente en la Nube.

Heroku cuenta (a la fecha) con cuatro planes:

Gratis
- Aplicaciones no comerciales, pruebas de concepto y proyectos personales.
Producción ($25 o más)
- Aplicaciones de negocios, tales como Aplicaciones y Apis internas de empresas.
Avanzado ($250 o más)
- Aplicaciones con funcionalidades complejas que requieren alta disponibilidad, muy poca latencia y manejo de altos volúmenes de peticiones.
Empresa (Precio por definir)
- Aplicaciones de organizaciones a gran escala.

Más información

Scraping con FastAPI

Uno de los problemas que encontré a lo largo del desarrollo de este proyecto fue el de los tiempos de respuesta. Cuando se hace una petición a la API para que obtenga la información de una lista de Letterboxd, dicho proceso puede tomar algunos segundos, incluso minutos. El problema radica en que el servidor se queda "pegado" tratando de responder a la solicitud por lo que no es posible realizar una nueva petición. Como podrán imaginar, esperar hasta UN minuto por solicitud no es nada practico ni agradable, por lo que aquí es donde entra Celery y RabbitMQ.

En la pagina oficial de Celery encontramos lo siguiente:

Celery is a simple, flexible, and reliable distributed system to process vast amounts of messages, while providing operations with the tools required to maintain such a system. It’s a task queue with focus on real-time processing, while also supporting task scheduling.

Y en la página de RabbitMQ:

RabbitMQ is a messaging broker - an intermediary for messaging. It gives your applications a common platform to send and receive messages, and your messages a safe place to live until received.

En pocas palabras, y con posibilidades de caer en equivocaciones, podríamos decir que Celery se encarga del manejo de las solicitudes para que estas puedan procesarse en "segundo plano" y así liberar el End Point para continuar recibiendo peticiones. Esto se logra -a muy grandes rasgos- asignándole una ID a la tarea, esta ID es la respuesta de esa primera petición. Con dicha ID podemos, en otro End Point, estar pendientes de nuestra tarea, cuando ya esté lista recibiremos el JSON de la lista de películas.

Ahora bien, entonces ¿cuál es la función de RabbitMQ en todo esto?

"Sencillo", RabbitMQ lo que hace es almacenar la solicitud y la respuesta que genera Celery.

De las dos definiciones anteriores ruego se tome en serio muy poco de lo expuesto y en lugar aconsejo que se haga una investigación por cuenta propia.

¿Dónde correr RabbitMQ?

Para esto encontré dos opciones:

Google Cloud o cualquier plataforma similar (AWZ, Azure, etc.)
CloudAMQP

En este caso vamos a utilizar la primer opción, pero si deseas probar la segunda puedes dar click en el enlace de arriba y encontrarás una guía completa.

La pregunta es, ¿cómo hice para correr RabbitMQ con Google CLoud? Fácil, hice uso de Contenedores. Primero busqué la imagen de RabbitMQ para posteriormente correrla... todo muy sencillo hasta ahí.

El problema vino a la hora de tratar de obtener una IP externa. Lo que hice fue lo siguiente. En la consola de Google Cloud corrí:

(Remplazando todo lo que está completamente en Mayúsculas)

gcloud container clusters get-credentials [NOMBRE_CLUSTER] --zone [ZONA_CLUSTER]

Después, para exponer el servicio:

kubectl patch service/SERVICO_NOMBRE-rabbitmq-svc \
  --namespace default \
  --patch '{"spec": {"type": "LoadBalancer"}}'

Por último, para obtener la IP externa y los puertos:

kubectl get service SERVICO_NOMBRE-rabbitmq-svc

¿Cómo correr Celery en Heroku?

Como sabrán, a la hora de correr un APP en Heroku necesitamos un archivo llamado Procfile en el que le especificamos a Heroku los comando que se ejecutarán a la hora de iniciar la aplicación.

Entonces, para poder ejecutar FastAPI y Celery a la vez necesitamos que nuestro archivo Procfile luzca algo así:

web: gunicorn -w 3 -k uvicorn.workers.UvicornWorker main:app
worker: celery -A main.celery worker -Q letterboxList

Donde main hace referencia al nombre del archivo principal.
app y celery hacen referencia al nombre de las variables dentro del main archivo que se encargan de iniciar FastAPI y Celery, respectivamente.
Por último, letterboxList hace referencia al nombre de la tarea.

Ya para finalizar, en mi caso tuve que realizar un paso más.

Tuve que dirigirme a la página de Heroku, seleccionar el APP que había creado, darle en Resources y revisar que los dos Dynos estuvieran activados. En mi caso el de worker no lo estaba así que tuve que darle al icono del Lápiz (la opción de editar Dyno) y activarlo.

Y eso sería todo, así de sencillo es correr FastAPI y Celery en Heroku. Por último, si desean ver el resultado final de este proyecto pueden dar click aquí.

Recuerden que si tienen alguna duda pueden escribirme por:

Discord: rooyca#6075
Telegram: @seiseiseis

Hasta la próxima. Que tengan un excelente día.

Como extraer la obra completa de Shakespeare de una Imagen

rooyca — Sat, 09 Jul 2022 22:04:06 +0000

¿Te gustaría leer la obra completa de uno de los grandes de la literatura inglesa pero piensas que es demasiado extensa como para descargarla? Pues el día de hoy te tengo la solución, vamos a extraérla desde una pequeña imagen (2 Megabytes) con su rostro...

Esteganografía

¿Qué es?

A diferencia de la criptografía, donde es obvio que se está ocultando algo, la esteganografía oculta la información de tal forma que no se levante sospechas de que hay algo oculto. Esto se consigue por medio de diferentes técnicas que nos permiten ocultar archivos, imágenes, textos o incluso vídeos dentro de otros archivos.

¿Cómo funciona?

Hay diferentes técnicas para ocultar información dentro de archivos. Una de las más usadas y quizás la más sencilla de entender es la comúnmente conocido como "Técnica del Bit menos significante" o LSB (por sus siglas en inglés).

Esta técnica lo que hace es cambiar algunos de los últimos bits en un byte para codificar el mensaje. Esto es útil en imágenes, donde el valor del rojo, verde y azul están representados por bits (un byte) en un rango de 0 a 255 (ver RGB) en decimales o de 00000000 a 11111111 en binario.

Cambiar el valor de los últimos dos bits en un pixel completamente rojo de: 11111111 a 11111101 unicamente cambia el valor de rojo de 255 a 253, lo cual a simple vista crea un cambio prácticamente imperceptible, pero que aún así nos permite ocultar información dentro de la imagen.

El anterior diagrama muestra dos imágenes de 4 pixeles cada una, junto a su respectivo valor binario. (Fuente)

Como dijimos anteriormente, esta técnica funciona muy bien con archivos multimedia, pero no tanto con archivos de texto ASCII donde un simple bit puede cambiar los caracteres completamente. Sin mencionar que el LSB es la técnica más sencilla de detectar.

¿Cómo usarla?

Recuerda que hay muchas técnicas de esteganografía, unas mejores que otras. Por lo general lo mejor es evitar la LSB e ir por algo un poco más sofisticado. Incluso, ¿por qué no?, diseñar tu propio algoritmo de esteganografía.

También es importante tener presentes los conceptos de encriptar y comprimir. Si encriptamos la información antes de ocultarla le añadimos una capa más de seguridad, mientras que comprimir la información nos permitirá añadirle más información a nuestro archivo.

Para el desarrollo de este tutorial, vamos a utilizar Steghide, una herramienta sencilla de usar pero no por ello menos eficaz.

1. Ocultando información

Primeramente vamos a instalar Steghide, por medio de apt.

sudo apt-get install steghide

Una vez instalado procemos a ocultar nuestra información, con el siguiente comando:

steghide embed -ef archivoSecreto -cf archivoDePortada -sf archivoFinal -z nivelDeCompresion -e esquema

Ahora vamos a explicar los argumentos que acabamos de utilizar:

-ef especifica la ruta del archivo que queremos ocultar. Podemos ocultar cualquier tipo de archivos dentro de nuestro archivo, incluyento scripts en Python.
-cf este es el archivo en el cual ocultaremos nuestra información. Aquí si hay restricciones, solo se permiten archivos del tipo BMP, JPEG, WAV y AU.
-sf es un argumento opcional que especifica el nombre del archivo resultante de esta "unión". Si no lo especificamos el archivo original será sobrescrito.
-z especifica el nivel de compresión, en un rango de 1 a 9. Si prefiere no comprimir su archivo use el argumente -Z
-e especifica el tipo de encriptación. Steghide soporta una gran cantidad de esquemas de encriptación y si se omite este argumento Steghide usará la opción por defecto que es 128-bit AES. Si prefieres no usar encriptacion simplemtente escribe -e none

En el siguiente ejemplo, ocultaré un archivo de texto dentro de una imagen de un tierno cachorro (para levantar menos sospecha 😉). El archivo final se llamará "perrito-secreto.jpeg", no voy a hacer uso del compresor ni del encriptador, y el comando en la terminal luciría algo así:

steghide embed -ef secret.txt -cf perrito.jpeg -sf perrito-secreto.jpeg -e none -Z

Después de ingresar nuestro comando Steghide nos pedirá que le asignemos una contraseña a nuestro archivo. Una vez ingresamos la passphrase tendremos nuestro archivo con información confidencial dentro de él 😄.

El resultado sería una imagen común y corriente... Si deseas saber lo que hay dentro del archivo de texto, aquí te dejo la imagen (password: topsecret):

2. Extrayendo información

El proceso de extraer la información de nuestros archivos es incluso más sencillo. El comando que deberemos ejecutar es el siguiente:

steghide extract -sf archivoSecreto -xf archivoFinal

Cuando ejecutamos este comando nos pedirá la contraseña, la ingresamos y deberíamos tener todos los archivos que se encontraban dentro del archivoSecreto

Ahora bien, te estarás preguntando, ¿cómo hago para extraer información de un archivo si no tengo la contraseña? Pues actualmente existen infinidad de herramientas que nos pueden ayudar con eso. Pero el día de hoy vamos a hacer uso de binwalk.

Como lo prometí en un principio, vamos a extraer la obra completa de Shakespeare de la siguiente imagen:

O si prefieres puedes visitar el post original en Twitter.

Al correr nuestro binwalk (binwalk shakespeare.jpg) nos indica que la imagen esta compuesta de 31 archivos RAR.

Procedemos a extraer los archivos de la siguiente manera
binwalk -e -C ./shake shakespeare.jpeg

Lo que creará una carpeta "shake" en nuestro directorio actual. Al ejecutar el comando nos extraerá los 31 archivos RAR, y al extraer el primero de ellos(shakespeare.-part001.rar) nos quedará un último archivo llamado shakespeare.html que al abrirlo, nos saldrá algo así:

¿Increíble no?

Bueno, eso sería todo por el día de hoy. Si quieres expander tus conocimientos sobre este tema te recomiendo leer este y este articulo. ¿Eso no es suficiente? Te recomiendo este curso de CTF, que abarca estos temas y muchos más. Y recuerda, si tienes alguna duda, queja, sugerencia o reclamo no dudes en hacérmelo saber.

Discord: rooyca#6075
Telegram: @seiseiseis

Una guía para compartir archivos en la Blockchain con IPFS

rooyca — Sat, 09 Jul 2022 21:43:23 +0000

Antes de nada, ¿qué es IPFS? La descripción oficial que encontramos en su sitio web es la siguiente:

Un protocolo hypermedia peer-to-peer diseñado para preservar y hacer crecer el conocimiento de la humanidad haciendo la web más abierta, más resiliente y mejor.

IPFS, o Interplanetary File System, creado por Protocol Labs, es un protocolo peer-to-peer donde cada nodo almacena una colección de archivos hasheados. Un usuario que desee alguno de esos archivos se conecta a una capa de este protocolo y por medio del Hash, IPFS se encarga "recolectar" el archivo que está distribuido a través de los nodos y finalmente envía el archivo al usuario que lo solicitó.

Fuente: https://radiostud.io/

¿Recuerdan BitTorrent? Pues es parecido, solo que con IPFS tienes más control de tus archivos y se hace referencia a tus archivos por medio de hashes.

¿Y la seguridad?

Como habrán podido deducir, en IPFS "cualquiera" puede tener acceso a nuestros archivos, lo único que se necesita es un Hash del tipo: QmYqSCWuzG8Cyo4MFQzqKcC14ct4ybA... para descargar nuestro archivo. Lo que nos llevaría a concluir que IPFS no es el protocolo indicado para archivos "sensibles"... ¿o sí?

Con ustedes, Encriptación Asimétrica (EA)

Por suerte, contamos con herramientas que nos permiten asegurar nuestros archivos antes de subirlos a IPFS. La EA nos permite encriptar el archivo con la clave publica del destinatario, lo que garantiza que terceros no puedan hacer nada con el archivo. Para este tutorial usaremos GPG.

Manos a la obra

En este tutorial, haremos lo siguiente:

Configurar GPG.
Configurar IPFS.
Encriptar un archivo con la clave publica de alguien.
Subir un archivo encriptado a IPFS.
Descargar dicho archivo desde otra máquina y asegurarnos de que solo el destinatario pueda ver su contenido.

Instalación de lo que usaremos

GPG

Tendremos que descargar GPG en ambas maquinas, la que envía y la que recibe, para ello nos dirigimos a este link y seguimos las instrucciones dependiendo de nuestro sistema operativo. Una vez instalado vamos a generar una clave en ambos equipos, para ello usamos el siguiente comando:

gpg --gen-key

Luego nos pedirá nuestro nombre, correo, un comentario y una contraseña, que entre más robusta mejor.

Ahora, en nuestro segundo equipo, después de generada la clave, la vamos a exportar con el siguiente comando:

gpg --export --armor > clavePublica.asc

Pasamos nuestro archivo a nuestro segundo pc, e importamos la clave con el siguiente comando:

gpg --import clavePublica.asc

Podemos revisar nuestras claves con el siguiente comando:

gpg --list-keys

Listo, eso sería todo en cuanto a GPG, ahora vamos a configurar nuestro nodo.

IPFS

Existen varias alternativas a la hora de descargar IPFS, en el siguiente enlace podremos usar la que nos parezca mejor. En mi caso usaré la terminal, una vez instalado podremos iniciar nuestro nodo con el siguiente comando:

ipfs init

Recuerda que esto debes hacerlo en ambos computadores. Después de esto deberemos iniciar nuestro programa (daemon: Disk And Execution MONitor)

ipfs daemon

Y listo, ya tendríamos nuestros nodos preparados para subir y bajar archivos.

Encriptando nuestro archivo con GPG

Ahora vamos a encripar nuestro archivo para que solo pueda ser desencriptado por el receptor, para ello vamos a correr el siguiente comando:

gpg --encrypt --recipient "Nombre del que recibe" archivo.pdf

En el que podrán notar dos variables, el nombre de la persona que lo recibe (que debe ser el mismo que pusimos en la clave pública que generamos anteriormente), en mi caso seria "Rooyca" y después pondremos nuestro archivo, que en mi caso es un pdf. Nos quedará un archivo con extensión .gpg.

Subiéndolo a IPFS

Una vez que tenemos todo preparado podemos abrir nuestra terminal y subir nuestro archivo encriptado a IPFS con el siguiente comando:

ipfs add archivo.pdf.gpg

Podemos comprobar que subimos correctamente nuestro archivo con el comando:

ipfs pin ls

Aquí debemos buscar el Hash que coincida con el resultado de nuestro comando anterior, en mi caso seria:

QmazcLvRjPMLY5UAGEDVLrJCKX3ySqb8TZxLmvt7pfbxgf

Descargando de IPFS

Ahora, para descargar nuestro archivo es igual de sencillo, en nuestro segundo computador ingresamos ipfs get junto al hash del archivo.

ipfs get QmazcLvRjPMLY5UAGEDVLrJCKX3ySqb8TZxLmvt7pfbxgf

Ya tendriamos nuestro PDF, pero si intentamos abrirlo nos daremos cuenta que no es posible ver su contenido, por lo que procedemos a desencriptarlo.

Desencriptando

Para ello vamos a ingresar el siguiente comando, en el que le pasamos el nombre del archivo y ">" para cambiarle el nombre a "archivodes.pdf".

gpg --decrypt QmazcLvRjPMLY5UAGEDVLrJCKX3ySqb8TZxLmvt7pfbxgf > archivodes.pdf

Y listo, si ahora lo volvemos a abrir podremos acceder de manera normal a nuestro pdf. Así de sencillo es mandar archivos confidenciales o sensibles a través de una excelente plataforma como es IPFS.

Bueno, eso es todo por hoy, espero que esta pequeña guía los haya animado a mantener su propio nodo y ha hacer uso de este grandioso protocolo. Como siempre, si tienen alguna duda o simplemente desean decirme algo no duden en contactarme.

Discord: rooyca#6075
Telegram: @seiseiseis

Publicación original

Blockgeni.com

Crea tu primera API con FLASK

rooyca — Sat, 09 Jul 2022 21:39:55 +0000

El día de hoy vamos a ver cómo crear una sencilla API con Flask. Este es un proyecto que a primera vista parece complicado, pero ya cuando iniciamos nos damos cuenta de que es todo lo contrario; muy sencillo y divertido de realizar, así que te invito a alistar tu IDE y manos a la obra.

Antes que nada, aqui te dejo el link por si deseas clonar directamente el repositorio de Github.

Desarollando nuestra API

Para este tutorial vamos a utilizar principalmente el "Mini"-Framework Flask y algunas extenciones del mismo. Para la instalación de todos los paquetes me gustaria dejarte dos opciones:

Instalar los siguientes paquetes con el comando pip install x-paquete
flask
flask_restful
flask_sqlalchemy
Descargar el el archivo requirements.txt e instalar todo de una vez con el comando pip install -r requirements.txt

La primera opcion nos permite ir familiarizandonos poco a poco con las herramientas que vamos utilizando a lo largo de este tutorial y la segunda nos agiliza el trabajo.

¿Cuál usar? Depende de...

Estructura de nuestra API

Vamos a explicar de manera súper básica la estructura de nuestra API. Para mayor informacion te invito a visitar la documentacion oficial de FlaskRESTful.

1. from flask import Flask
2. from flask_restful import Api, Resource, marshal_with, fields
3. from flask_sqlalchemy import SQLAlchemy

4. app = Flask(__name__)
5. api = Api(app)
6. app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///Players.db'
7. db = SQLAlchemy(app)

En las lineas uno, dos y tres importamos Flask, algunas clases desde flask_restful y SQLAlchemy, que será la encargada de realizar las conexiones con nuestra base de datos. Depués, de la linea cuatro a siete realizamos la configuracion de nuestra aplicacion y establecemos una conexion a través de sqlite con nuestra base de datos.

class Players(db.Model):
    __tablename__ = "players"
    id = db.Column(db.Integer, primary_key=True)
    region = db.Column(db.String, nullable=False)
    name = db.Column(db.String, nullable=False)
    puuid = db.Column(db.String, nullable=False)


resource_fields = {
    'id':fields.Integer,
    'region':fields.String,
    'name':fields.String,
    'puuid':fields.String
}

Aquí primero creamos la clase Players que será la encargada de manejar la "extructura" de nuestra base de datos. Como podemos ver, creamos una tabla llamada players y cuatro columnas. Por último creamos un diccionario llamado resource_fields para serializar nuestra informacion de tal manera que podamos mostrarla en formato JSON. (¿Qué es JSON?)

class Player(Resource):
    @marshal_with(resource_fields)
    def get(self, name):
        result = Players.query.filter_by(name=name).first()
        return result

api.add_resource(Player, "/<string:name>")


if __name__ == "__main__":
    app.run(host='0.0.0.0')

Por último, creamos la clase Player que organizará los datos de nuestra base de datos de la forma en que le especificamos en nuestro diccionario resource_fields. Luego definimos una función get que tomará como argumantos self y el nombre del jugador del cual queremos conocer la información. Con estos datos hacemos un query a nuestra base de datos, diciéndole que nos muestre el primer el primer jugador llamado name.

api.add_resource(Player, "/<string:name>") es una de las partes fundamentales de nuestro código, pues es aquí donde especificamos la ruta a la cual se hará la request, o dicho de otra forma, es aquí donde definimos nuestro Endpoint. En este caso sería simplemente a la ruta de inicio, es decir:

https://0.0.0.0:8000/Bluegod

Por último, la parte de if __name__ == "__main__": sencillamente evita que se ejecute la aplicación cuando es importada por otro script y en la parte de app.run(host='0.0.0.0') podriamos añadirle debug=True para que cada que realizamos un cambio y tenemos nuestra aplicación corriendo este cambio se aplica inmediatamente después de guardar, esto ayuda mucho cuando estamos testeando o añadiendo nuevas funciones, pero se recomienda quitarlo a la hora de hacer deploy de nuestra App.

Y... ya, eso sería todo, si hemos seguido correctamente todos los pasos hasta aquí deberiamos tener nuestra API funcionando. ¡Vamos a probarla!

¡Excelente! Sí funciona.

Bueno, eso sería todo por el día de hoy. Si quieres probar esta API AQUÍ te dejo un link en el cual podras hacerlo. Y recuerda, si tienes alguna duda, queja, sugerencia o reclamo no dudes en hacérmelo saber.

Discord: rooyca#6075
Telegram: @seiseiseis

Creando nuestros comandos personalizados en Linux

rooyca — Sat, 09 Jul 2022 21:34:29 +0000

¿Cansando de tener que escribir veinte variables para ejecutar un simple comando? Pues hoy aprenderemos a mapear nuestros comandos haciendo uso de Alias.

Creando nuestros Aliases

Alias es una forma sencilla de mapper, bindear, unir(?) comandos. Esta es la mejor manera de ahorrarnos tiempo a la hora de escribir cadenas larguísimas de comandos. Si nosotros escribimos "alias" en nuestra terminal debería aparecernos los aliases predeterminados de nuestro sistema, algo así:

Como podran notar, en mi caso tengo dos alias customizados: price y subl; el primero es un script en python que uso para ver el comportamiento del mercado crypto y el segundo es simplemtente para abrir SublimeText.

Modificando nuestro archivo .bashrc

Para poder lograr que nuestros alias sean permanentes y no solo durante una seccion de la terminal debemos modificar un archivo llamado .bashrc, que por lo general se encuentra en /home/usuario/ para esto debemos abrirlo con el editor de texto de nuestra preferencia, en mi caso voy a utilizar vim:

vim ~/.bashrc

Bajamos hasta encontrar la seccion de Aliases y añadimos nuestro comando de la siguiente manera:

alias nuestro-comando='comando-a-mapear'

Un ejemplo más claro sería el siguiente:

alias price='python3 ~/Desktop/get_price.py'

En donde "price" es el comando que le quiero asignar a la cadena: "python3 ~/Desktop/get_price.py". Ahora lo último que nos queda es guardar los cambias y listo, así de sencillo tenemos nuestro comando personalizado.

Eso sería todo, si tienen alguna duda no duden en hacermelo saber.