que - javascript ejemplos

¿Cuáles son las cadenas integradas de JavaScript?

Question

esta pregunta es difícil de resumir en un título de pregunta

ACTUALIZACIÓN Creé un JSFiddle que construye una cadena ofuscada de su entrada basada en las letras extraídas de esta pregunta: ¿Puede acceder here , o sería más fácil?

Recientemente encontré un poco de JavaScript ofuscado en este perfil que se ve así:

javascript:[[]+1/!1][1^1][1>>1]+({}+[])[1<<1^11>>1]+([]+!!-
[])[1<<1]+[/~/+{}][+!1][-~1<<1]+([]+/-/[(!!1+[])[1>>1]+(!!1
+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]+([,][
~1]+[])[1-~1]+[[]+{}][!1.1%1][11111.1%11.1*111e11|!1]+(/1/+
1/[1<1][1%1])[1^11]+[[],[]+{}][1][+1]+(/<</[1]+[])[1/1.1&1]

Perdón por arruinar la sorpresa, pero cuando esto se evalúa, devuelve esto:

"I love you" in Chrome
"I lone you" In Firefox
"I lo[e you" in IE10

La forma en que esto funciona cuando se rompe, es generar una serie de mensajes y sacarles letras de esa manera (usando la "I" como ejemplo):

[]+1/!1
returns
"Infinity"
then
[[]+1/!1]
creates this array:
["Infinity"]
then
[[]+1/!1][1^1]
Takes the first (1^1 == 0) element of that array
"Infinity"
finally
[[]+1/!1][1^1][1>>1]
Takes the first (1>>1 == 0) char of that string
"I"

Otras cadenas que se generan incluyen:

({}+[])       -> "[object Object]" (where the space comes from)
([]+!!-[])    -> "false" (used for it''s "l")
[/~/+{}][+!1] -> "/~/[object Object]" (this is used for an "o")
(/<</[1]+[])  -> "undefined"

Estaba interesado en encontrar un reemplazo para la "n" y "[" y se me ocurrió esto:

String.fromCharCode((''1''.charCodeAt(0)<<1)+(10<<1))

Lo cual siento en el espíritu de usar 1''s y 0''s, pero viola uno de los aspectos más elegantes del código original, que es la apariencia de que no tiene nada que ver con cadenas. ¿Alguien más tiene una idea de cómo generar una "v" que esté de acuerdo con el código ofuscado original?

Aquí hay información adicional que se encontró después de que muchos programadores de JavaScript con talento analizaran más a fondo este

Firefox devuelve "I lone you" debido a esta línea:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]+

[1^11<<1] recorta un personaje específico de esto:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])

Que se evalúa a esto:

"function test() {
    [native code]
}"

¡¡Que parece que podríamos tener nuestra "V" !!!

Chrome devuelve "Te amo", porque el mismo código devuelve esto:

"function test() { [native code] }"

Antes de que se cerrara la pregunta por una conexión dudosa con "un problema de programación real", pensé que agregaría una solución resumida que se basa en @Supr''s , @Cory''s y @alpha123''s , he aquí:

alert([[]+1/!1][1^1][1>>1]+({}+[])[1<<1^11>>1]+(
[]+!!-[])[1<<1]+[/~/+{}][+!1][-~1<<1]+[([]+/-/[(
!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(
!!1+[])[1^1]])[1+(1^(11+1+1)<<1)],([]+/-/[(!!1+[
])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[
])[1^1]])[1^11<<1],([]+/-/[(!!1+[])[1>>1]+(!!1+[
])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11
+1+1)<<1]][((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<
1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1<<1<<1<<1
)+1<<1]==({}+[])[1^1])*1)+((([]+/-/[(!!1+[])[1>>
1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1
]])[(1^11<<1)-1]==({}+[])[1^1])<<1)]+([,][~1]+[]
)[1-~1]+[[]+{}][!1.1%1][11111.1%11.1*111e11|!1]+
(/1/+1/[1<1][1%1])[1^11]+[[],[]+{}][1][+1]+(/<</
[1]+[])[1/1.1&1])

Dada la complejidad del código y el mensaje que produce, es casi como si el motor de JavaScript dijera qué tan especial lo haces sentir :)

Answer 1

¿Por qué no se usa el native code de la pregunta? Este da una ''v'' en Chrome y Firefox:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]>([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11+1+1)<<1]?([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]:([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11+1+1)<<1]

Edite para admitir IE y hágalo sin el operador ternario: este funciona en Chrome, IE y FF. Crea una matriz y usa == para determinar el navegador.

[([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1+(1^(11+1+1)<<1)],([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1],([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11+1+1)<<1]][((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1<<1<<1<<1)+1<<1]==({}+[])[1^1])*1)+((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1^11<<1)-1]==({}+[])[1^1])<<1)]

Legible:

