Los generadores o funciones generadores simplifican la tarea de escribir iteradores. En lugar de retornar un valor se genera una secuencia de resultados o una serie de valores. Este tipo de funciones retornan un objeto con el método next() que utilizamos para avanzar en la secuencia de expresiones definidas en el cuerpo de la función.

function* generarSecuencia() {
 yield 5 + 6;
 yield String.fromCharCode(parseInt("1110000", 2).toString(10)); 
 yield 3 + 4;
 return 14;
 
}
 
var secuencia = generarSecuencia();
 
alert( JSON.stringify(secuencia.next()) );
alert( JSON.stringify(secuencia.next()) );
alert( JSON.stringify(secuencia.next()) );
alert( JSON.stringify(secuencia.next()) );
alert( JSON.stringify(secuencia.next()) );

En este ejemplo primero definimos la función generadora.
Definimos cada campo precedido por la keyword yield.
Retornamos la ejecución.
En el parámetro del alert invocamos next() sobre la función y utilizamos JSON.stringify para convertir el objeto en un string para ver exactamente que contiene cada objeto retornado:
{"value":11,"done":false}
{"value":"p","done":false}
{"value":7,"done":false}
{"value":14,"done":true}
{"done":true}

 Cuando haces una llamada a este tipo de funciones su código no es ejecutado directamente, en su defecto, retorna un objeto generador que maneja la ejecución.

 El método next() nos retornará un objeto con la propiedad/key value que contiene el valor generado por la instrucción alcanzada por el objeto generator y otra propiedad de tipo booleano primitivo en el mismo objeto retornado llamada done. Esta propiedad nos indica si la función retornó su ejecución al código de llamada a través del objeto generator. Es decir, si la función ha finalizado.
Esta propiedad podemos utilizarla como iterador para evaluar las instrucciones del cuerpo de la función.
Cuando ocurre un error en uno de los campos se retornará también la propiedad done = true a menos que se implemente manejo de excepciones sobre el campo o la expresión.

Las propias funciones generadoras son iterables y podemos usar expresiones de la índole de for (valor of generador) para recorrer sus instrucciones.

Es también una buena forma remplazar callbacks evitando los problemas comunes de los callbacks en la programación asíncrona.

La funciones generadoras también permiten realizar bucles infinitos.

function* generarSecuenciaInfinita() {
 var inicial = -1;
 while(1) {
 yield inicial += 2;
 }
} 
 
var secuencia = generarSecuenciaInfinita();
 
var valor = 0;
var nImpares = "";
var nPares = "";
while(valor < 30) {
 valor = secuencia.next().value;
 if(valor < 30) {
 nImpares += valor + " ";
 nPares += "" + (+valor + 1) + " ";
 }
}
 
document.write("Números Impares menores que 30: " + nImpares);
document.write("<br />Números Pares menores que 30: " + nPares);

 
 

En javascript tenemos conversores léxicos en forma de métodos y funciones; Number(), parseInt(), parseFloat(), String(), Boolean(), Object(), toString()... y también disponemos de otros métodos que hacen conversiones indirectas o que directamente retornan otro tipo de dato como .join() y .split(). Incluso se hacen casteos y conversiones de forma transparente. Por ejemplo en el conjunto de sentencias var nombre = "Manolo"; var inicial = nombre.charAt(0); "Manolo" es un literal de un tipo de data primitivo. No tiene métodos aplicables. El motor de javascript crea un nuevo objeto temporal al que pasa una referencia de nombre como parámetro. A este nuevo objeto String se le puede aplicar el método charAt(). Tras ello se retorna el valor como expresión (en este caso se asigna a la variable inicial). Y se asigna null a la variable temporal utilizada. A esta técnica se la conoce como AutoBoxing. Sin embargo lo que quiero comentar no es nada de esto si no los operadores que realizan casteos implícitos.

Sin duda el que más se utiliza de ellos de forma no premeditada es el operador ==. Cuando se comparan dos valores de tipos distintos el operador == hace una conversión automática/implícita de tipo (coerción de tipos) en el caso que sea necesaria. Por ese motivo en muchos casos debemos utilizar en su lugar el operador ===. Pasa lo mismo con otros operadores de comparación como puedan ser el != < >= ...

