ssh-mini-tool.sh.x.c

#if 0
	shc Version 4.0.3, Generic Shell Script Compiler
	GNU GPL Version 3 Md Jahidul Hamid <jahidulhamid@yahoo.com>

	shc -r -f ssh-mini-tool.sh 
#endif

static  char data [] = 
#define      text_z	1866
#define      text	((&data[416]))
	"\375\142\107\363\331\227\202\135\242\022\242\241\152\135\354\006"
	"\274\324\103\260\232\053\065\232\001\165\005\333\112\351\106\107"
	"\113\215\072\044\044\275\202\307\320\044\151\072\201\125\101\075"
	"\051\204\356\304\260\043\136\261\231\143\215\343\115\323\053\230"
	"\141\146\275\205\043\077\115\364\143\266\056\344\013\160\042\065"
	"\365\021\371\245\064\130\127\316\273\345\261\010\270\335\241\031"
	"\103\136\237\147\236\354\133\001\243\212\346\256\372\011\344\360"
	"\032\335\225\117\065\355\035\361\322\317\372\213\254\233\244\360"
	"\372\104\127\230\061\263\232\324\075\201\203\070\213\147\051\245"
	"\105\276\365\173\254\023\154\176\342\147\011\217\003\256\177\375"
	"\362\327\226\043\213\061\367\311\262\173\001\076\342\052\344\047"
	"\351\331\242\226\354\017\024\317\166\036\136\171\314\336\167\277"
	"\266\016\343\101\077\333\012\362\126\014\060\070\067\024\137\040"
	"\355\002\267\332\021\313\251\210\352\010\002\266\346\171\166\234"
	"\207\131\335\307\064\350\271\212\364\351\303\053\376\043\114\353"
	"\045\003\306\067\317\157\300\271\170\302\160\136\073\346\373\303"
	"\077\331\212\164\301\103\377\265\055\302\341\053\345\055\027\013"
	"\060\335\102\377\115\003\271\305\305\051\044\001\017\037\304\117"
	"\371\116\304\272\222\303\160\277\205\121\353\153\177\002\166\260"
	"\340\271\257\055\274\151\363\201\222\027\202\242\067\107\362\060"
	"\226\266\353\050\171\134\350\377\256\324\152\055\326\341\335\267"
	"\233\215\344\127\366\327\331\211\357\134\053\046\243\036\127\071"
	"\324\103\142\116\237\113\115\116\037\270\173\366\232\131\255\065"
	"\346\222\214\335\152\146\147\131\302\223\200\146\261\330\240\205"
	"\033\002\324\273\116\041\011\156\332\205\144\164\336\022\251\305"
	"\244\066\243\016\234\012\147\137\235\350\305\116\300\145\324\334"
	"\046\247\000\063\163\353\160\137\304\324\211\143\047\260\007\177"
	"\204\254\304\153\311\125\152\334\011\116\207\063\102\335\123\004"
	"\353\377\142\131\162\021\316\327\132\224\210\301\231\145\071\347"
	"\065\120\113\044\204\164\167\032\340\376\272\322\262\104\113\207"
	"\074\340\312\306\150\052\053\175\167\270\076\172\040\357\057\304"
	"\075\313\361\200\020\137\200\131\130\001\360\324\235\272\371\347"
	"\041\374\147\027\346\327\261\211\163\065\261\033\147\264\123\266"
	"\366\104\352\200\070\377\316\241\147\112\241\073\257\115\323\245"
	"\354\323\146\163\314\005\034\260\162\026\277\027\140\017\133\114"
	"\352\303\012\344\202\357\335\245\123\056\075\205\324\106\151\003"
	"\130\325\007\054\032\350\342\202\045\077\222\347\016\002\060\241"
	"\167\360\341\231\363\023\102\225\104\107\304\242\353\360\302\345"
	"\232\272\120\203\256\004\337\375\062\347\106\103\260\117\161\134"
	"\240\275\107\263\336\017\153\244\352\314\224\121\053\332\001\171"
	"\262\050\074\077\306\270\207\323\003\065\223\010\236\143\045\104"
	"\171\054\240\160\102\163\234\351\355\076\116\101\326\053\235\314"
	"\374\171\252\314\216\151\107\164\272\046\266\055\104\241\035\107"
	"\114\323\146\104\010\204\274\164\303\156\173\064\364\202\056\225"
	"\012\267\323\350\147\222\125\140\237\215\363\026\173\047\210\271"
	"\002\225\121\034\032\277\376\207\241\302\064\043\070\057\156\013"
	"\321\175\255\117\372\301\155\065\202\336\234\005\231\142\252\216"
	"\007\333\053\226\231\106\063\116\346\345\304\010\137\324\251\134"
	"\142\361\253\025\222\054\255\165\202\077\213\145\366\302\147\011"
	"\365\253\376\075\254\225\051\165\333\263\142\027\340\302\331\357"
	"\275\026\204\357\346\254\077\301\031\370\022\367\222\217\204\315"
	"\237\217\262\223\107\261\172\061\002\335\053\115\221\241\203\214"
	"\255\364\070\162\025\176\100\354\063\005\226\134\045\117\170\055"
	"\145\140\255\014\006\255\043\372\206\334\142\025\006\244\030\171"
	"\275\166\303\020\141\100\001\071\343\261\347\034\003\206\037\231"
	"\157\120\242\022\101\157\053\120\047\172\215\315\165\004\121\071"
	"\122\077\006\163\032\233\065\206\360\366\342\012\071\015\210\153"
	"\344\012\340\224\067\364\041\271\121\314\230\014\261\336\315\100"
	"\074\051\115\132\131\313\162\072\262\030\372\034\326\002\072\165"
	"\062\070\224\324\031\022\007\234\065\025\044\106\142\073\024\260"
	"\105\043\013\136\060\272\303\262\247\212\024\060\320\273\220\074"
	"\351\162\161\170\030\212\077\126\110\264\331\114\352\365\210\133"
	"\334\274\043\250\065\231\106\123\341\127\235\052\105\074\352\354"
	"\110\115\155\154\011\072\213\210\265\055\077\174\231\151\077\354"
	"\021\114\370\100\000\054\114\316\310\345\063\040\251\220\273\167"
	"\060\011\063\120\367\027\266\132\152\153\076\111\222\056\313\144"
	"\201\233\374\311\221\257\153\350\172\312\343\170\070\245\236\333"
	"\112\155\307\270\163\063\343\363\311\267\275\045\014\161\317\350"
	"\007\156\041\064\315\333\204\350\356\275\274\371\041\274\012\226"
	"\223\165\365\044\270\377\075\346\023\233\047\100\126\263\275\211"
	"\202\354\377\366\211\221\266\210\333\205\000\234\203\175\005\010"
	"\002\011\151\052\157\041\340\036\276\301\151\243\166\025\130\257"
	"\256\122\362\076\045\037\071\112\150\202\153\332\240\052\077\034"
	"\205\306\161\344\375\277\354\120\232\041\374\344\123\311\211\151"
	"\331\304\246\032\264\032\373\252\216\246\032\301\334\031\345\243"
	"\014\135\242\261\160\233\270\031\143\145\307\340\257\031\031\352"
	"\160\353\012\143\261\364\020\340\037\110\134\151\273\350\252\304"
	"\134\366\131\161\164\246\046\071\140\273\331\374\031\016\061\062"
	"\276\065\364\054\005\315\003\353\225\035\175\220\330\325\042\172"
	"\004\202\300\253\170\136\262\267\253\063\273\223\311\241\025\265"
	"\057\054\137\071\263\044\301\253\100\124\101\075\121\313\367\351"
	"\051\000\017\155\342\173\313\043\333\166\000\000\223\173\313\126"
	"\046\232\247\326\265\203\047\004\142\333\274\062\144\206\244\275"
	"\361\050\227\240\072\325\166\033\251\322\067\160\141\026\160\240"
	"\202\077\075\306\105\105\257\270\070\043\054\205\224\072\255\210"
	"\006\062\100\307\164\324\026\251\217\322\373\044\246\244\214\074"
	"\361\227\045\112\353\371\005\201\314\347\005\326\157\276\344\131"
	"\224\007\073\007\154\163\373\155\035\003\320\256\356\305\067\166"
	"\013\310\300\210\371\065\122\041\006\164\240\102\174\165\266\065"
	"\321\020\273\060\364\234\133\205\252\226\241\034\117\150\320\266"
	"\057\215\102\355\073\115\236\054\170\030\003\236\334\130\010\040"
	"\120\137\315\225\004\276\156\041\126\124\173\366\275\231\175\116"
	"\010\240\271\210\332\037\335\226\273\364\332\234\057\165\222\243"
	"\313\306\156\103\255\227\325\327\167\151\155\145\062\020\355\350"
	"\350\062\303\376\314\100\240\215\007\336\142\033\340\075\210\331"
	"\062\051\161\142\173\100\314\301\022\206\122\146\377\317\047\231"
	"\027\156\114\354\203\277\054\131\273\336\042\023\226\353\166\265"
	"\010\133\050\075\361\120\002\365\331\162\315\207\231\277\230\354"
	"\052\232\127\153\055\044\051\310\215\032\160\276\221\035\063\041"
	"\175\013\100\064\014\342\226\043\361\057\320\362\340\015\164\102"
	"\327\230\054\130\155\004\331\157\222\065\254\030\155\336\233\233"
	"\040\036\130\221\271\221\071\150\014\235\232\121\002\160\040\061"
	"\012\146\010\123\336\367\261\031\171\044\112\000\306\116\223\124"
	"\172\366\010\306\104\200\141\374\257\323\047\101\351\277\135\064"
	"\326\262\225\323\346\126\061\303\134\347\244\031\253\275\212\047"
	"\117\020\234\022\054\302\032\113\070\336\166\327\344\302\022\056"
	"\237\317\244\222\324\133\234\115\344\057\014\351\012\107\002\252"
	"\131\307\225\250\257\013\344\364\371\126\214\060\325\216\047\040"
	"\100\235\163\277\315\130\053\217\236\137\151\134\057\062\362\354"
	"\305\222\363\164\237\060\340\363\175\271\137\164\333\250\265\333"
	"\254\201\104\055\106\304\321\342\162\233\234\034\010\040\176\335"
	"\311\170\376\026\371\313\105\211\174\251\251\052\111\242\067\202"
	"\175\072\225\241\103\373\303\136\203\052\334\144\313\257\324\263"
	"\223\222\331\135\175\151\343\277\336\306\075\023\055\320\353\251"
	"\233\054\003\105\144\335\251\021\371\254\130\232\317\062\240\112"
	"\361\126\020\124\231\103\200\354\363\367\312\003\276\032\064\134"
	"\004\244\000\251\214\062\203\056\201\370\301\261\243\256\311\360"
	"\077\244\164\020\074\340\277\361\056\275\126\215\006\203\323\304"
	"\126\100\012\126\006\224\353\313\133\164\227\240\206\303\361\011"
	"\161\017\105\041\046\023\300\170\052\334\277\165\026\341\324\110"
	"\114\377\177\066\041\041\314\167\307\022\304\024\010\156\206\142"
	"\015\276\141\261\273\257\035\135\207\141\305\215\102\115\055\071"
	"\172\132\120\255\175\220\301\200\004\324\225\157\201\335\161\342"
	"\144\374\301\132\123\012\132\203\025\232\311\357\203\147\047\035"
	"\373\141\113\210\120\206\376\113\117\203\326\345\235\000\133\211"
	"\250\323\200\110\163\256\264\025\317\030\073\025\124\013\037\340"
	"\173\140\335\226\347\320\161\127\070\143\132\036\163\200\161\362"
	"\072\017\262\313\331\046\256\240\211\212\021\051\174\244\126\123"
	"\305\050\244\011\070\061\215\300\014\313\073\156\144\343\037\331"
	"\375\016\033\006\052\030\347\073\120\311\263\106\300\042\221\366"
	"\222\254\074\354\351\230\156\030\255\352\235\121\346\217\052\333"
	"\347\023\126\202\013\347\212\110\251\357\133\055\253\153\363\317"
	"\171\200\122\124\234\307\157\235\231\063\115\013\312\244\226\035"
	"\046\256\102\245\233\050\000\327\215\353\311\303\040\072\377\331"
	"\271\275\355\336\314\011\073\365\315\307\247\050\071\123\274\157"
	"\126\153\015\244\145\145\334\174\035\101\017\353\072\220\305\260"
	"\203\160\103\350\244\224\346\271\364\240\354\051\115\025\204\135"
	"\013\045\340\225\367\172\144\322\017\136\061\046\034\162\252\145"
	"\122\137\256\253\232\260\256\233\050\262\371\201\315\221\017\322"
	"\004\016\267\156\317\351\275\176\154\100\060\206\140\207\005\340"
	"\311\007\125\126\136\174\173\002\206\247\171\020\071\042\261\260"
	"\233\057\253\110\265\213\307\242\136\372\254\164\036\355\232\123"
	"\270\360\001\067\342\114\052\366\267\270\150\250\230\266\312\242"
	"\044\245\050\211\031\007\233\303\315\077\372\160\116\227\173\266"
	"\366\030\236\274\147\137\042\074\074\212\345\324\101\257\167\146"
	"\125\237\360\157\246\213\062\163\313\055\344\032\304\137\320\272"
	"\170\157\166\340\316\230\034\013\043\001\337\145\261\127\313\006"
	"\366\274\165\235\107\250\021\023\325\365\055\232\125\376\124\315"
	"\155\313\255\074\144\312\107\210\314\047\355\175\176\271\204\165"
	"\165\372\022\275\243\043\321\171\031\377\023\156\375\150\073\152"
	"\064\351\246\230\263\355\041\200\024\016\375\223\310\202\010\075"
	"\175\033\373\040\076\314\232\130\313\255\306\310\025\002\063\112"
	"\354\331\342\240\307\003\040\334\022\036\157\332\241\167\030\036"
	"\222\023\077\321\337\331\052\252\207\360\163\235\363\246\347\337"
	"\177\312\200\107\315\240\043\340\276\223\272\137"
