¿Cómo evitar que su código JavaScript sea robado, copiado y visto?

Question

Sé que es imposible para el 100% de protección, pero algo alto o que funciona para la mayoría de los usuarios.

Por ejemplo, encontré un sitio donde ver la fuente de la página actual no arrojó nada.

En otro caso, acceder o intentar descargar los ficheros por si mismo .js desde el navegador

http://gget.com/somesecret.js,

usted y esas cosas sería redirigir.

Si ofusca su código, ¿será muy difícil descifrarlo? si es así, también es otra buena solución (¿qué software se recomienda)?

Answer 1

Puede ofuscar su Javascript. Hay muchas herramientas para hacerlo en la naturaleza, p. http://www.javascriptobfuscator.com/. Sin embargo, no impide que nadie vea el código, pero hace que sea más difícil de leer.

Answer 2

Especialmente en los navegadores modernos, es una completa pérdida de tiempo.

Puedo usar Firebug para ver somesecret.js ... en cuanto a la otra, estoy mejor si te desplazas hacia abajo verías la fuente.

Puede minimizar u ocultar su código, lo que dificultará su modificación (pero no tomará una copia exacta). Se recomienda la minificación, ya que la página se cargará un poco más rápido.

Answer 3

Bueno, si es el propietario del servidor, puede denegar el acceso desde referencias que no sean su propio nombre de host. En Apache, puede hacerlo a través de .htaccess.

También puede usar Dean Edwards' packer para empaquetar sus códigos Javascript de producción.

Pero tenga en cuenta que con Firebug u otras herramientas de depuración, la mayoría de las personas todavía pueden ver su código a través de la pestaña/inspector DOM.

Answer 4

Simplemente no es posible.

Para que un navegador de visitantes pueda ejecutar el script, debe poder descargarlo. No importa qué truco trates de obtener con JS, permisos de servidor, etc., al final del día siempre pueden simplemente wget http://example.com/yourcoolscript.js. E incluso si no pueden (por ejemplo, requieren encabezados "secretos" para esa solicitud) que probablemente inhibiría el comportamiento de la mayoría de los navegadores, sin que impida que una persona determinada mire de todos modos.

Fundamentalmente, debido a que JS se ejecuta en el lado del cliente, el cliente debe tener acceso al archivo JS "original".

Una cosa menor que puede hacer es ofuscación, lo que puede ayudar un poco. Pero desde que se interpreta JS, también es su propio desobusuario; consulte one of my earlier answers para ver un ejemplo.

Básicamente, "si lo construyes, se verán". :-)

Answer 5

No pierdas tu tiempo. Si un navegador puede descargarlo para ejecutarlo (y puede, de lo contrario, el código es inútil), se puede escribir un programa para descargarlo y guardarlo.

Una y otra vez, hemos visto que los métodos tecnológicos para proteger este tipo de cosas no funcionan.

¿De verdad crees que tu código JS es tan valioso que necesita ese tipo de protección? Una vez que lo hagas funcionar, corrígelo a través de un minificador solo para acelerar el proceso de descarga. Pero en cuanto a protegerlo, me concentraría en lo que mejor haces (que supongo que es codificarlo).

Si realmente necesita proteger el código para que no lo vea, no lo haga en el lado del cliente JS. Póngalo en el servidor y simplemente use JS para comunicarse con eso.

Answer 6

Hay dos tipos de usuarios: Hay un grupo grande a quien no le puede importar menos. No es necesario protegerse contra ellos.

Luego, está el grupo que realmente quiere ver cómo lo hizo. No hay forma de protegerse contra ellos. Tienen todas las herramientas y el conocimiento para eludir cualquier protección que se te ocurra. Podría usar la ofuscación, pero eso le va a costar dinero y tiempo, así que al final, solo puede perder.

Cree un gran producto y ofrezca un buen soporte y la gente estará dispuesta a pagarlo. La construcción del castillo no funcionó bien en el pasado (mucho esfuerzo y solo tomó un par de piedras para derribarlos) y seguramente no funciona hoy.

Si teme que sus ideas sean robadas, busque un nuevo trabajo, porque lo será y no hay nada que pueda hacer.

Answer 7

Si tiene grandes secretos, guárdelos en el servidor.

A continuación, agrupe todos sus archivos JS en un solo archivo, que usted ofusque.
Esto debería evitar que muchas personas vayan más allá y reducir el tamaño y las llamadas http.
Pero esto no detendrá al verdadero tipo malo, en su caso.

Estamos construyendo una aplicación pesada JS y curado esta paranoia hace mucho tiempo.
De hecho, hicimos todo lo contrario.

Como no se puede proteger nada, ¿por qué no abrir las piezas útiles y obtener comentarios de otras personas?
Pruébalo, no te decepcionará.