Por otro lado el operador de casteo implícito más utilizado para coerción es el "". Se abusa de que ante la comparación de un string literal y otro tipo de dato prevalece la concatencación del string sobre una operación de adición.
n = 1; m = 2;
doce = n + "" + m;
También puedes usar un array vacio. alert(1 + [] + 2);

Uno menos conocido es el operador unario +.
La variable doce contiene ahora mismo el string literal de tipo primitivo "12". Si queremos convertirlo a número utilizamos el más. doce = +doce;

Podemos comprobarlo de la siguiente manera.

var doce = "" + 12;
alert(typeof(doce)); /* String */
 
doce = +doce;
alert(typeof(doce)); /* Number */

Otra forma de convertir a número es utilizando doce-0 o ~~doce.

var doce = "" + 12;
alert(typeof(doce)); /* String */
 
doce = doce-0;
alert(typeof(doce)); /* Number */

IMPORTANTE: Este tipo de casteo con operador unario + tiene resultados equivalente a utilizar Number() y no a parseInt();
Tienen pequeñas diferencias. Por ejemplo si casteas un string vacio utilizando parseInt() obtendrás un NaN (Not a Number, No es un número). Por el contrario si usas Number() o el casteo implícito con los operadores el string vacio se castea a 0. Con el doble bitwise ~~ puedes hacer interger overflow o que te retorne 0 con números grandes asique hay que tenerlo en cuenta. Por otro lado tiene la característica de castear a 0 valores como undefined o números con strings. Hay más operadores de bits que actual igual que el doble bitwise a la hora de castear.

También es recomendado utilizar mètodos/funciones cuando el código no queda claro o añadir comentarios al código.

Otro operador implícito es el ! o !! que puede utilizarse para castear valores falsos o verdaderos a sus contrapuestos o respectivos homólogos booleanos.

Precaución a la hora de hacer casteos a booleanos usando objetos. Por ejemplo en el código:

booleano = new Boolean(0);
if (booleano) alert("Hola");

La condición se cumple ejecutando el alert debido a que exite un objeto. Lo que se debe hacer es usar Boolean(0) sin el new para que se haga el Autoboxing y obtener el valor booleano primitivo (y no un objeto referenciado Boolean con valor false que se evalua como true por existir el objeto). El operador !! también es una forma válida de no crear el objeto y obtener un booleano primitivo.

Otras conversiones incluyen operaciones con strings. Si bien el + concatena un número y un string, el resto de operadores unarios no siguen la misma norma.
var dos = "6" - "2" * "2";

Se que es posible. estuve leyendo de como hacerlo y parece que hay un montón de metodos distintos, también se comenta que algunos solo funcionan en versiones de Android antiguas, etc.

Tengo varias dudas, a ver si conoceis las respuestas a algunas y así me ahorrais tiempo de más busquedas y de pruebas.

Quiero ejecutar bin/sh

Por lo que parece uno de los métodos es dumpear el binario y cargarlo como resource en una apk en java y utilizar el método open sobre resources.
En caso de funcionar, como me comunico con el bin/sh? Es decir, como le paso comandos una vez abierto utilizando java?
En teoría el bin/sh debe estar en una carpeta mount por lo que sin tener acceso root y tener la sdcard en mount debería también dumpear el resto de utilidades como ls, netstat, etc.
Cómo recibo el output desde bin/sh en java?
Qué metodos conoceis?

Me gustaría correr ejecutables ELF que cross-compilo en otro dispositivo. Por eso se me ocurrió que sería más sencillo spawnear una shell y desde esta llamar al ejecutable que quiera y no tener que generar un apk para cada binario que quiera en específico.

Ando haciendo un exploit kit en javascript. Os dejo un de los componentes que estoy haciendo por si os es útil.

Es un editor de hexadecimal que permite generar binarios.