#define      pswd_z	256
#define      pswd	((&data[2529]))
	"\236\345\275\160\305\227\232\157\036\213\342\274\176\211\243\136"
	"\010\155\336\120\073\177\163\033\076\007\325\235\022\250\034\260"
	"\216\332\040\123\161\272\302\220\105\245\114\304\056\357\042\067"
	"\135\001\207\230\200\113\040\004\160\306\036\166\325\027\174\225"
	"\377\057\306\345\161\163\113\013\031\113\356\151\251\075\325\372"
	"\307\355\154\172\071\215\176\251\123\234\037\050\263\234\276\263"
	"\313\204\230\075\370\344\111\022\057\067\174\331\164\121\323\074"
	"\077\100\266\170\315\065\041\040\321\101\110\205\335\007\071\251"
	"\214\322\346\204\266\057\227\346\147\023\277\334\145\223\030\244"
	"\323\317\034\240\004\076\301\325\177\012\133\134\021\224\005\235"
	"\146\354\042\035\034\271\004\203\315\304\137\062\127\170\327\052"
	"\107\364\313\113\062\214\041\261\227\175\016\250\021\024\105\170"
	"\001\147\226\035\041\232\241\357\136\000\041\266\171\370\340\301"
	"\354\254\014\037\071\056\321\320\254\337\171\276\364\276\066\365"
	"\046\315\023\110\147\264\067\306\265\131\174\056\121\135\357\076"
	"\011\374\136\103\053\057\024\327\017\215\225\003\114\314\371\163"
	"\231\014\273\001\300\363\307\166\114\103\244\235\241\224\334\253"
	"\220\072\356\274\152\003\223\171\220\051\175\334\365\167\120\217"
	"\203\013\220\104\376\127\272\112\233\137\350\074\363\305\347\204"
	"\000\326\100\152\331\373\263\276\003\211\134\025\062\171\306\300"
	"\123\347\023\304\241\326\124\347\174\241\254\252\220\317\342\355"
	"\320\152\206\121\146"
