473938_fr-FR

liliconcom

Faille de sécurité avec les classes chiffrées (exemple)

Je poste ici à titre d'information : les classes cryptées en JSL ne sont pas sécurisées.Je recommande d'utiliser uniquement des fonctions et non des classes, car les fonctions n'y sont pas vulnérables.

 

Le problème réside dans le fait que les classes JMP sont introspectives, alors que les fonctions compilées ne le sont pas.Considérez la classe suivante qui contient une méthode que j'aimerais vraiment garder secrète :

Define Class(
 "complex",
 real = 0;
 imag = 0;
 _init_ = Method( {a, b},
  real = a;
  imag = b;
 );
 secret method = Method( {secret input 1, secret input 2 = "foo"},
  {Default Local},
  my secret password = "password123";
  my secret connection database = "database=UML_4x7z;source=axml1131;pwd=my_great_password";
  Eval( Eval Expr(
  my ultra secret program = Run Program(
   Executable( "secret_exe.exe" ),
   Options( Expr( "-o " || my secret connection database ) ) 
  )
  ) );
 );
 Add = Method( {y},
  New Object( complex( real + y:real, imag + y:imag ) )
 );
 Sub = Method( {y},
  New Object( complex( real - y:real, imag - y:imag ) )
 );
 Mul = Method( {y},
  New Object( complex( real * y:real - imag * y:imag, imag * y:real + real * y:imag ) )
 );
 Div = Method( {y},
  t = New Object( complex( 0, 0 ) );
  mag2 = y:Magsq();
  t:real = real * y:real + imag * y:imag;
  t:imag = imag * y:real + real * y:imag;
  t:real = t:real / mag2;
  t:imag = t:imag / mag2;
  t;
 );
 Magsq = Method( {},
  real * real + imag * imag
 );
 Mag = Method( {},
  Sqrt( real * real + imag * imag )
 );
 _to string_ = Method( {},
  Char( real ) || " + " || Char( imag ) || "i"
 );
 _show_ = _to string_;
);

Si vous prenez ce script et le chiffrez (en utilisant Edit->Encrypt Script...), alors idéalement, le code interne ne devrait pas être facilement visible par tout utilisateur final auquel vous pourriez le distribuer.Ceci, en revanche, n'est pas le cas.C’est en fait ridiculement facile à déconstruire et à reconstruire.

 

Voici quelques fonctions qui peuvent déconstruire les méthodes chiffrées (c'est là le problème) puis les reconstruire par souci de commodité :

clref = New Object( complex( 1, 2 ) );

introspect = Function( {obj},
 {Default Local},
 i = 1;
 obj part = Arg( obj, 1 );
 ret = Eval List( {Head Name( obj part )} );
 While( !Is Empty( Arg( obj part, i ) ),
  moil = Eval List({Arg( obj part, i)} );
  ret[N Items( ret ) + 1] = If( N Arg( Arg( moil, 1 ) ) > 0, Recurse( moil ), Head Name( Arg( moil, 1 ) ) );
  i++
 );
 ret
);
Clear Log();
deconstructed = introspect( Eval List( {Name Expr( clref:secret method )} ) );
Show( deconstructed );

reconstruct = Function( {input},
 {Default Local},
 init = Parse( input[1] || "()" );
 If( Is List( input ) & N Items( input ) > 1,
  For( i = 2, i <= N Items( input ), i++,
   If( Is List( input[i] ),
    Insert Into( init, Try( ( s = Recurse( input[i] ); s )[1], Char( s ) ) )
   ,
    Insert Into( init, Parse( input[i] ) )
   )
  );
 );
 Eval List( {Name Expr( init ) } );
);

Show( reconstruct( v )&nbsp;);

Notez qu'il y a deux mises en garde avec ceci : il ne peut pas facilement distinguer les chaînes et les noms (mais vous, en tant qu'humain, le pouvez probablement), et il n'aura pas de visibilité sur les arguments centraux d'une construction telle que classe:méthode( arg1, arg2 ):returned_class_method( arg ); , où la première méthode renvoie une classe dont vous appelez ensuite une méthode.Même avec ces limitations, il peut être très rapide de trouver les détails de mise en œuvre, même pour les mots de passe/informations sensibles.

 

Encore une fois, ma recommandation est que si vous chiffrez un script/plusieurs scripts à des fins de sécurité, ne comptez pas sur les classes.

Automatisation et scriptsles fenêtresRe : Vulnérabilité de sécurité avec les classes chiffrées (exemple)

Bon à savoir.Je suggère d'envoyer ceci à support@jmp.com aussi si vous ne l'avez pas déjà fait.