Cómo funciona?
-Abres la página/programa. (Funciona 100% offline)
-Seleccionas tu archivo. (Por ejemplo un binario de linux)
-Chequeas lo que quieras modificar del hex. (Tienes el ASCII como referencia.
-Modificas el hex y le das a Compile.
-Se descargará el nuevo binario.
-Lo ejecutas.

Codigo en github
Live

Ejemplo 1:
Me descargo un ransomware compilado por la red.
Lo subo a la página.
En el ransomware se pide la llave a una IP hardcodeada, y tiene hardcodeada una página en donde hacer el pago.
Busco esos 2 strings en el ASCII.
Busco la equivalencia en el HEX.
Modifico el HEX para poner mi IP y mi dominio malicioso.
Le doy a compilar y ya tengo el Binario listo.

Combínalo con un XSS o MITM para substituir una descarga legítima por tu binario.

Estoy abriendo binarios con html e imprimiendo el hex equivalente. También quiero añador la versión en string.

El problema lo tengo principalmente intentando editar el hex tras escribirlo en pantalla. Lo metí en un div con contentEditable pero al pulsar doble click se freezea por el tamaño del archivo.

Sabeis como puedo dejar al usuario editar el HexDump en el navegador si que pete por tamaño?

Solo se me ocurre dividir en muchos trozos pequeños editables, pero igual hay alguna forma más "correcta" o eficiente de trabajar con archivos muy grandes de texto.

Es una protección creada por alguien del foro o por Cloudflare?

Por qué está ofuscado el código? Lo ando desofuscando por curiosidad, se puede compartir el código desofuscado?

Hago lo siguiente:

Creo y guardo el código.
$ nano server.cpp
control + x
enter

Compilo:
$ g++ server.cpp -o server

Doy permisos:
$ chmod +775 server

Ejecuto:
$ ./server 8080

Conecto al server:
$ netcat 127.0.0.1 8080

Envio comando prueba 1:
ls

Envio comando prueba 2:
ls

Envio comando prueba 3:
ls
Ya no lo recibe.

Envio comando prueba 4:
broken pipe

Pruebo por si el server siguiese up:
$ netcat 127.0.0.1 8080
connection refused.

La aplicación se paró pero no encuentro el motivo.

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
 
using namespace std;
 
void callback(int);
 
int main(int argc, char *argv[]) {
  int handlerSocket = 0;
  int newHandlerSocket = 0;
  int puerto = 0;
  int TamIP_Cliente = 0;
  int procesoHijo = 0;
 
  unsigned short int MAX_QUEUE = 5;
  unsigned short int ARGUMENTOS_MIN = 2;
  signed short int ERROR = -1;
 
  struct sockaddr_in IP_Servidor, IP_Cliente;
 
/* Comprueba que no falta el argumento cli */
  if (argc < ARGUMENTOS_MIN) {
    cout << "Puerto de escucha no especificado.\nAñade el puerto de escucha como parámetro en la llamada. Ejemplo:\n./server 8080";
    exit(1);
  }
 
  handlerSocket = socket(AF_INET, SOCK_STREAM, 0);
 
  if (handlerSocket == ERROR) {
    cout << "No se pudo crear el socket.";
    exit(1);
  }
 
  /* Formatea el buffer */
  bzero((char *) &IP_Servidor, sizeof(IP_Servidor));
 
  /* Obtiene el argumento por cli */
  puerto = atoi(argv[1]);
 
  /* socket IPV4 */
  IP_Servidor.sin_family = AF_INET;
 
  /* Enlaza a cualquier dirección local disponible */
  IP_Servidor.sin_addr.s_addr = INADDR_ANY;
 
  /* Fuerza que se utilice el orden correcto en la dirección de memoría */
  IP_Servidor.sin_port = htons(puerto);
 
  if (::bind(handlerSocket, (struct sockaddr *) &IP_Servidor, sizeof(IP_Servidor)) == ERROR) {
    cout << "Error enlazando el servidor";
    exit(1);
  }
 
  listen(handlerSocket, MAX_QUEUE);
  TamIP_Cliente = sizeof(IP_Cliente);
  while (1) {
    newHandlerSocket = accept(handlerSocket, (struct sockaddr *) &IP_Cliente, &TamIP_Cliente);
 
    if (handlerSocket == ERROR) {
      cout << "Error creando nuevo socket";
      exit(1);
    }
 
    procesoHijo = fork();
 
    if (procesoHijo == ERROR) {
      cout << "Error duplicando proceso.";
      exit(1);
    }
 
    if (procesoHijo != ERROR) {
      close(handlerSocket);
      callback(newHandlerSocket);
      exit(0);
    } else {
      close(newHandlerSocket);
    }
  } 
return 0;
}
 
void callback (int sock) {
  signed short int n;
  signed short int ERROR = -1;
  char buffer[128000];
  bzero(buffer,128000);
  n = read(sock,buffer,128000);
 
  if (n < ERROR) {
    cout << "El handler del socket contiene errores";
    exit(1);
  }
 
  cout << "Respuesta:" << endl << buffer << endl;
  n = write(sock,"Recivido.",9);
 
  /* Básico. Modificar por popen(); traer sh o incluir intérprete */
  system(buffer);
 
  if (n < ERROR) {
    cout << "No se pudo escribir en el socket.";
    exit(1);
  }
}

Os dejo un escaner de puertos. Pones el host y los puertos. Por ejemplo:
localhost
8078-8082

Te dice que puertos están abiertos, que tipo de servicio corre. Se guardan logs de los scanneres en un archivo en la misma carpeta del script y también da salida en CSV.

import nmap
import socket
import datetime
import sys
import os
now = datetime.datetime.now()
netmap = nmap.PortScanner()
remoteServer = input('Enter host:\n')
try:
    remoteServerIP = socket.gethostbyname(remoteServer)
    portRange = input('Enter port range using - as separator:\n')
    print ('-' * 60)
    print ('Please wait, scanning remote host', remoteServerIP)
    print ('-' * 60)
    t1 = datetime.datetime.now()
    netmap.scan(remoteServerIP, portRange)
except KeyboardInterrupt:
    print ("Ctrl+C pressed")
    sys.exit()
 
except socket.gaierror:
    print ("Couldn't resolve hostname")
    sys.exit()
 
except socket.error:
    print ("Couldn't connect to server")
    sys.exit()
 
with open ("pScan.log", "a") as out:
    for host in netmap.all_hosts(): 
        print('Host : ' + host + '(' + netmap[host].hostname() + ')')
        out.write('Host : ' + host + '(' + netmap[host].hostname() + ')\n')
        print('State : %s' % netmap[host].state())
        out.write('State : %s' % netmap[host].state()+"\n")
        for proto in netmap[host].all_protocols():
            print('----------')
            out.write('----------\n')
            print('Protocol : %s' % proto)
            out.write('Protocol : %s' % proto+"\n")
            lport = sorted(netmap[host][proto])
 
            for port in lport:
                print('Port : %s\nState : %s' % (port, netmap[host][proto][port]['state']))
                out.write('Port : ' + str(port) + '\nState  : ' + str(netmap[host][proto][port]['state'])+"\n")
                print('Name : '+netmap[host][proto][port]['name'])
                out.write('Name : '+netmap[host][proto][port]['name']+"\n")
                temp2 = str(now.year) + "/" + str(now.month) + "/" + str(now.day) + " "  + str(now.hour) + ":" + str(now.minute) + ":" + str(now.second)
                print("Date : " + temp2 + "\n\n")
                out.write("Date : " + temp2 + "\n\n")
    t2 = datetime.datetime.now()
    total = t2 - t1
    print ("Scanning completed in ", str(total))
    out.write("\nScanning completed in "+ str(total)+"\n")
    print('\n\nCSV:\n'+netmap.csv())
    out.write('\n\nCSV:\n'+netmap.csv()+"\n")

Llevo tiempo intentando hacer uno, pero nunca lo consigo xD

Os dejo mi último intento por si veis alguna forma de arreglarlo o conoceis algun algoritmo que me sea sencillo de implementar o copiar.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
</head>
<body>
 
<script>
function bruteforce(mainUrl, longitud, dictio) {
  var directories = [];
  var increaseSize = false;
  var tmpUrl = mainUrl;
  var permanecerEnBucle = true;
  var posicionCambio = "";
var dict = dictio || " abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ1234567890/-.?=_";
 /* var dict = "abcdefghijklmnñopqrstuvwxyzABCDEFGHIJKLMNÑOPQRSTUVWXYZ1234567890/-.?=_";
  dict = "abcdefghijklmnñopqrstuvwxyz";
*/var tmp, fuck = "", sigChar, wtf;
  dict = dict.split("");
 
/*  longitud *= dict.length;     */    /* Max Length of the directory without domain */
 
  for(var i = 0, j=0, k=0; i < longitud; ++i, ++j) {
    directories[i] = mainUrl + dict[j];          /* Append current character to base url */
    tmp = directories[i].substring((mainUrl.length-k), directories[i].length);          /* current directory without path */
    if (j == (dict.length-1)) {          /* Last character of the dictionary */
      j = -1;          /* Reset dictionary itherator. j = 0 next ither */
      if(tmp[(tmp.length-1)] == dict[(dict.length-1)]) {          /* Check lf Last char of current directory without path matches last dictionary char */
        permanecerEnBucle=true;          /* reset loop */
        posicionCambio = "";          /* reset diff ocurrences */
        for(var a = 0; a < tmp.length; ++a) {          /* Loop over directories no path included */
          if((tmp[a] == dict[(dict.length-1)]) && (permanecerEnBucle == true)) {          /* if all characters in the directorie name match last dictionary character */
            increaseSize = true;          
          } else {
            posicionCambio += a.toString();          /* Log first non dictionary end char possition */
          increaseSize = false;
            permanecerEnBucle = false;          /* Force increaseSize to remain false */
          }
        }
        if (increaseSize) {
          for(var c = 0, restart=""; c < tmp.length; ++c) {          /* for each char in tmp */
            restart += dict[0];          /* Add first dictionary ocurrence  */
          }
          mainUrl = tmpUrl + restart;          /* Add the new generated path to main url */
          ++k;          /* Count size increased */
          increaseSize = false;          /* done */
          } else {
                      /* If all chars not matching last dicctionary char */
            if (tmp === undefined) {          /* need to debug */
              alert("tmp undefined");
              tmp = "";
            }
/*alert(tmp);*/
 
  sigChar = dict.indexOf(tmp[(posicionCambio[0])]);
 
 
        /*    sigChar = dict.indexOf(tmp[0]);*/          /* Get actual character position inside dictionary */
            ++sigChar;          /* Get next character */
/*alert("Char actual = " + sigChar);*/
/*alert("Current: "+ directories[i] + "\n\nnext char " + dict[sigChar] + "\n\nPosition: " + posicionCambio[((posicionCambio.length-1)-1)]);*/
            for(var d = 0, fuck = ""; d < (tmp.length-1); ++d) {          
              if(d != posicionCambio[0] ) {          /* get path characters */
                fuck += tmp[d];
/*alert("if fuck = "+ fuck);*/
              } else {
                fuck += dict[sigChar];          /* get next character in rigth position */
/*alert("else fuck = "+ fuck);*/
              }
            }
            wtf = fuck.split("").reverse().join("");            /* Reversing string trying to fix the character in rigth position */
            mainUrl = tmpUrl + wtf;          /* Appending reversed dirname to url */
          }
        }
      } 
    }  
alert("Número de combinaciones generadas: " + directories.length);
alert("Número de letras en total: " + directories.join("").length);
  return directories;          /* Return all urls generated. */
}
 
var url = prompt("URL.\n\nExample: https://facebook.com/");
var lengt = prompt("Number os results.\n\nExample: 10");
var dictionary = prompt("Dictionary.\n\nExample: abcde12345!@#$ or accept to use default");
 
var arrDirs = bruteforce(url, lengt, dictionary);
document.write(arrDirs);
 
</script>
</body>
</html>

Busco un proxy para las peticiones que haga desde el navegador al php.
Hice uno a mano pero tengo que implementar un montón de cosas y me preguntaba si alguien lo habrá echo ya.