sintaxis - perl guia completo pdf

¿Cómo deobfusacte correctamente una secuencia de comandos de Perl?

Question

Estoy tratando de desofuscar el siguiente código de Perl ( source ):

#!/usr/bin/perl
(my$d=q[AA                GTCAGTTCCT
  CGCTATGTA                 ACACACACCA
    TTTGTGAGT                ATGTAACATA
      CTCGCTGGC              TATGTCAGAC
        AGATTGATC          GATCGATAGA
          ATGATAGATC     GAACGAGTGA
            TAGATAGAGT GATAGATAGA
              GAGAGA GATAGAACGA
                TC GATAGAGAGA
                 TAGATAGACA G
               ATCGAGAGAC AGATA
             GAACGACAGA TAGATAGAT
           TGAGTGATAG    ACTGAGAGAT
         AGATAGATTG        ATAGATAGAT
       AGATAGATAG           ACTGATAGAT
     AGAGTGATAG             ATAGAATGAG
   AGATAGACAG               ACAGACAGAT
  AGATAGACAG               AGAGACAGAT
  TGATAGATAG             ATAGATAGAT
  TGATAGATAG           AATGATAGAT
   AGATTGAGTG        ACAGATCGAT
     AGAACCTTTCT   CAGTAACAGT
       CTTTCTCGC TGGCTTGCTT
         TCTAA CAACCTTACT
           G ACTGCCTTTC
           TGAGATAGAT CGA
         TAGATAGATA GACAGAC
       AGATAGATAG  ATAGAATGAC
     AGACAGAGAG      ACAGAATGAT
   CGAGAGACAG          ATAGATAGAT
  AGAATGATAG             ACAGATAGAC
  AGATAGATAG               ACAGACAGAT
  AGACAGACTG                 ATAGATAGAT
   AGATAGATAG                 AATGACAGAT
     CGATTGAATG               ACAGATAGAT
       CGACAGATAG             ATAGACAGAT
         AGAGTGATAG          ATTGATCGAC
           TGATTGATAG      ACTGATTGAT
             AGACAGATAG  AGTGACAGAT
               CGACAGA TAGATAGATA
                 GATA GATAGATAG
                    ATAGACAGA G
                  AGATAGATAG ACA
                GTCGCAAGTTC GCTCACA
])=~s//s+//g;%a=map{chr $_=>$i++}65,84,67,
71;$p=join$;,keys%a;while($d=~/([$p]{4})/g
){next if$j++%96>=16;$c=0;for$d(0..3){$c+=
$a{substr($1,$d,1)}*(4**$d)}$perl.=chr $c}
             eval $perl;

Cuando se ejecuta, imprime Just another genome hacker.

Después de ejecutar el código a través de Deparse y perltidy ( perl -MO=Deparse jagh.pl | perltidy ) el código se ve así:

( my $d =
"AA...GCTCACA/n" # snipped double helix part
) =~ s//s+//g;
(%a) = map( { chr $_, $i++; } 65, 84, 67, 71 );
$p = join( $;, keys %a );
while ( $d =~ /([$p]{4})/g ) {
    next if $j++ % 96 >= 16;
    $c = 0;
    foreach $d ( 0 .. 3 ) {
        $c += $a{ substr $1, $d, 1 } * 4**$d;
    }
    $perl .= chr $c;
}

Esto es lo que he podido descifrar por mi cuenta.

( my $d =
"AA...GCTCACA/n" # snipped double helix part
) =~ s//s+//g;

elimina todos los espacios en blanco en $d (la doble hélice).

(%a) = map( { chr $_, $i++; } 65, 84, 67, 71 );

hace un hash con las teclas A , T , C y G y como valores 0 , 1 , 2 y 3 . Normalmente código en Python, por lo que esto se traduce en un diccionario {''A'': 0, ''B'': 1, ''C'': 2, ''D'': 3} en Python.

$p = join( $;, keys %a );

une las teclas del hash con $; el separador de subíndices para la emulación de matriz multidimensional . La documentación dice que el valor predeterminado es "/ 034", lo mismo que SUBSEP en awk, pero cuando lo hago:

my @ascii = unpack("C*", $p);
print @ascii[1];