[
    //ie
    ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1+(1^(11+1+1)<<1)],
    //ch
    ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1],
    //ff
    ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^(11+1+1)<<1]
]
[
    //ch?
    ((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1<<1<<1<<1)+1<<1]==({}+[])[1^1])*1)+
    //ff?
    ((([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1^11<<1)-1]==({}+[])[1^1])<<1)
]

Answer 2

Antes que nada, me gustaría agradecer a Jason y a todos los colaboradores por jugar con ese fragmento divertido. Escribí ese fragmento de código solo por diversión para enviársela a mi esposa el 14 de febrero :) Al tener solo Chrome instalado en la computadora portátil, no tenía opciones para comprobar cómo funcionaba en Firefox e IE. Además, realmente no esperaba que la representación de los métodos toString() pudiera tener un aspecto diferente en otros navegadores.

Ahora, pasando al problema real , echemos un vistazo al código. Sí, "v" fue el verdadero "problema" aquí. No encontré otras formas de obtener esta letra, excepto el análisis de cadena [native code] , que puede tomarse de cualquier método incorporado. Como me limité a no tener cadenas y no se usaban números, excepto 1 , necesitaba explotar algún método que solo tuviera caracteres disponibles en su nombre.

Los caracteres disponibles se pueden obtener a partir de palabras clave y representaciones de cadenas existentes, es decir, desde el principio teníamos NaN , null , undefined , Infinity , true , false y "[object Object]" . Algunos de ellos se pueden convertir fácilmente en cadenas, por ejemplo, 1/!1+[] da "Infinity" .

He analizado diferentes métodos de compilación para matrices [] , objetos {} , expresiones regulares /(?:)/ , Números 1.1 , cadenas "1" , y descubrí un hermoso método de objeto RegExp llamado test() . Su nombre puede ser ensamblado a partir de todos los caracteres disponibles, por ejemplo, "t" y "e" de true , y "s" de false . He creado una "test" cadena y abordado este método usando la notación de corchetes para la expresión regular literal /-/ , correctamente identificada en esta línea:

/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]]

Como ya se discutió, este fragmento de código se evalúa en Chrome como:

function test() { [native code] }

en Firefox como:

function test() {
    [native code]
}

y en IE como:

 function test() {     [native code] }  

^{(en este último, preste especial atención a la palabra clave space before function )}

Entonces, como puede ver claramente, mi código obtenía el carácter número 24 de la cadena presentada, que en Chrome era "v" (como estaba previsto), pero desafortunadamente en Firefox e IE - "n" y "[" respectivamente.

Para hacer el mismo resultado en todos los navegadores, utilicé un enfoque diferente al ilustrado en las otras respuestas. Ahora la versión modificada se ve así:

javascript:[[]+1/!1][1^1][1>>1]+({}+[])[1<<1^11>>1]+([]+!!-
[])[1<<1]+[/~/+{}][+!1][-~1<<1]+//[[^1]+/]/[([]+![])[1<<1<<
1]+(/|/[(1+{})[1+11>>>1]+[[]+{}][+!1][1]+([]+1/[])[1<<1>>1]
+([1<1]+[])[1+11>>>1+1]+[[!!1]+1][+[]][1-1]+([]+!!/!/)[1|1]
+(/1/[1]+[])[!1%1]+(-{}+{})[-1+1e1-1]+(1+[!!1])[1]+([]+1+{}
)[1<<1]+[!!/!!/+[]][+[]][1&1]]+/=/)[1e1+(1<<1|1)+(([]+/-/[(
!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1
]])[1^1]==+!1)]+(!![]+{})[1|1<<1]+[1+{}+1][!1+!1][(11>>1)+1
]](([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+
(!!1+[])[1^1]]))[1&.1][11>>>1]+([,][~1]+[])[1-~1]+[[]+{}][!
1.1%1][11111.1%11.1*111e11|!1]+(/1/+1/[1<1][1%1])[1^11]+[[]
,[]+{}][1<<1>>>1][1||1]+(/[<+>]/[1&1|1]+[1.1])[1/11.1&1.11]

Sin embargo, para intrigar a los lectores, no proporcionaré una solución para eso. Honestamente, creo que comprenderás fácilmente cómo funciona ... y algunos incluso pueden sorprender a sus seres queridos de forma cruzada;)

PD aún otro ofuscador

Inspirado por la idea de Jason de crear una herramienta de ofuscación universal, he escrito una más. Puede encontrarlo en JSBin: http://jsbin.com/amecoq/2 . Puede ofuscar cualquier texto que contenga números [0-9] , letras latinas pequeñas [az] y espacios. La longitud de la cadena está limitada principalmente con su RAM (al menos el cuerpo de mi respuesta fue ofuscado con éxito). La salida es compatible con Chrome, Firefox e IE.