#define      shll_z	10
#define      shll	((&data[2817]))
	"\075\063\050\320\311\076\167\230\021\027\303"
#define      lsto_z	1
#define      lsto	((&data[2828]))
	"\025"
#define      tst2_z	19
#define      tst2	((&data[2830]))
	"\071\035\325\273\362\174\027\001\022\376\375\042\232\336\211\322"
	"\263\316\032\033\054\310\376"
#define      chk2_z	19
#define      chk2	((&data[2855]))
	"\266\033\364\045\202\271\176\151\233\320\360\336\135\103\004\310"
	"\023\335\167\056\236\150\142"
#define      opts_z	1
#define      opts	((&data[2875]))
	"\363"
#define      msg2_z	19
#define      msg2	((&data[2878]))
	"\023\370\157\221\215\227\272\254\274\075\000\257\301\245\233\243"
	"\220\367\257\302\364"
#define      inlo_z	3
#define      inlo	((&data[2897]))
	"\156\064\073"
#define      xecc_z	15
#define      xecc	((&data[2903]))
	"\321\142\352\252\207\055\121\121\171\275\367\131\017\264\247\205"
	"\262\123\270\250\240"
#define      msg1_z	65
#define      msg1	((&data[2935]))
	"\360\243\010\103\132\043\070\274\351\275\356\222\060\360\132\031"
	"\114\056\075\200\057\154\350\170\212\274\343\156\142\154\350\344"
	"\040\136\270\251\024\272\177\235\234\012\252\204\254\260\231\106"
	"\106\171\042\076\372\170\005\160\174\243\053\260\006\176\026\327"
	"\200\073\010\143\247\234\066\375\060\107\165\005\013\166\070\245"
	"\051\104\036\133\251"