Me sale el valor 28 ? Además, no me queda claro cómo emula esto una matriz multidimensional. ¿Es $p algo así como [[''A''], [''T''], [''C''], [''G'']] en Python?

    while ( $d =~ /([$p]{4})/g ) {

Siempre que $d coincida ([$p]{4}) , ejecute el código en el bloque while. pero como no entiendo completamente qué estructura es $p , también me cuesta entender qué sucede aquí.

next if $j++ % 96 >= 16;

Continúe si el $j módulo 96 es mayor o igual a 16. Incrementos de $j con cada pasada del ciclo while (?).

$c = 0;
foreach $d ( 0 .. 3 ) {
    $c += $a{ substr $1, $d, 1 } * 4**$d;
}

Para $d en el rango de 0 a 3 extrae alguna subcadena, pero en este punto estoy completamente perdido. Las últimas líneas concatenan todo y evalúan el resultado.

Answer 1

Precaución : no ejecute ciegamente perl ofuscado, especialmente si hay un eval , backticks, system , open , etc. llame a algún lugar y eso puede no ser demasiado obvio ^* . Deparse con Deparse y reemplazar cuidadosamente las eval con declaraciones impresas es una obligación hasta que comprenda lo que está sucediendo. También se debe considerar ejecutar en una zona de pruebas / con un usuario sin privilegios / en una máquina virtual.

_{^* s&&$_ⅇ evalúa $_ por intance.}

Primera observación: 034 es octal. Es igual a 28 (dec) o 0x1c (hex), por lo que no hay nada sospechoso allí.

El $; la cosa es pura ofuscación, no puedo encontrar una razón para usar eso en particular. $p solo será una cadena ATCG (con . reemplazado por $; lo que sea).
Por lo tanto, en la expresión regular [$p] coincide cualquiera de {''A'', ''T'', ''C'', ''G'', $;} . Desde $; nunca aparece en $d , es inútil allí. A su vez [$p]{4} coincide con cualquier secuencia de cuatro letras en el conjunto anterior, como si se hubiera usado (ignorando el inútil $; ):

while ( $d =~ /([ATCG]{4})/g ) { ... }

Si tuviera que escribir esto usted mismo, después de haber eliminado el espacio en blanco, simplemente tomaría cada subcadena sucesiva de $d de longitud cuatro (suponiendo que no haya otros caracteres en $d ).

Ahora esta parte es divertida:

foreach $d ( 0 .. 3 ) {
    $c += $a{ substr $1, $d, 1 } * 4**$d;
}

• $1 contiene el punto de código actual de cuatro letras. substr $1, $d, 1 devuelve cada letra sucesiva de ese punto de código.

• %a asigna A a 00b (binario), T a 01b, C a 10b y G a 11b.

  A   00
  T   01
  C   10
  G   11

• multiplicar por 4**$d será equivalente a un desplazamiento a la izquierda en el bit de 0, 2, 4 y 6.

¡Así que esta divertida construcción te permite construir cualquier valor de 8 bits en el sistema de base cuatro con ATCG como dígitos!

es decir, hace las siguientes conversiones:

         A A A A
AAAA -> 00000000

         T A A T
TAAT -> 01000001 -> capital A in ascii

         T A A C
CAAT -> 01000010 -> capital B in ascii

CAATTCCTGGCTGTATTTCTTTCTGCCT -> BioGeek

Esta parte:

next if $j++ % 96 >= 16;

hace que la conversión anterior se ejecute solo para los primeros 16 "puntos de código", se salta los siguientes 80, luego se convierte para los siguientes 16, salta los siguientes 80, etc. Básicamente se saltea partes de la elipse (sistema de eliminación de ADN basura).

Aquí hay un feo convertidor de texto a ADN que puede usar para producir cualquier cosa que reemplace la hélice (no maneja el tema de omisión de 80):

use strict;
use warnings;
my $in = shift;

my %conv = ( 0 => ''A'', 1 => ''T'', 2 => ''C'', 3 => ''G'');

for (my $i=0; $i<length($in); $i++) {
    my $chr = substr($in, $i, 1);
    my $chv = ord($chr);
    my $encoded ="";
    $encoded .= $conv{($chv >> 0) & 0x3};
    $encoded .= $conv{($chv >> 2) & 0x3};
    $encoded .= $conv{($chv >> 4) & 0x3};
    $encoded .= $conv{($chv >> 6) & 0x3};
    print $encoded;
}
print "/n";

$ perl q.pl ''print "BioGeek/n";''
AAGTCAGTTCCTCGCTATGTAACACACACAATTCCTGGCTGTATTTCTTTCTGCCTAGTTCGCTCACAGCGA

Adhiere $d que en lugar de la hélice (y elimina la parte de saltar en el decodificador).