Answer 8

Una idea es websockets uso para servir archivos de javascript en el navegador a través de un socket.listener y funcionando con eval. De esta forma, es muy, muy difícil para cualquiera ver la "fuente" real, ya que la conexión del socket ya se ha cerrado.

Hay otra táctica increíble que se puede ver en la página de inicio de http://samy.pl, que utiliza espacios (\ u0020) y pestañas (\ u0009) como cifrado de bytes para ocultar el código JS.

Si ve la fuente, sólo se puede ver 1 línea de código real JS: http://pastebin.com/e0pqJ8sB Ver por sí mismo si puede averiguar cómo funciona (no spoilers!)

En lo que ofuscadores ir, ver http://utf-8.jp/public/jjencode.html (y/u otra versión)

Este Ofuscador libre carreras del lado del cliente, y produce un galimatías que unminify.comjsbeautifier y ni siquiera se puede decodificar:

$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++$,$_$_:(![]+"")[$],_$_:++$,$_$$:({}+"")[$],$$_$:($[$]+"")[$],_$$:++$,$$$_:(!""+"")[$],$__:++$,$_$:++$,$$__:({}+"")[$],$$_:++$,$$$:++$,$___:++$,$__$:++$};$.$_=($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];$.$($.$($.$$+"\""+$.$_$_+(![]+"")[$._$_]+$.$$$_+"\\"+$.__$+$.$$_+$._$_+$.__+"(\\\"\\"+$.__$+$.__$+$.___+$.$$$_+(![]+"")[$._$_]+(![]+"")[$._$_]+$._$+",\\"+$.$__+$.___+"\\"+$.__$+$.__$+$._$_+$.$_$_+"\\"+$.__$+$.$$_+$.$$_+$.$_$_+"\\"+$.__$+$._$_+$._$$+$.$$__+"\\"+$.__$+$.$$_+$._$_+"\\"+$.__$+$.$_$+$.__$+"\\"+$.__$+$.$$_+$.___+$.__+"\\\"\\"+$.$__+$.___+")"+"\"")())(); 

código original:

alert("Hello, JavaScript") 

salida de ambos b sitios web de eautificadores:

$ = ~[]; 
$ = { 
    ___: ++$, 
    $$$$: (![] + "")[$], 
    __$: ++$, 
    $_$_: (![] + "")[$], 
    _$_: ++$, 
    $_$$: ({} + "")[$], 
    $$_$: ($[$] + "")[$], 
    _$$: ++$, 
    $$$_: (!"" + "")[$], 
    $__: ++$, 
    $_$: ++$, 
    $$__: ({} + "")[$], 
    $$_: ++$, 
    $$$: ++$, 
    $___: ++$, 
    $__$: ++$ 
}; 
$.$_ = ($.$_ = $ + "")[$.$_$] + ($._$ = $.$_[$.__$]) + ($.$$ = ($.$ + "")[$.__$]) + ((!$) + "")[$._$$] + ($.__ = $.$_[$.$$_]) + ($.$ = (!"" + "")[$.__$]) + ($._ = (!"" + "")[$._$_]) + $.$_[$.$_$] + $.__ + $._$ + $.$; 
$.$$ = $.$ + (!"" + "")[$._$$] + $.__ + $._ + $.$ + $.$$; 
$.$ = ($.___)[$.$_][$.$_]; 
$.$($.$($.$$ + "\"" + $.$_$_ + (![] + "")[$._$_] + $.$$$_ + "\\" + $.__$ + $.$$_ + $._$_ + $.__ + "(\\\"\\" + $.__$ + $.__$ + $.___ + $.$$$_ + (![] + "")[$._$_] + (![] + "")[$._$_] + $._$ + ",\\" + $.$__ + $.___ + "\\" + $.__$ + $.__$ + $._$_ + $.$_$_ + "\\" + $.__$ + $.$$_ + $.$$_ + $.$_$_ + "\\" + $.__$ + $._$_ + $._$$ + $.$$__ + "\\" + $.__$ + $.$$_ + $._$_ + "\\" + $.__$ + $.$_$ + $.__$ + "\\" + $.__$ + $.$$_ + $.___ + $.__ + "\\\"\\" + $.$__ + $.___ + ")" + "\"")())(); 

Espero que esto ilumine a los necesitados!

Answer 9

Si alguien hace de acero su código puede demandar. Su código está protegido por derechos de autor. Eres como el autor de una novela. Si alguien robó su aplicación o parte de su código, sería culpable de plagio.

Answer 10

Una cosa que PUEDE hacer es eludir javascript por completo: escriba la lógica del lado del cliente en un lenguaje igual o más competente (para lo cual puede encontrar un compilador de JavaScript) y compílelo en javascript al final. (Esto probablemente ofusca el código demasiado bien)