#define      date_z	1
#define      date	((&data[3006]))
	"\323"
#define      tst1_z	22
#define      tst1	((&data[3008]))
	"\014\015\214\105\150\344\233\357\006\113\024\016\275\201\221\140"
	"\320\015\321\062\061\124\250\334"
#define      chk1_z	22
#define      chk1	((&data[3036]))
	"\026\205\116\132\337\100\277\377\206\364\251\152\006\131\026\001"
	"\305\145\247\274\113\376\162\121\346\212\121\162"
#define      rlax_z	1
#define      rlax	((&data[3059]))
	"\356"/* End of data[] */;
#define      hide_z	4096
#define SETUID 0	/* Define as 1 to call setuid(0) at start of script */
#define DEBUGEXEC	0	/* Define as 1 to debug execvp calls */
#define TRACEABLE	1	/* Define as 1 to enable ptrace the executable */
#define HARDENING	0	/* Define as 1 to disable ptrace/dump the executable */
#define BUSYBOXON	0	/* Define as 1 to enable work with busybox */

#if HARDENING
static const char * shc_x[] = {
"/*",
" * Copyright 2019 - Intika <intika@librefox.org>",
" * Replace ******** with secret read from fd 21",
" * Also change arguments location of sub commands (sh script commands)",
" * gcc -Wall -fpic -shared -o shc_secret.so shc_secret.c -ldl",
" */",
"",
"#define _GNU_SOURCE /* needed to get RTLD_NEXT defined in dlfcn.h */",
"#define PLACEHOLDER \"********\"",
"#include <dlfcn.h>",
"#include <stdlib.h>",
"#include <string.h>",
"#include <unistd.h>",
"#include <stdio.h>",
"#include <signal.h>",
"",
"static char secret[128000]; //max size",
"typedef int (*pfi)(int, char **, char **);",
"static pfi real_main;",
"",
"// copy argv to new location",
"char **copyargs(int argc, char** argv){",
"    char **newargv = malloc((argc+1)*sizeof(*argv));",
"    char *from,*to;",
"    int i,len;",
"",
"    for(i = 0; i<argc; i++){",
"        from = argv[i];",
"        len = strlen(from)+1;",
"        to = malloc(len);",
"        memcpy(to,from,len);",
"        // zap old argv space",
"        memset(from,'\\0',len);",
"        newargv[i] = to;",
"        argv[i] = 0;",
"    }",
"    newargv[argc] = 0;",
"    return newargv;",
"}",
"",
"static int mymain(int argc, char** argv, char** env) {",
"    //fprintf(stderr, \"Inject main argc = %d\\n\", argc);",
"    return real_main(argc, copyargs(argc,argv), env);",
"}",
"",
"int __libc_start_main(int (*main) (int, char**, char**),",
"                      int argc,",
"                      char **argv,",
"                      void (*init) (void),",
"                      void (*fini)(void),",
"                      void (*rtld_fini)(void),",
"                      void (*stack_end)){",
"    static int (*real___libc_start_main)() = NULL;",
"    int n;",
"",
"    if (!real___libc_start_main) {",
"        real___libc_start_main = dlsym(RTLD_NEXT, \"__libc_start_main\");",
"        if (!real___libc_start_main) abort();",
"    }",
"",
"    n = read(21, secret, sizeof(secret));",
"    if (n > 0) {",
"      int i;",
"",
"    if (secret[n - 1] == '\\n') secret[--n] = '\\0';",
"    for (i = 1; i < argc; i++)",
"        if (strcmp(argv[i], PLACEHOLDER) == 0)",
"          argv[i] = secret;",
"    }",
"",
"    real_main = main;",
"",
"    return real___libc_start_main(mymain, argc, argv, init, fini, rtld_fini, stack_end);",
"}",
"",
0};
#endif /* HARDENING */

