RE: crypting ruby source

Hi,=20

that's the first time I post in the ML, so please be indulgent...

I just wrote a small hack which intend to crypt the source. It's simple =
and not optimised (and quite lame ;) but usable.
I am aware that there is a flaw in the way I did it :=20
  the en/decrypt method must not be known nor published (i.e. you
have to write your own if you want it to be totally secure
-> another step in the way of closed source).=20
And the function to decrypt must be declared static and inaccessible by =
another way ( I've modified eval.c, so the decrypt function must be in =
eval.c too).


So , where are the other flaws in the method ( I know there ARE other =
flaws) ?

Best regards,

Pierre Brengard



The crypted file has a .rbx extension.
The global variable $KEY has to be setted up before doing a 'require'.

So here is the modif : in file eval.c, replace function rb_f_require =
with this one :
( I've not done a diff, so it's clear for everyone)

VALUE
rb_f_require(obj, fname)
    VALUE obj, fname;
{
    VALUE feature, tmp;
    char *ext, *ftptr; /* OK */
    volatile VALUE load;
    int state;
    volatile int safe =3D ruby_safe_level;

    Check_SafeStr(fname);
    ext =3D strrchr(RSTRING(fname)->ptr, '.');
    if (ext) {
 if (strcmp(".rb", ext) =3D=3D 0) {
     feature =3D rb_str_dup(fname);
     tmp =3D rb_find_file(fname);
     if (tmp) {
  fname =3D tmp;
  goto load_rb;
     }
 }
 else if (strcmp(".rbx", ext) =3D=3D 0) {
     feature =3D rb_str_dup(fname);
     tmp =3D rb_find_file(fname);
     if (tmp) {
  fname =3D tmp;
  goto load_rbx;
     }
 }
 else if (strcmp(".so", ext) =3D=3D 0 || strcmp(".o", ext) =3D=3D 0) {
     fname =3D rb_str_new(RSTRING(fname)->ptr, ext-RSTRING(fname)->ptr);
#ifdef DLEXT2
     tmp =3D fname;
     if (rb_find_file_ext(&tmp, loadable_ext+1)) {
  feature =3D tmp;
  fname =3D rb_find_file(tmp);
  goto load_dyna;
     }
#else
     feature =3D tmp =3D rb_str_dup(fname);
     rb_str_cat2(tmp, DLEXT);
     tmp =3D rb_find_file(tmp);
     if (tmp) {
  fname =3D tmp;
  goto load_dyna;
     }
#endif
 }
 else if (strcmp(DLEXT, ext) =3D=3D 0) {
     tmp =3D rb_find_file(fname);
     if (tmp) {
  feature =3D fname;
  fname =3D tmp;
  goto load_dyna;
     }
 }
#ifdef DLEXT2
 else if (strcmp(DLEXT2, ext) =3D=3D 0) {
     tmp =3D rb_find_file(fname);
     if (tmp) {
  feature =3D fname;
  fname =3D tmp;
  goto load_dyna;
     }
 }
#endif
    }
    tmp =3D fname;
    switch (rb_find_file_ext(&tmp, loadable_ext)) {
      case 0:
 break;

      case 1:
 feature =3D fname =3D tmp;
 goto load_rb;

      default:
 feature =3D tmp;
 fname =3D rb_find_file(tmp);
 goto load_dyna;
    }
    if (rb_feature_p(RSTRING(fname)->ptr, Qfalse))
 return Qfalse;
    rb_raise(rb_eLoadError, "No such file to load -- %s",
      RSTRING(fname)->ptr);

  load_dyna:
    if (rb_feature_p(RSTRING(feature)->ptr, Qfalse))
 return Qfalse;
    rb_provide_feature(feature);
    {
 int volatile old_vmode =3D scope_vmode;

 PUSH_TAG(PROT_NONE);
 if ((state =3D EXEC_TAG()) =3D=3D 0) {
     void *handle;

     SCOPE_SET(SCOPE_PUBLIC);
     handle =3D dln_load(RSTRING(fname)->ptr);
     rb_ary_push(ruby_dln_librefs, INT2NUM((long)handle));
 }
 POP_TAG();
 SCOPE_SET(old_vmode);
    }
    if (state) JUMP_TAG(state);

    return Qtrue;

  load_rb:
    if (rb_feature_p(RSTRING(feature)->ptr, Qtrue))
 return Qfalse;
    ruby_safe_level =3D 0;
    rb_provide_feature(feature);
    /* loading ruby library should be serialized. */
    if (!loading_tbl) {
 loading_tbl =3D st_init_strtable();
    }
    /* partial state */
    ftptr =3D ruby_strdup(RSTRING(feature)->ptr);
    st_insert(loading_tbl, ftptr, curr_thread);

    PUSH_TAG(PROT_NONE);
    if ((state =3D EXEC_TAG()) =3D=3D 0) {
 rb_load(fname, 0);
    }
    POP_TAG();
    st_delete(loading_tbl, &ftptr, 0); /* loading done */
    free(ftptr);
    ruby_safe_level =3D safe;
    if (state) JUMP_TAG(state);

    return Qtrue;
   =20
    /* here begins the modif */
    load_rbx:
    {
     FILE *f;
     char *buf; *clear;
     struct stat st;
     int tmp2;
     VALUE vkey;
     char *key;
    =20
     f =3D fopen(RSTRING(fname)->ptr, "r");
     stat((const char *)RSTRING(fname)->ptr, &st);
     buf =3D (char *)malloc(st.st_size);
     fread( buf, st.st_size, 1, f);
     vkey =3D rb_gv_get("KEY");
     key =3D STR2CSTR(vkey);
     clear =3D decrypt (buf, key);    /* write your own function */
     return rb_eval_string(clear);
    =20
    }
}