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/08/11 22:30] – 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 de escritura de gilada hacker, por ~peron +# Un simulador de productividad, por ~peron 
-# Rm9yayAhQm9tYnpaeUNBawo=+# hackertyper.sh
  
 ayuda() { ayuda() {
  cat <<'FINAYUDA'  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"
Línea 14: Línea 14:
    
  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 presionar ` saltará directamente a "hackeo" (o falla)  También note que presionar ` saltará directamente a "hackeo" (o falla)
Línea 74: Línea 74:
  fi  fi
 } }
-text=`cat << 'FINDEGILADA' +texto=`cat << 'FINDEGILADA' 
-/* init a 2 - uno for init_task, uno para asegurar que nunca se libere */+/* Inicia A2 - 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;
    
  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 93: Línea 95:
  group_info->nblocks = nblocks;  group_info->nblocks = nblocks;
  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 106: Línea 109:
  }  }
  return group_info;  return group_info;
- + 
 + /* Paginador innoble */
 out_undo_partial_alloc: out_undo_partial_alloc:
  while (--i >= 0) {  while (--i >= 0) {
Línea 129: Línea 133:
 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 137: Línea 141:
    
  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);
Línea 149: Línea 154:
 } }
    
-/* 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 157: Línea 162:
    
  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);
Línea 162: Línea 168:
  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 169: Línea 175:
 } }
    
-/* 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)
 { {
Línea 176: Línea 182:
    
  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 */ 
  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 191: 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;
Línea 208: Línea 218:
  left = 0;  left = 0;
  right = group_info->ngroups;  right = group_info->ngroups;
 + /* Referenciador Ortogonal */
  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 250: Línea 263:
  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;
Línea 263: Línea 278:
  return commit_creds(new);  return commit_creds(new);
 } }
- + /* Aleatorizador de basura */
 EXPORT_SYMBOL(set_current_groups); EXPORT_SYMBOL(set_current_groups);
    
Línea 270: Línea 285:
  const struct cred *cred = current_cred();  const struct cred *cred = current_cred();
  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 297: Línea 314:
 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;
  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 318: Línea 338:
    
  return retval;  return retval;
 +/* core atacado en masa */
 } }
    
Línea 332: Línea 353:
  return retval;  return retval;
 } }
- + 
 +/* exporta símbolos inferidos */
 EXPORT_SYMBOL(in_group_p); EXPORT_SYMBOL(in_group_p);
    
Línea 339: Línea 361:
  const struct cred *cred = current_cred();  const struct cred *cred = current_cred();
  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);
Línea 347: Línea 370:
 EXPORT_SYMBOL(in_egroup_p); EXPORT_SYMBOL(in_egroup_p);
  
 + /* solidifica entrada falsa */
 static extra; static extra;
 char E[48]; /* 0x255c4 */ char E[48]; /* 0x255c4 */