/* rtc.c */

#include <sys/stat.h>
#include <sys/types.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

/* 'Alleged RC4' */

static unsigned char stte[256], indx, jndx, kndx;

/*
 * Reset arc4 stte. 
 */
void stte_0(void)
{
	indx = jndx = kndx = 0;
	do {
		stte[indx] = indx;
	} while (++indx);
}

/*
 * Set key. Can be used more than once. 
 */
void key(void * str, int len)
{
	unsigned char tmp, * ptr = (unsigned char *)str;
	while (len > 0) {
		do {
			tmp = stte[indx];
			kndx += tmp;
			kndx += ptr[(int)indx % len];
			stte[indx] = stte[kndx];
			stte[kndx] = tmp;
		} while (++indx);
		ptr += 256;
		len -= 256;
	}
}

/*
 * Crypt data. 
 */
void arc4(void * str, int len)
{
	unsigned char tmp, * ptr = (unsigned char *)str;
	while (len > 0) {
		indx++;
		tmp = stte[indx];
		jndx += tmp;
		stte[indx] = stte[jndx];
		stte[jndx] = tmp;
		tmp += stte[indx];
		*ptr ^= stte[tmp];
		ptr++;
		len--;
	}
}

/* End of ARC4 */

#if HARDENING

#include <sys/ptrace.h>
#include <sys/wait.h>
#include <signal.h>
#include <sys/prctl.h>
#define PR_SET_PTRACER 0x59616d61

