Puedes descargarte Lua 5.X o Lua Jit para interpretar código LUA.

Lua Rocks para bajarte módulos.

No tiene mucho módulo, tiene poca documentación, muchos errores y demás que tienes que subsanar por tu cuenta. Necesitas conocimientos intermedios-avanzados de sistemas para ir arreglando y configurando cosas muy básicas como puedan ser las rutas en las que se buscan los módulos usando un sistema virtual de ficheros.

El lenguaje en sí tiene un montón de cosas muy sencillas, pero también tiene otras cosas poco friendly para newbies como las patterns (las expresiones regulares de lua), lua sockets(no es ni librería std, por defecto no tiene modulo de red lua y es poco amigable el uso de sockets, las iteración de tablas, comprobaciones constantes para evitar que variables y tablas tengan nil, el stack de C tampoco es demasiado amigable, asique escribir módulos en C para lua tampoco es algo que aprendas a hacer en 2 minutos si no estás acostumbrado...

El lenguaje en sí es muy bueno y potente. El problema es la falta de soporte y la poca comunidad que hay.

A pesar de todo esto, se usa en un montón de programas. Principalmente suele usarse como "añadido" a juegos para tener una consola con la que configurar cosas del juego, hacer chats in-game y cosas similares.

También se usa mucho como lenguaje de scripting para todo tipo de programas. A parte de los que te comenta El Brujo, otro muy popular es Nmap y Ncat.
Nmap te permite agregar scripts para configurar el scanner o hacerle plugins para que haga otras cosas. Lo mismo con Ncat, donde puedes programar un montón de utilidades como podría ser el caso de un pequeño proxy ftp, dns, un scanner, etc.

Otro uso común es el de chicle entre diversas tecnologías y lenguajes. Dado su pequeño tamaño y su integración total con C, es común que se use para hacer de intermediario entre lenguajes o para unir componentes de un mismo lenguaje.

Una de las mayores ventajas es que corre en todos lados. Está bastante cerca del programa una vez, corre en todos los sitios, no tienes que andar haciendo condicionales y defines raros.

Es un lenguaje que dentro de lo que cabe, se aprende en muy muy poco tiempo, pero a pesar de ser un lenguaje potente, no es un javascript con 1000 metodos distintos de fábrica para unir strings, buscar texto, darle la vuelta... Está diseñado para traer lo mínimo indespensable y que tu personalmente le añadas exactamente lo que necesites usando librerías de tercero o las tuyas propias.

Yo lo suelo utilizar para servidores web y scripts para netcat, aunque no estoy muy contento con la librería de luasockets y todas las comprobaciones extra que acabo haciendo para cosas simples.

Este código son 3 funciones que hice para un servidor web y que comparto para poder comentar peculiaridades de la sintaxis y del lenguaje:

function split(string, pattern)
  if string == nil or pattern == nil then return "" end
  local lines = {}
  for i in string.gmatch(string, pattern) do
    lines[i] = i
  end
  return lines
end

Las funciones se definen con la palabra clave funcion.
Los condicionales no requieren parámetros.
Nil es literlamente nada. Viene del latín y en la práctica es similar al Null de otros lenguajes.
then y end se utilizan en lugar de los típicos corchetes de apertura y cierre respectivamente.
Local limita el alcance de las variables a la función en la que se encuentra
{} crea una tabla, que es un contenedor que sirve para muchas cosas distintas.
string.gmatch acepta un string y una pattern de lua para ir retornando el siguiente resultado de la búsqueda en cada iteración.

function read_config()
  package.path =  "./config/?.config;" .. package.path
  local fd = io.open("./config/config.config", "r")
  if not fd then
    print("[debug]File not found")
  end
  local lines = fd:read "*a"
  fd:close()
  --print("File Content:\n" .. lines)
  lines = split(lines, "([^\n]*)\n?")
  for key, val in pairs(lines) do
    val = string.lower(val)
    if val == "use_static_headers[true]" then
      print("[debug]Getting getting static headers")
      server_headers = require("static_headers")
      --[[for k, v in pairs(server_headers) do
        print(k .. ": " .. v)
      end]]--
    elseif val == "custom_methods[true]" then
      print("[debug]Getting getting custom methods")
      server_methods = require("custom_methods")
      --[[for i = 1, #server_methods do
        print(server_methods[i])
      end]]--
    end
  end
end

En esta función declaro de forma explicita la ruta que quiero añadir para que se busque en el sistema y le concateno el resto de package.path para que pieda seguir cargando módulos en las path originales.
A continuación leo todo el fichero con la opción *a.
Utilizo el método split que definí previamente usando una pattern para obtener todo lo que hay entre 2 saltos de linea.
Itero la tabla con pair para ptener el iterador y el valor.
Un poco más abajo hay un comentario multilinea.
El # es para obtener el length de un elemento.


[code=LUAfunction splitHeader(header)
  local aux = ""
  local index = 1
  local key = ""
  local value = ""
  for i = 1, #header do
    if header:sub(i, i) ~= ":" then
      if aux == nil then
   aux = header:sub(i, i)
      else
        aux = aux .. header:sub(i, i)
      end
    else
      index = i
      key = aux
      break
    end
  end
  for index = index + 1, #header do
    value = value .. header:sub(index, index)
  end
  --print("KEY:" .. key .. "\nVALUE:" .. value)
  -- value:match is removing leading/trailing spaces
  return key, value:match("^%s*(.-)%s*$")
end[/code]

Espero que sirva mi explicación!

Gracias a dios en Iran son unos cagados xD
Si le hace eso a North Korea, le llueven más petardos que en fin de año.

El sabotaje continuo al programa nuclear de Iran es una locura.

Probaste a utilizar un debugger? gdb es bastante sencillo. Y/O haz una función que haga cout y la llamas tras cada linea del programa. debuggear("linea1") //hasta linea 1 funciona.

int result;
result=0;

Puedes definir el valor de result en la propia declaración:
int result = 0;

En la primera sentencia del bucle for, se te olvidó declarar el tipo de i:
for(int i = 0; bla bla bla

Puedes usar += para tu asignación a result dentro del bucle:
result+=max(a,b);

Como te comenta el compañero, tienes que hacer return del resultado de la funciones que declares con cualquier tipo que no sea void.

En tu función tendrías que retornar result trás el bucle for. En el código que compartes tienes result declarado antes de la función product, pero nunca lo usas fuera. Debe estár dentro de la función.

#include <iostream> // input(entrada) output(salida) stream(<< >>) cout es C salida, cin es C entrada
 
using namespace std; // te ahorra poner std::cout std::cin std::string std::getline ...
 
// Prototipo de funciones
int min(int, int);
int max(int a, int b); // aconsejable añadirle los nombres de los parametros que vas a usar abajo tambien aqui, para facilitar la comprension del codigo, a pesar de no ser estrictamente necesario.
int product(int, int);
 
 
// función principal
int main(int argc, char **argv) { /* deberías declarar así siempre la funcion principal del programa. El primer argumento contiene el número de datos enviados por consola en el caso de correr el programa desde la cmd de Windows o la terminal de Linux.
Por ejemplo en la cmd, miPrograma.exe 5 5
Los argumentos se encuentran en el segundo parametro si lo recorres utilizando argv como tamaño, puedes obtenerlos para utilizarlos en tu programa en lugar de usar cin. Así es como se progaman los comandos de windows y linux.
Te lo comento no porque tenga gran relevancia o sea algo que tengas que saber de memoria ahora mismo, si no para que no te suenen a chino cuando los veas en clase. */
 
  cout << "El resultado es: " << product(5, 5) << endl;
  cin.get(); // Se suele utilizar para pausar el programa y que no se cierre sin que te de tiempo a ver los resultados.
  return 0;
}
 
 
 
// declaracion de funciones. Al estar debajo de main, tienen que tener su prototipo definido antes de main.
 
// Se aconseja comentar el código para entenderlo mejor. Ej:
/* Retorna el entero menor de dos enteros */
int min(int num1, int num2) {
  if (num1 < num2) { /* si el primer parametro es menor que el segundo, entonces: */
    return num1; // retorna el primer parametro
  }
  return num2; // retorna el segundo. Una vez se retorna una función, se sale de ella, asique si se retorna num2 es porque no se complio la condicion anterior que retornaba num1
}
 
/* Esta funcion hace lo mismo que la anterior, pero retorna el mayor en lugar del menor */
int max(int a, int b) {
  if (a > b) {
    return a;
  } else { // En este caso da igual que se añada el else o no. Si en el if anterior hubiese un cout en lugar de un return, entonces si que sería importante el else. Debido a que no se retornaría a, se imprimiría, y sin el else la ejecucion continuaria retornando b despues de imprimir en pantalla a.
    return b;
  }
}
 
 
int product(int num1, int num2) {
  int res = 0;
  for(int i = 1; i <= min(num1, num2); ++i) {
    res += max(num1, num2);
  }
  return res;
}

Practica! Haz por ejemplo un programa que imprima en pantalla los números impares situados entre los 2 números que indique el usuario.
Otro al que le pidas al usuario su nombre y su apellido en minúsculas, y le pongas ambas iniciales en mayúsculas.
Un programa que te diga el número de letras y palabras que tiene una frase.
...

Vas practicando con las cosas más sencillas que se te ocurran y según vas mejorando, vas haciendo cosas cada vez más difíciles.

Para la programación te recomiendo 80% práctica y  20% teoría, y no al revés como solemos hacer muchos al inicio. Cada cosa que leas la tienes que usar 20 veces antes de leer la siguiente. Si no, se te acumulan una cantidad de conceptos en la cabeza que no puedes plasmar. Se te olvidan otras, mezclas varias...

Estes son los comandos más básicos que se suelen usar:

ls
cd
cat
pwd
cp
mv
rm
mkdir
clear
touch
chmod +775
./
echo
vim
man
dpkg -l
pkg list-all
pkg list-installed
pkg install nombrePrograma
apt-get update && apt-get upgrade
exit

Puedes añadirles argumentos
ls -a
ls -h
ls --help

O rutas:

cd miCarpeta
cd ~/../usr

Puedes añadir condicionales:
Si el comando anterior funciona, ejecuta el siguiente.
mkdir nuevaCarpeta && cd nuevaCarpeta

Si el comando anterior no funciona, ejecuta el siguiente.
cd nuevaCarpeta || mkdir nuevaCarpeta

Puedes encadenar los que quieras así.


También puedes pasar el resultado de un comando al siguiente:
Por ejemplo lo siguiente muestra solo los primeros 20 caracteres del archivo que indiques.
cat miArchivo.txt | wc -c 20

Algunos de los modificadores más comunes:
wc
head
tail
cut
more
less
grep
figlet


A parte de redireccionar a otros comandos, también puedes redireccionar a archivos.

Crea un archivo o sobrescribe uno que ya existe:
echo 'Hola' > hola.txt

Añade al archivo:
echo 'Hola otra vez' >> hola.txt


Depués tienes una lista de comandos útiles casi infinita. Algunos de los más usados:
apache
curl
espeak
git
gcc
g++
lua53
lynx
make
netcat
nginx
nmap
node
npm
openssl
php
pip
python
quickjs
radare2
ssh
sqlite
tar
wget
unrar
unzip


Puedes mirar lo que hace cada uno usando:
comando -h
man comando
google.com/search?q=comando+linux


A parte de los comandos listados, tienes muchos programas en la carpeta bin.

cd ~/../usr/bin && ls

Mira también este tema.
https://foro.elhacker.net/gnulinux/tutorial_comandos_de_linux_bash-t508210.0.html

Ahí van los míos. También jugué muchos años al OSU!

- Desactivar aceleración del ratón de Windows.
- Utilizar un ratón por cable y con sensor y buen pollling rate.
- Usar raw pointer en la configuración del juego si lo permite.
- DPI entre 450-750.
- Sensibilidad en juegos a 0/por defecto.
- Resolución disponible más próxima a 1400/720.
- Grip que solo toque el ratón. Ya sea Palm o Claw.
- Usar el brazo, no solo la muñeca. (Es más fácil mejorar en velocidad que en precisión).
- Limpiar el ratón y la superficie entre partidas con algo húmedo.
- Monitor con buen refresh rate.
- Configurar el sistema para tener buen número de fps.
- Cerrar programas y tirar de la red equipos que no estés usando para bajar el ping.
- Juega cuando te apetezca y no te frustres. A mejor juegues, mejor queda la memoria muscular. Si llevas 8 horas seguidas y sigues por inhercia sin prestar atención desarrollas malos hábitos.
- Mente en blanco. Pensar en mejorar mientras juegas te distrae de jugar (que es como mejoras).
- Paciencia, continuidad y disfrutar.

Sí, mucho mejor por series que todas seguidas.

En los gimnasios te suelen indicar que hagas cinta 15 mins para calentar antes de empezar y después varias series de 10 en cada ejercicio.

Yo prefiero usar algo menos de peso y hacer series bastante más largas y lentas.

Muchas repeticiones de mancuernas (sin matarse), lentas, con peso moderado, todos los dias 2 horas después de comer y comer muchas proteinas. No abuses de los huevos, aunque sea buen alimento.

Explicación:
- Si haces sobresfuerzos, consigues el efecto contrario. Los músculos se compactan y se te quedan brazos "fibrados". Creo que se debe a la falta de oxígeno.
- A más número de repeticiones + se desarrollan los músculos. Si un dia haces 400 y descansas 2 días para recuperarte, te habría compensado más hacer 140 cada día. Muchos se matan pensando que esforzándose como locos consiguen mejores resultados. Es al contrario.
- Si pones mucho peso, haces pocas repeticiones, que puede ser como no hacer nada por el poco tiempo que estás ejercitándote. Si pones poco, tampoco es bueno porque no ejerces presión (entonces no aumentas masa) y quemas calorías (generas calor) que también es contraproducente.
- Necesitas tener energía y calorías que quemas, asique el momento ideal para hacer ejercicio es cuando acabaste la digestión. Si los haces antes de comer, tienes menos que quemar y reponer. Si las haces nada más comer, la sangre se concentra en el estómago para hacer la digestión, lo cual no afecta mucho pero tampoco es óptimo para absorber calorías ejercitarse en ese momento.
- Lo de los huevos más que nada por salud. No es bueno abusar de nada.

Por experiencia mi peso ideal de mancuernas era el peso con el que podía hacer un máximo de entre 50-100 repeticiones. Si estás empezando vas a notar el fortalecimiento en menos de un mes.
Mi primer mes con mancuernas pasé de hacer 50 repiticiones a hacer más de 200 con el mismo peso. Cuando es así lo vas aumentando.

No hagas solo el ejercicio típico de sentarse, agarrar la mancuerna, levantarla y bajarla.
Haz también el ejercicio de apoyarte con una mano en una silla y con la otra agarras la mancuerna y la levantas hacia el pecho mirando hacia ti. Y cuando la bajas tienes que girar la muñeca, como si quisieses darle un puñetazo al suelo.
Otro ejercicio bueno es sentarse, pones la mancuerna de pie entre las piernas, apoyas las manos de forma plana contra el disco de abajo de la mancuerna, como si agarrases un baso con las dos manos y lo bajases para tocar la mesa con las manos sin soltsr el baso. Entonces te tumbas hacis atrás, estiras los brazos rectos hacia arriba y los mueves rectos hacia detrás tuya. La pesa la agarras con las manos planas en el disco. Que esté bien apretada para que no se te salgan los discos y te caigan encima.
Con estos 3 ejercicios desarrollas todo el brazo.

Si es un problema de como te ves físicamente está guay. Si es un problema de inseguridad o crees que corres algún peligro, entonces te interesan el jujitsu (más aún si eres delgado o pequeño, ya que es una ventaja) y añádele uno de boxeo/kárate/kick boxing para desarrollar reflejos para evitar golpes. El kárate a mi me dio resultados sorprendentes en reflejos, a pesar de que las katas son un rollo que flipas jaja.

Si es por salud y desestresarte, yo recurro al Muay Thay. Es un deporte bastante agresivo, técnico y de mucho cardio. Yo lo veo más como deporte o lifestyle que como defensa personal. Las situaciones reales se suelen decidir en un golpe y el Muay Thai no se especializa en tirar rectos a la mandíbula ni en bloquearlos.

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.

Los dominios no son más que formas humanas de escribir ips.  Escribes el dominio y el servidor DNS te da su ip para que la uses.

Puedes tener todos los dominios que quieras apuntando a la misma ip.

Puedes usar el comando curl https://example.com -v para ver alguna de la info que demandas. viene ñreinstalado en windows y linux.