^{Sugerencia: la herramienta utiliza un enfoque de ofuscación diferente del presentado anteriormente.}

Answer 3

Aquí está la parte que genera el n / v:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[1^11<<1]

En Firefox, ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]]) evalúa

"function test() {
    [native code]
}"

mientras que en Chrome es

"function test() { [native code] }"

1^11<<1 es igual a 23. Entonces, debido al espacio en blanco adicional de Firefox, esto no es suficiente para llegar a la ''v'', sino que es ''n''.

Y esta es la razón por la que no debe confiar en el comportamiento de Function # toString. ;)

EDITAR: Finalmente encontré una versión entre navegadores razonablemente ofuscada:

[[]+1/!1][1^1][1>>1]+({}+[])[1<<1^11>>1]+([]+!!-[])[1<<1]+[/~/+{}][+!1][-~1<<1]+([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1^11<<1)+(parseInt("010")<10?(1+1+1+1):0)]+([,][~1]+[])[1-~1]+[[]+{}][!1.1%1][11111.1%11.1*111e11|!1]+(/1/+1/[1<1][1%1])[1^11]+[[],[]+{}][1][+1]+(/<</[1]+[])[1/1.1&1]

Esto reemplaza la sección n / v con:

([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]])[(1^11<<1)+(parseInt("010")<10?(1+1+1+1):0)]

que explota las diferencias en parseInt (aparentemente Firefox analiza números empezando por 0 como octal, mientras que Chrome no) para agregar 4 en el caso de Firefox, obteniendo ''v'' de ''nativo'' en ambos casos (no puedo encontrar otro ''v '' :PAG).
El análisis parece un poco fuera de lugar, pero es lo mejor que puedo hacer por ahora.

Answer 4

En cromo, la expresión ([]+/-/[(!!1+[])[1>>1]+(!!1+[])[1<<1^1]+(!1+[])[1|1<<1]+(!!1+[])[1^1]]) evalúa como "function test() { [native code] }" , el [1^11<<1] evalúa a 23 (los operadores bit a bit causan que la variable se trunque a 32 bits)

Answer 5

Esto da av en Chrome:

Object.getOwnPropertyNames(Object)[17][3];

Y esto lo hace en Firefox:

Object.getOwnPropertyNames(Object)[9][3]

Ambos lo sacan de Object.prototype.preventExtensions() , por lo que probablemente pueda encontrar una forma de navegador cruzada para hacer referencia a ese método. (Es el único nombre de 17 caracteres en Object.Prototype para principiantes).

Siéntete libre de construir una versión más ofuscada de esto y tomar todo el crédito por ti mismo, estoy fuera de tiempo;)

Answer 6

Esto es lo más cerca que pude, desafortunadamente viola la convención de la ofuscación original al hacer una llamada a unescape() :

unescape((/%/+[])[1]+(/1/[1]+[])[1%1]+(+!1)+(+!1)+(1e1+(11*(1-~1)<<1)))

Demoler:

(/%/+[])[1]          => "%"
(/1/[1]+[])[1%1]     => "u"
(+!1)                => "0"
(+!1)                => "0"
(1e1+(11*(1-~1)<<1)) => "76"
===========================
unescape("%u0076")   => "v"

Otras ideas:

1. De alguna manera llegar a unescape("/x76")
2. De alguna forma convierta 118 sin llamar a String.fromCharCode()
3. Obtenga el texto de una excepción con la palabra "Inválido" en ella

Actualizaciones:

Empecé a jugar al golf de código y lo he estado haciendo más corto, reemplazando partes con más 1 s, etc.

Answer 7

Para el caso de uso general , si el revestimiento del personaje no es una gran preocupación, me inclinaría a hacer trampa un poco.

Crea la función "c" que convierte un número 0 .. 25 en un personaje.

c=function(v){for(var i in window){for(var ci in i){if(parseInt(i[ci],(10+11+11)+(1<<1)+(1<<1))==(v+10)){return i[ci]}}}};

Por razones de rendimiento, guarde previamente las letras, si lo desea.

l=[];for(var i=0; i<(11+11)+(1<<1)+(1<<1);i++){l[i]=c(i);}

En la consola de Chrome, la matriz resultante se ve así:

> l;
["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "K", "l", "m", "n", "o", "p", "q", "r", "S", "t", "u", "v", "w", "x", "y", "Z"]

Entonces ... tu v podría ser l[10+10+1] .

Alternativamente, una solución general como esta:

p=(function(){10%11}+[])[1+11+(1<<1)]; // "%"
u=(function(){club=1}+[])[1+11+(1<<1)]; // "u"
vc=p+u+(0+[])+(0+[])+((111>>1)+11+10+[]); // "%u0076"
unescape(vc);

O bien, para este problema específico , tal vez solo:

(function(){v=1}+[])[10+(1<<1)]; // "v"