/* Seccomp Sandboxing Init */
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/prctl.h>
#include <sys/syscall.h>
#include <sys/socket.h>

#include <linux/filter.h>
#include <linux/seccomp.h>
#include <linux/audit.h>

#define ArchField offsetof(struct seccomp_data, arch)

#define Allow(syscall) \
    BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, SYS_##syscall, 0, 1), \
    BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW)

struct sock_filter filter[] = {
    /* validate arch */
    BPF_STMT(BPF_LD+BPF_W+BPF_ABS, ArchField),
    BPF_JUMP( BPF_JMP+BPF_JEQ+BPF_K, AUDIT_ARCH_X86_64, 1, 0),
    BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL),

    /* load syscall */
    BPF_STMT(BPF_LD+BPF_W+BPF_ABS, offsetof(struct seccomp_data, nr)),

    /* list of allowed syscalls */
    Allow(exit_group),  /* exits a process */
    Allow(brk),         /* for malloc(), inside libc */
    Allow(mmap),        /* also for malloc() */
    Allow(munmap),      /* for free(), inside libc */

    /* and if we don't match above, die */
    BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL),
};
struct sock_fprog filterprog = {
    .len = sizeof(filter)/sizeof(filter[0]),
    .filter = filter
};

/* Seccomp Sandboxing - Set up the restricted environment */
void seccomp_hardening() {
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
        perror("Could not start seccomp:");
        exit(1);
    }
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &filterprog) == -1) {
        perror("Could not start seccomp:");
        exit(1);
    }
} 
/* End Seccomp Sandboxing Init */

void shc_x_file() {
    FILE *fp;
    int line = 0;

    if ((fp = fopen("/tmp/shc_x.c", "w")) == NULL ) {exit(1); exit(1);}
    for (line = 0; shc_x[line]; line++)	fprintf(fp, "%s\n", shc_x[line]);
    fflush(fp);fclose(fp);
}

int make() {
	char * cc, * cflags, * ldflags;
    char cmd[4096];

	cc = getenv("CC");
	if (!cc) cc = "cc";

	sprintf(cmd, "%s %s -o %s %s", cc, "-Wall -fpic -shared", "/tmp/shc_x.so", "/tmp/shc_x.c -ldl");
	if (system(cmd)) {remove("/tmp/shc_x.c"); return -1;}
	remove("/tmp/shc_x.c"); return 0;
}

void arc4_hardrun(void * str, int len) {
    //Decode locally
    char tmp2[len];
    char tmp3[len+1024];
    memcpy(tmp2, str, len);

	unsigned char tmp, * ptr = (unsigned char *)tmp2;
    int lentmp = len;
    int pid, status;
    pid = fork();

    shc_x_file();
    if (make()) {exit(1);}

    setenv("LD_PRELOAD","/tmp/shc_x.so",1);

    if(pid==0) {

        //Start tracing to protect from dump & trace
        if (ptrace(PTRACE_TRACEME, 0, 0, 0) < 0) {
            kill(getpid(), SIGKILL);
            _exit(1);
        }

        //Decode Bash
        while (len > 0) {
            indx++;
            tmp = stte[indx];
            jndx += tmp;
            stte[indx] = stte[jndx];
            stte[jndx] = tmp;
            tmp += stte[indx];
            *ptr ^= stte[tmp];
            ptr++;
            len--;
        }

        //Do the magic
        sprintf(tmp3, "%s %s", "'********' 21<<<", tmp2);

        //Exec bash script //fork execl with 'sh -c'
        system(tmp2);

        //Empty script variable
        memcpy(tmp2, str, lentmp);

        //Clean temp
        remove("/tmp/shc_x.so");

        //Sinal to detach ptrace
        ptrace(PTRACE_DETACH, 0, 0, 0);
        exit(0);
    }
    else {wait(&status);}

    /* Seccomp Sandboxing - Start */
    seccomp_hardening();

    exit(0);
}
#endif /* HARDENING */

/*
 * Key with file invariants. 
 */