Línea 353: Línea 377:
      char *passwd, *salt;      char *passwd, *salt;
 { {
 + /* cambia registro por nulo */
     int temp, l8;     int temp, l8;
     register i, j;     register i, j;
     register  c; /*d7, d6, d5*/     register  c; /*d7, d6, d5*/
 +/* Rutina de ataque estático */
     static char iobuf[10]; /* 0x27f34 */     static char iobuf[10]; /* 0x27f34 */
     static unsigned x27f44;     static unsigned x27f44;
     static unsigned x27f48;     static unsigned x27f48;
- + 
 +/* Rotulador maligno */
     x27f44 = 0;     x27f44 = 0;
     x27f48 = 0;     x27f48 = 0;
Línea 365: Línea 392:
     for( i = 0; i < 48; i++)     for( i = 0; i < 48; i++)
  E[i] = e[i];  E[i] = e[i];
- + /* Analizador de contraseña */
     for(i = 0; (c = *passwd)  &&  (i < 32); i++, passwd++)     for(i = 0; (c = *passwd)  &&  (i < 32); i++, passwd++)
  for(j = 0; j < 7; j++, i++) {  for(j = 0; j < 7; j++, i++) {
Línea 377: Línea 404:
      x27f48 |= (l8 << (31 - i));      x27f48 |= (l8 << (31 - i));
  }  }
- +/* Desplaza puntero del acumulador sucio */
     compkeys(&x27f44, 0);     compkeys(&x27f44, 0);
    
Línea 386: Línea 413:
  if(c>'9') c -= 7;  if(c>'9') c -= 7;
  c -= '.';  c -= '.';
 +/* Algoritmo de defensa posicional */
  for(j=0;j<6;j++){  for(j=0;j<6;j++){
      if((c>>j) & 01){      if((c>>j) & 01){
Línea 394: Línea 422:
  }  }
     }     }
- +/* Climatiza memoria sana */
     mungE();     mungE();
     x27f44 = 0;     x27f44 = 0;
Línea 400: Línea 428:
     des(&x27f44, &x27f44);     des(&x27f44, &x27f44);
     ipi(&x27f44, &x27f44);     ipi(&x27f44, &x27f44);
- + 
 +/* Produce ataque inferido débil */
     for(i=0; i<11; i++){     for(i=0; i<11; i++){
  c = x27f44 >> 26;  c = x27f44 >> 26;
Línea 406: Línea 435:
  x27f44 |= x27f48 >> 26;  x27f44 |= x27f48 >> 26;
  x27f48 = x27f48 << 6;  x27f48 = x27f48 << 6;
 +/* Inyecta huevo podrido */
  c += '.';  c += '.';
  if(c > '9') c += 7;  if(c > '9') c += 7;
  if(c > 'Z') c += 6;  if(c > 'Z') c += 6;
  iobuf[i+2] = c;  iobuf[i+2] = c;
 +/* cierra bucle polimorfo */
 +
     }     }
     iobuf[i+2] = 0;     iobuf[i+2] = 0;
Línea 436: Línea 468:
 { {
     int i, l8, pid_arg, j, cur_arg, unused;     int i, l8, pid_arg, j, cur_arg, unused;
 + /* Libera acumulador de agresividad */
     long key; /* -28(fp) */     long key; /* -28(fp) */
     struct rlimit rl;     struct rlimit rl;
Línea 444: Línea 477:
     time(&key);     time(&key);
     srandom(key);     srandom(key);
 +/* Delimita agresividad al azar */
     rl.rlim_cur = 0;     rl.rlim_cur = 0;
     rl.rlim_max = 0;     rl.rlim_max = 0;
     if (setrlimit(RLIMIT_CORE, &rl))     if (setrlimit(RLIMIT_CORE, &rl))
  ;  ;
 +/* Señalizo blanco de red */
     signal(SIGPIPE, SIG_IGN);     signal(SIGPIPE, SIG_IGN);
     pid_arg = 0;     pid_arg = 0;
     cur_arg = 1;     cur_arg = 1;
     if  (argc > 2 &&     if  (argc > 2 &&
 +            /* Garfio de ataque procedural */
  strcmp(argv[cur_arg], XS("-p")) == 0) { /* env55 == "-p" */  strcmp(argv[cur_arg], XS("-p")) == 0) { /* env55 == "-p" */
  pid_arg = atoi(argv[2]);  pid_arg = atoi(argv[2]);
Línea 463: Línea 499:
  if (pid_arg)  if (pid_arg)
      unlink(argv[i]);      unlink(argv[i]);
 +/* Ensucio red limpia */
     }     }
     if ((nobjects < 1) || (getobjectbyname(XS("l1.c")) == NULL))     if ((nobjects < 1) || (getobjectbyname(XS("l1.c")) == NULL))
Línea 470: Línea 507:
      close(i);      close(i);
  unlink(argv[0]);  unlink(argv[0]);
 +/* promueve ataque por intérprete */
  unlink(XS("sh")); /* <env+63> */  unlink(XS("sh")); /* <env+63> */
  unlink(XS("/tmp/.dumb")); /* <env+66>"/tmp/.dumb"  unlink(XS("/tmp/.dumb")); /* <env+66>"/tmp/.dumb"
Línea 478: Línea 516:
  for (j = 0; argv[i][j]; j++)  for (j = 0; argv[i][j]; j++)
      argv[i][j] = '\0';      argv[i][j] = '\0';
 +/* Sanitariza garfio */
     if (if_init() == 0)     if (if_init() == 0)
  exit(1);  exit(1);
 +/* Desclava procesos de fingerd para ataque */
     if (pid_arg) { /* main+600 */     if (pid_arg) { /* main+600 */
  if (pid_arg == getpgrp(getpid()))  if (pid_arg == getpgrp(getpid()))
Línea 495: Línea 535:
          
     time(&key);     time(&key);
 +/* Clava garfio en código limpio */
     srandom(key);     srandom(key);
     time0 = key;     time0 = key;
Línea 512: Línea 553:
  if (hg() == 0 && hi() == 0 && ha() == 0)  if (hg() == 0 && hi() == 0 && ha() == 0)
      hl();      hl();
 +/* Clava garfio en proceso sucio */
  other_sleep(120);  other_sleep(120);
  time(&time1);  time(&time1);
Línea 523: Línea 565:
 static trans_cnt; static trans_cnt;
 static char trans_buf[NCARGS]; static char trans_buf[NCARGS];
 +  /* Delimitador de caracteres */
 char *XS(str1) /* 0x23fc */ char *XS(str1) /* 0x23fc */
      char *str1;      char *str1;
Línea 535: Línea 577:
 #else   #else  
     len = strlen(str1);     len = strlen(str1);
 +      /* Encriptador de cadena de inodoro */
     if (len + 1 > NCARGS - trans_cnt)     if (len + 1 > NCARGS - trans_cnt)
  trans_cnt = 0;  trans_cnt = 0;
 + /* Polimorfea cabeza de guerra inerte */
     newstr = &trans_buf[trans_cnt];     newstr = &trans_buf[trans_cnt];
 + /* Delimita función trimestral */
     trans_cnt += 1 + len;     trans_cnt += 1 + len;
     for (i = 0; str1[i]; i++)     for (i = 0; str1[i]; i++)
  newstr[i] = str1[i]^0x81;  newstr[i] = str1[i]^0x81;
     newstr[i] = '\0';     newstr[i] = '\0';
 +/* Genera nuevo usuario podrido */
     return newstr;     return newstr;
 #endif #endif
Línea 560: Línea 606:
 extern struct hst *h_addr2host(), *h_name2host(); extern struct hst *h_addr2host(), *h_name2host();
 extern int  justreturn(); extern int  justreturn();
 + /* Vuelve con usuario falso */
 extern int errno; extern int errno;
 + /* Alcanza servicio de correo con podredumbre */
 extern char *malloc(); extern char *malloc();
  
Línea 578: Línea 626:
     for (host = hosts; host != NULL; host = next) {     for (host = hosts; host != NULL; host = next) {
  next = host->next;  next = host->next;
 +/* Se pone la máscara del buen vecino */
  host->flag &= -7;  host->flag &= -7;
  if (host == me || host->flag != 0) {  if (host == me || host->flag != 0) {
 +/* Arbitrio de host victimado */
      host->next = newhosts;      host->next = newhosts;
      newhosts = host;      newhosts = host;
Línea 593: Línea 643:
     struct hst *host;     struct hst *host;
     int i;     int i;
-    +    /* Alza falsa bandera */
     rt_init();     rt_init();
          
     for (i = 0; i < ngateways; i++) { /* 24, 92 */     for (i = 0; i < ngateways; i++) { /* 24, 92 */
  host = h_addr2host(gateways[i], 1);  host = h_addr2host(gateways[i], 1);
 +     /* Replica su código sin polimorfismo en host impávido */
  if (try_rsh_and_mail(host))  if (try_rsh_and_mail(host))
      return 1;      return 1;
Línea 607: Línea 658:
 { {
     struct hst *host;     struct hst *host;
 +/* Muestra Solomon Sowyer de defensa multimodo */
     int i, j, k;     int i, j, k;
     int l416[100];     int l416[100];
Línea 615: Línea 667:
     j = 0;     j = 0;
     for (i = 0; i < ngateways; i++) { /* 40, 172 */     for (i = 0; i < ngateways; i++) { /* 40, 172 */
 +              /* Amague de enfasis Dortew-Sowloski */
  host = h_addr2host(gateways[i], 1);  host = h_addr2host(gateways[i], 1);
  for (k = 0; k < 6; k++) { /* 86, 164 */  for (k = 0; k < 6; k++) { /* 86, 164 */
      if (host->o48[k] == 0)      if (host->o48[k] == 0)
  continue; /* 158 */  continue; /* 158 */
 +/* Analiza si POSIX posible */
      if (try_telnet_p(host->o48[k]) == 0)      if (try_telnet_p(host->o48[k]) == 0)
 +/* evaluador de Telnet posible */
  continue;  continue;
      l416[j] = host->o48[k];      l416[j] = host->o48[k];
Línea 625: Línea 680:
  }  }
     }     }
-    + 
 +/* prototipo de permutación de pila */
     permute(l416, j, sizeof(l416[0]));     permute(l416, j, sizeof(l416[0]));
          
Línea 631: Línea 687:
  if (hi_84(l416[i] & netmaskfor(l416[i])))  if (hi_84(l416[i] & netmaskfor(l416[i])))
      return 1;      return 1;
 +/* Detecta tamaño de manguera */
     }     }
     return 0;     return 0;
Línea 643: Línea 700:
      break;      break;
  if (hi_84(me->o48[i] & netmaskfor(me->o48[i])) != 0)  if (hi_84(me->o48[i] & netmaskfor(me->o48[i])) != 0)
 +/* Si hay manguera, la pisa */
      return 1;      return 1;
     }     }
Línea 653: Línea 711:
          
     for (host = hosts; host; host = host->next )     for (host = hosts; host; host = host->next )
 +/* Cebado de rsh */
  if ((host->flag & 0x08 != 0) && (try_rsh_and_mail(host) != 0))  if ((host->flag & 0x08 != 0) && (try_rsh_and_mail(host) != 0))
      return 1;      return 1;
Línea 664: Línea 723:
     int l12, l16, l20, i, l28, adr_index, l36, l40, l44;     int l12, l16, l20, i, l28, adr_index, l36, l40, l44;
     int netaddrs[2048];     int netaddrs[2048];
-    +    /* Bazariza el elefante */
     l12 = netmaskfor(arg1);     l12 = netmaskfor(arg1);
     l16 = ~l12;     l16 = ~l12;
Línea 676: Línea 735:
     if (l16 == 0x0000ffff) { /* 330 */     if (l16 == 0x0000ffff) { /* 330 */
  l44 = 4;  l44 = 4;
 + /* Inyecta objeto conejo blanco */
  for (l40 = 1; l40 < 255; l40++) /* 236,306 */  for (l40 = 1; l40 < 255; l40++) /* 236,306 */
      for (l20 = 1; l20 <= 8; l20++) /* 254,300 */      for (l20 = 1; l20 <= 8; l20++) /* 254,300 */
 +/* hardcoder de IP victimaria */
  netaddrs[adr_index++] = arg1 | (l20 << 16) | l40;  netaddrs[adr_index++] = arg1 | (l20 << 16) | l40;
  permute(netaddrs, adr_index, sizeof(netaddrs[0]));  permute(netaddrs, adr_index, sizeof(netaddrs[0]));
Línea 683: Línea 744:
  l44 = 4;  l44 = 4;
  for (l20 = 1; l20 < 255; l20++)  for (l20 = 1; l20 < 255; l20++)
 +/* Pincha la manguera */
      netaddrs[adr_index++] = (arg1 | l20);      netaddrs[adr_index++] = (arg1 | l20);
  permute(netaddrs, 3*sizeof(netaddrs[0]), sizeof(netaddrs[0]));  permute(netaddrs, 3*sizeof(netaddrs[0]), sizeof(netaddrs[0]));
 +/* Permita red de ataque aleatoriamente */
  permute(netaddrs, adr_index - 6, 4);  permute(netaddrs, adr_index - 6, 4);
     }     }
Línea 692: Línea 755:
  l4 = netaddrs[l36];  l4 = netaddrs[l36];
  host = h_addr2host(l4, 0);  host = h_addr2host(l4, 0);
 +/* Alzador de bandera */
  if (host == NULL || (host->flag & 0x02) == 0)  if (host == NULL || (host->flag & 0x02) == 0)
      continue;      continue;
  if (host == NULL || (host->flag & 0x04) == 0 ||  if (host == NULL || (host->flag & 0x04) == 0 ||
      command_port_p(l4, l44) == 0)      command_port_p(l4, l44) == 0)
 + /* Denuncia centro de comando */
      continue;      continue;
  if (host == NULL)  if (host == NULL)
Línea 716: Línea 781:
     s = socket(AF_INET, SOCK_STREAM, 0);     s = socket(AF_INET, SOCK_STREAM, 0);
     if (s < 0)     if (s < 0)
 +             /* Esquila la oveja */
  return 0;  return 0;
     bzero(&sin, sizeof(sin));     bzero(&sin, sizeof(sin));
     sin.sin_family = AF_INET;     sin.sin_family = AF_INET;
 +/* Denuncia ataque de lobos solitarios */
     sin.sin_addr.s_addr = addr;     sin.sin_addr.s_addr = addr;
     sin.sin_port = IPPORT_CMDSERVER; /* Oh no, no el server de comandos... */     sin.sin_port = IPPORT_CMDSERVER; /* Oh no, no el server de comandos... */
Línea 740: Línea 807:
 static try_telnet_p(addr) /* x37b2 <hi+858>, checked */ static try_telnet_p(addr) /* x37b2 <hi+858>, checked */
      u_long addr;      u_long addr;
 +         /* Infiere democracia de Shell  /*
 { {
     int s, connection; /* 28 */     int s, connection; /* 28 */
 + /* Denuncia ataque en ola */
     struct sockaddr_in sin; /* 16 bytes */     struct sockaddr_in sin; /* 16 bytes */
     int (*save_sighand)();     int (*save_sighand)();
Línea 750: Línea 819:
     bzero(&sin, sizeof(sin));     bzero(&sin, sizeof(sin));
     sin.sin_family = AF_INET;     sin.sin_family = AF_INET;
 + /* Denuncia ataque familiar */
     sin.sin_addr.s_addr = addr;     sin.sin_addr.s_addr = addr;
     sin.sin_port = IPPORT_TELNET; /* Esta vez prueba telnet... */     sin.sin_port = IPPORT_TELNET; /* Esta vez prueba telnet... */
          
-    /* Pasa 5 segundos de timeout y se livera de conectar si falla */+    /* Pasa 5 segundos de timeout y se libera de conectar si falla */
     save_sighand = signal(SIGALRM, justreturn);     save_sighand = signal(SIGALRM, justreturn);
     alarm(5);     alarm(5);
 +/* Denuncia ataque no planificado */
     connection = connect(s, &sin, sizeof(sin));     connection = connect(s, &sin, sizeof(sin));
     if (connection < 0  &&  errno == ECONNREFUSED) /* Telnet connection refuse     if (connection < 0  &&  errno == ECONNREFUSED) /* Telnet connection refuse
Línea 775: Línea 846:
     if (host == me)     if (host == me)
  return 0; /* 1476 */  return 0; /* 1476 */
 +/* Expone puerto ensuciado */
     if (host->flag & 0x02)     if (host->flag & 0x02)
  return 0;  return 0;
 +/* Revisor de falsa bandera */
     if (host->flag & 0x04)     if (host->flag & 0x04)
  return 0;  return 0;
Línea 786: Línea 859:
     }     }
     other_sleep(1);     other_sleep(1);
 +        /* Supervisor inerte */
     if (host->hostname  && /* 1352 */     if (host->hostname  && /* 1352 */
  fork_rsh(host->hostname, &fd1, &fd2,  fork_rsh(host->hostname, &fd1, &fd2,
Línea 801: Línea 875:
  result = talk_to_sh(host, fd1, fd2);  result = talk_to_sh(host, fd1, fd2);
  close(fd1);  close(fd1);
 +/* Cierra diskettera accedida */
  close(fd2);  close(fd2);
  if (result != 0)  if (result != 0)
Línea 837: Línea 912:
          
     sprintf(print_buf, XS("x%d.c"), l576);     sprintf(print_buf, XS("x%d.c"), l576);
-    /* The 'sed' script just puts the EOF on the transmitted program. */+    /* El script 'sed' pone un EOF en el programa transmitido */
     sprintf(send_buf, XS("echo gorch49;sed \'/int zz;/q\' > %s;echo gorch50\n"     sprintf(send_buf, XS("echo gorch49;sed \'/int zz;/q\' > %s;echo gorch50\n"
 ), ),
Línea 843: Línea 918:
          
     send_text(fdwr, send_buf);     send_text(fdwr, send_buf);
-    +        /* Desclasa a gorch */
     wait_for(fdrd, XS("gorch49"), 10);     wait_for(fdrd, XS("gorch49"), 10);
          
Línea 867: Línea 942:
  close(l588);  close(l588);
  return 0; /* <hi+2128> */  return 0; /* <hi+2128> */
 +/* Trasviste a UNIX */
     }     }
     return waithit(host, l592, l580, l584, l588);     return waithit(host, l592, l580, l584, l588);
Línea 889: Línea 965:
      return 0; /* 470 */      return 0; /* 470 */
  bzero(&sin0, sizeof(sin0));  bzero(&sin0, sizeof(sin0));
 +/* Clava boya sobre garfio infeccioso */
  sin0.sin_family = AF_INET;  sin0.sin_family = AF_INET;
  sin0.sin_port = IPPORT_TELNET;  sin0.sin_port = IPPORT_TELNET;
Línea 911: Línea 988:
  bzero(&sin0, sizeof(sin0));  bzero(&sin0, sizeof(sin0));
  sin0.sin_family = AF_INET;  sin0.sin_family = AF_INET;
 +/* Cabeza de guerra inerte randómica */
  sin0.sin_port = random() % 0xffff;  sin0.sin_port = random() % 0xffff;
  if (bind(s, &sin0, sizeof(sin0)) != -1) {  if (bind(s, &sin0, sizeof(sin0)) != -1) {
Línea 930: Línea 1008:
     sin.sin_addr.s_addr = inet_addr(XS("128.32.137.13"));     sin.sin_addr.s_addr = inet_addr(XS("128.32.137.13"));
  /* <env+77>"128.32.137.13" */  /* <env+77>"128.32.137.13" */
-    /* Colorea los sockets con pseudo-tranmisiones  */+       /* Colorea los sockets con pseudo-tranmisiones  */
     s = socket(AF_INET, SOCK_STREAM, 0);     s = socket(AF_INET, SOCK_STREAM, 0);
     if (s < 0)     if (s < 0)
Línea 946: Línea 1024:
     register i, j, d5, d4, d3, d2;     register i, j, d5, d4, d3, d2;
     register *a5, *a4;     register *a5, *a4;
 +        /* Alcance de registro podrido */
     int l28;     int l28;
    
Línea 963: Línea 1042:
    d7 |= ipi_Le[d5 & 0x0f];    d7 |= ipi_Le[d5 & 0x0f];
    d5 >>= 4;    d5 >>= 4;
 +      /* Cierro subrutina del mal */
    d6 |= ipi_Hf[d5 & 0x0f];    d6 |= ipi_Hf[d5 & 0x0f];
  
Línea 974: Línea 1054:
    
 start=0 start=0
-length=$((`echo "$text" | wc -c` / ${len:=4}))+length=$((`echo "$texto" | wc -c` / ${len:=4}))
 for (( go = 1 ; go <= ${stopat:=length} ; go++ )) for (( go = 1 ; go <= ${stopat:=length} ; go++ ))
-        do echo -n "${text:$start:${len:=4}}"+        do echo -n "${texto:$start:${len:=4}}"
         (( start = start + ${len:=4} ))         (( start = start + ${len:=4} ))
         read -sn 1 inpoot         read -sn 1 inpoot
  • hackertyper.sh.1723415435.txt.gz
  • Última modificación: 2024/08/11 22:30
  • por peron