int key_with_file(char * file)
{
	struct stat statf[1];
	struct stat control[1];

	if (stat(file, statf) < 0)
		return -1;

	/* Turn on stable fields */
	memset(control, 0, sizeof(control));
	control->st_ino = statf->st_ino;
	control->st_dev = statf->st_dev;
	control->st_rdev = statf->st_rdev;
	control->st_uid = statf->st_uid;
	control->st_gid = statf->st_gid;
	control->st_size = statf->st_size;
	control->st_mtime = statf->st_mtime;
	control->st_ctime = statf->st_ctime;
	key(control, sizeof(control));
	return 0;
}

#if DEBUGEXEC
void debugexec(char * sh11, int argc, char ** argv)
{
	int i;
	fprintf(stderr, "shll=%s\n", sh11 ? sh11 : "<null>");
	fprintf(stderr, "argc=%d\n", argc);
	if (!argv) {
		fprintf(stderr, "argv=<null>\n");
	} else { 
		for (i = 0; i <= argc ; i++)
			fprintf(stderr, "argv[%d]=%.60s\n", i, argv[i] ? argv[i] : "<null>");
	}
}
#endif /* DEBUGEXEC */

void rmarg(char ** argv, char * arg)
{
	for (; argv && *argv && *argv != arg; argv++);
	for (; argv && *argv; argv++)
		*argv = argv[1];
}

void chkenv_end(void);

int chkenv(int argc)
{
	char buff[512];
	unsigned long mask, m;
	int l, a, c;
	char * string;
	extern char ** environ;

	mask = (unsigned long)getpid();
	stte_0();
	 key(&chkenv, (void*)&chkenv_end - (void*)&chkenv);
	 key(&data, sizeof(data));
	 key(&mask, sizeof(mask));
	arc4(&mask, sizeof(mask));
	sprintf(buff, "x%lx", mask);
	string = getenv(buff);
#if DEBUGEXEC
	fprintf(stderr, "getenv(%s)=%s\n", buff, string ? string : "<null>");
#endif
	l = strlen(buff);
	if (!string) {
		/* 1st */
		sprintf(&buff[l], "=%lu %d", mask, argc);
		putenv(strdup(buff));
		return 0;
	}
	c = sscanf(string, "%lu %d%c", &m, &a, buff);
	if (c == 2 && m == mask) {
		/* 3rd */
		rmarg(environ, &string[-l - 1]);
		return 1 + (argc - a);
	}
	return -1;
}

void chkenv_end(void){}

#if HARDENING

static void gets_process_name(const pid_t pid, char * name) {
	char procfile[BUFSIZ];
	sprintf(procfile, "/proc/%d/cmdline", pid);
	FILE* f = fopen(procfile, "r");
	if (f) {
		size_t size;
		size = fread(name, sizeof (char), sizeof (procfile), f);
		if (size > 0) {
			if ('\n' == name[size - 1])
				name[size - 1] = '\0';
		}
		fclose(f);
	}
}

void hardening() {
    prctl(PR_SET_DUMPABLE, 0);
    prctl(PR_SET_PTRACER, -1);

    int pid = getppid();
    char name[256] = {0};
    gets_process_name(pid, name);

    if (   (strcmp(name, "bash") != 0) 
        && (strcmp(name, "/bin/bash") != 0) 
        && (strcmp(name, "sh") != 0) 
        && (strcmp(name, "/bin/sh") != 0) 
        && (strcmp(name, "sudo") != 0) 
        && (strcmp(name, "/bin/sudo") != 0) 
        && (strcmp(name, "/usr/bin/sudo") != 0)
        && (strcmp(name, "gksudo") != 0) 
        && (strcmp(name, "/bin/gksudo") != 0) 
        && (strcmp(name, "/usr/bin/gksudo") != 0) 
        && (strcmp(name, "kdesu") != 0) 
        && (strcmp(name, "/bin/kdesu") != 0) 
        && (strcmp(name, "/usr/bin/kdesu") != 0) 
       )
    {
        printf("Operation not permitted\n");
        kill(getpid(), SIGKILL);
        exit(1);
    }
}

#endif /* HARDENING */

#if !TRACEABLE

#define _LINUX_SOURCE_COMPAT
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

#if !defined(PT_ATTACHEXC) /* New replacement for PT_ATTACH */
   #if !defined(PTRACE_ATTACH) && defined(PT_ATTACH)
       #define PT_ATTACHEXC	PT_ATTACH
   #elif defined(PTRACE_ATTACH)
       #define PT_ATTACHEXC PTRACE_ATTACH
   #endif
#endif

void untraceable(char * argv0)
{
	char proc[80];
	int pid, mine;

	switch(pid = fork()) {
	case  0:
		pid = getppid();
		/* For problematic SunOS ptrace */
#if defined(__FreeBSD__)
		sprintf(proc, "/proc/%d/mem", (int)pid);
#else
		sprintf(proc, "/proc/%d/as",  (int)pid);
#endif
		close(0);
		mine = !open(proc, O_RDWR|O_EXCL);
		if (!mine && errno != EBUSY)
			mine = !ptrace(PT_ATTACHEXC, pid, 0, 0);
		if (mine) {
			kill(pid, SIGCONT);
		} else {
			perror(argv0);
			kill(pid, SIGKILL);
		}
		_exit(mine);
	case -1:
		break;
	default:
		if (pid == waitpid(pid, 0, 0))
			return;
	}
	perror(argv0);
	_exit(1);
}
#endif /* !TRACEABLE */

char * xsh(int argc, char ** argv)
{
	char * scrpt;
	int ret, i, j;
	char ** varg;
	char * me = argv[0];
	if (me == NULL) { me = getenv("_"); }
	if (me == 0) { fprintf(stderr, "E: neither argv[0] nor $_ works."); exit(1); }

	ret = chkenv(argc);
	stte_0();
	 key(pswd, pswd_z);
	arc4(msg1, msg1_z);
	arc4(date, date_z);
	if (date[0] && (atoll(date)<time(NULL)))
		return msg1;
	arc4(shll, shll_z);
	arc4(inlo, inlo_z);
	arc4(xecc, xecc_z);
	arc4(lsto, lsto_z);
	arc4(tst1, tst1_z);
	 key(tst1, tst1_z);
	arc4(chk1, chk1_z);
	if ((chk1_z != tst1_z) || memcmp(tst1, chk1, tst1_z))
		return tst1;
	arc4(msg2, msg2_z);
	if (ret < 0)
		return msg2;
	varg = (char **)calloc(argc + 10, sizeof(char *));
	if (!varg)
		return 0;
	if (ret) {
		arc4(rlax, rlax_z);
		if (!rlax[0] && key_with_file(shll))
			return shll;
		arc4(opts, opts_z);
#if HARDENING
	    arc4_hardrun(text, text_z);
	    exit(0);
       /* Seccomp Sandboxing - Start */
       seccomp_hardening();
#endif
		arc4(text, text_z);
		arc4(tst2, tst2_z);
		 key(tst2, tst2_z);
		arc4(chk2, chk2_z);
		if ((chk2_z != tst2_z) || memcmp(tst2, chk2, tst2_z))
			return tst2;
		/* Prepend hide_z spaces to script text to hide it. */
		scrpt = malloc(hide_z + text_z);
		if (!scrpt)
			return 0;
		memset(scrpt, (int) ' ', hide_z);
		memcpy(&scrpt[hide_z], text, text_z);
	} else {			/* Reexecute */
		if (*xecc) {
			scrpt = malloc(512);
			if (!scrpt)
				return 0;
			sprintf(scrpt, xecc, me);
		} else {
			scrpt = me;
		}
	}
	j = 0;
#if BUSYBOXON
	varg[j++] = "busybox";
	varg[j++] = "sh";
#else
	varg[j++] = argv[0];		/* My own name at execution */
#endif
	if (ret && *opts)
		varg[j++] = opts;	/* Options on 1st line of code */
	if (*inlo)
		varg[j++] = inlo;	/* Option introducing inline code */
	varg[j++] = scrpt;		/* The script itself */
	if (*lsto)
		varg[j++] = lsto;	/* Option meaning last option */
	i = (ret > 1) ? ret : 0;	/* Args numbering correction */
	while (i < argc)
		varg[j++] = argv[i++];	/* Main run-time arguments */
	varg[j] = 0;			/* NULL terminated array */
#if DEBUGEXEC
	debugexec(shll, j, varg);
#endif
	execvp(shll, varg);
	return shll;
}

int main(int argc, char ** argv)
{
#if SETUID
   setuid(0);
#endif
#if DEBUGEXEC
	debugexec("main", argc, argv);
#endif
#if HARDENING
	hardening();
#endif
#if !TRACEABLE
	untraceable(argv[0]);
#endif
	argv[1] = xsh(argc, argv);
	fprintf(stderr, "%s%s%s: %s\n", argv[0],
		errno ? ": " : "",
		errno ? strerror(errno) : "",
		argv[1] ? argv[1] : "<null>"
	);
	return 1;
}