perlfilter - Online en la nube

PROGRAMA:

NOMBRE

perlfilter - Filtros de origen

DESCRIPCIÓN

Este artículo trata sobre una característica poco conocida de Perl llamada fuente filtros. Filtros de origen
alterar el texto del programa de un módulo antes de que Perl lo vea, tanto como un preprocesador de C altera
el texto fuente de un programa en C antes de que el compilador lo vea. Este artículo te dice más
sobre qué son los filtros de origen, cómo funcionan y cómo escribir los suyos.

El propósito original de los filtros de fuente era permitirle cifrar la fuente de su programa para
prevenir la piratería casual. Esto no es todo lo que pueden hacer, como pronto aprenderá. Pero primero, el
lo esencial.

CONCEPTOS

Antes de que el intérprete de Perl pueda ejecutar un script de Perl, primero debe leerlo desde un archivo
en la memoria para su análisis y compilación. Si ese mismo script incluye otros scripts con
una declaración "use" o "require", entonces cada uno de esos scripts deberá leerse desde su
respectivos archivos también.

Ahora piense en cada conexión lógica entre el analizador de Perl y un archivo individual como un
fuente stream. Se crea una secuencia de origen cuando el analizador de Perl abre un archivo, continúa
para existir cuando el código fuente se lee en la memoria, y se destruye cuando se termina Perl
analizar el archivo. Si el analizador encuentra una instrucción "require" o "use" en una fuente
secuencia, se crea una secuencia nueva y distinta solo para ese archivo.

El siguiente diagrama representa un flujo de fuente único, con el flujo de fuente de un Perl
archivo de script de la izquierda en el analizador de Perl de la derecha. Así es como Perl normalmente
opera

archivo -------> analizador

Hay dos puntos importantes para recordar:

1. Aunque puede haber una cantidad ilimitada de flujos de origen en un momento dado,
solo uno estará activo.

2. Cada flujo de origen está asociado con un solo archivo.

Un filtro de fuente es un tipo especial de módulo Perl que intercepta y modifica una fuente.
stream antes de que llegue al analizador. Un filtro de fuente cambia nuestro diagrama de esta manera:

archivo ----> filtro ----> analizador

Si eso no tiene mucho sentido, considere la analogía de una canalización de comandos. Di que tienes
un script de shell almacenado en el archivo comprimido ensayo.gz. El comando de canalización simple a continuación
ejecuta el script sin necesidad de crear un archivo temporal para contener el archivo sin comprimir.

gunzip -c prueba.gz | sh

En este caso, el flujo de datos de la canalización se puede representar de la siguiente manera:

trial.gz ----> gunzip ----> sh

Con los filtros de fuente, puede almacenar el texto de su script comprimido y usar una fuente
filter para descomprimirlo para el analizador de Perl:

gunzip comprimido
Programa Perl ---> filtro de origen ---> analizador

USO FILTROS

Entonces, ¿cómo se usa un filtro de origen en un script de Perl? Arriba, dije que un filtro de fuente es
solo un tipo especial de módulo. Como todos los módulos de Perl, un filtro de origen se invoca con un
declaración de uso.

Supongamos que desea pasar su fuente de Perl a través del preprocesador de C antes de la ejecución. Como lo
sucede, la distribución de filtros de origen viene con un módulo de filtro de preprocesador C llamado
Filtro :: cpp.

A continuación se muestra un programa de ejemplo, "cpp_test", que utiliza este filtro. Línea de números
Se han agregado para permitir que las líneas específicas sean referenciadas fácilmente.

1: use Filter :: cpp;
2: #define VERDADERO 1
3: $ a = VERDADERO;
4: imprime "a = $ a \ n";

Cuando ejecuta este script, Perl crea una secuencia de origen para el archivo. Antes del analizador
procesa cualquiera de las líneas del archivo, el flujo de origen se ve así:

cpp_test ---------> analizador

La línea 1, "use Filter :: cpp", incluye e instala el módulo de filtro "cpp". Toda la fuente
los filtros funcionan de esta manera. La declaración de uso se compila y ejecuta en tiempo de compilación, antes
se lee más del archivo, y adjunta el filtro cpp al flujo de origen detrás
las escenas. Ahora el flujo de datos se ve así:

cpp_test ----> filtro cpp ----> analizador

A medida que el analizador lee la segunda línea y las siguientes del flujo de origen, las alimenta
líneas a través del filtro de origen "cpp" antes de procesarlas. El filtro "cpp" simplemente
pasa cada línea a través del preprocesador C real. La salida del preprocesador de C es
luego insertado de nuevo en el flujo de origen por el filtro.

.-> cpp -.
| |
| |
| <- '
cpp_test ----> filtro cpp ----> analizador

El analizador luego ve el siguiente código:

use Filter :: cpp;
$ a = 1;
imprimir "a = $ a \ n";

Consideremos qué sucede cuando el código filtrado incluye otro módulo con uso:

1: use Filter :: cpp;
2: #define VERDADERO 1
3: usa Fred;
4: $ a = VERDADERO;
5: imprime "a = $ a \ n";

El filtro "cpp" no se aplica al texto del módulo Fred, solo al texto del
archivo que lo utilizó ("cpp_test"). Aunque la declaración de uso en la línea 3 pasará por el
cpp, el módulo que se incluye ("Fred") no lo hará. Las transmisiones de origen se ven como
esto después de analizar la línea 3 y antes de analizar la línea 4:

cpp_test ---> filtro cpp ---> analizador (INACTIVO)

Fred.pm ----> analizador

Como puede ver, se ha creado una nueva secuencia para leer la fuente de "Fred.pm". Esta
El flujo permanecerá activo hasta que se haya analizado todo "Fred.pm". El flujo de origen para
"cpp_test" seguirá existiendo, pero está inactivo. Una vez que el analizador ha terminado de leer
Fred.pm, se destruirá el flujo de origen asociado a él. El flujo de origen para
"cpp_test" vuelve a activarse y el analizador lee la línea 4 y las siguientes de
"cpp_test".

Puede utilizar más de un filtro de origen en un solo archivo. Del mismo modo, puede reutilizar el
mismo filtro en tantos archivos como desee.

Por ejemplo, si tiene un archivo fuente comprimido y codificado en uuen, es posible apilar un
uudecode filter y un filtro de descompresión como este:

use Filter :: uudecode; use Filter :: descomprimir;
M'XL(".H<US4''V9I;F%L')Q;>7/;1I;_>_I3=&E=%:F*I"T?22Q/
M6] 9 *
...

Una vez que se haya procesado la primera línea, el flujo se verá así:

archivo ---> uudecode ---> descomprimir ---> analizador
filtro filtro

Los datos fluyen a través de los filtros en el mismo orden en que aparecen en el archivo de origen. El uudecode
filtro apareció antes del filtro de descompresión, por lo que el archivo de origen se codificará antes
está descomprimido.

ESCRITURA A FUENTE FILTRO

Hay tres formas de escribir su propio filtro de fuente. Puedes escribirlo en C, usa un
programa externo como filtro, o escriba el filtro en Perl. No cubriré los dos primeros en
cualquier gran detalle, así que primero los sacaré del camino. Escribir el filtro en Perl es
más conveniente, así que le dedicaré la mayor parte del espacio.

ESCRITURA A FUENTE FILTRO IN C

La primera de las tres técnicas disponibles es escribir el filtro completamente en C.
módulo externo, crea interfaces directamente con los ganchos de filtro de fuente proporcionados por
perla

La ventaja de esta técnica es que tiene un control total sobre la implementación
de su filtro. La gran desventaja es la mayor complejidad requerida para escribir el
filtro: no solo necesita comprender los ganchos del filtro de origen, sino que también necesita un
conocimiento razonable de las agallas de Perl. Una de las pocas veces que vale la pena tomarse esta molestia.
es cuando se escribe un codificador de fuentes. El filtro "descifrar" (que descifra la fuente
antes de que Perl lo analice) incluido con la distribución del filtro de origen es un ejemplo de un C
filtro de origen (consulte Filtros de descifrado, a continuación).

descifrado Filtros
Todos los filtros de descifrado funcionan según el principio de "seguridad a través de la oscuridad".
Independientemente de qué tan bien escriba un filtro de descifrado y qué tan fuerte sea su cifrado
El algoritmo es que cualquiera que esté lo suficientemente determinado puede recuperar el código fuente original. los
La razón es bastante simple: una vez que el filtro de descifrado ha descifrado la fuente de nuevo a
su forma original, fragmentos se almacenarán en la memoria de la computadora como Perl
lo analiza. Es posible que la fuente solo esté en la memoria durante un corto período de tiempo, pero cualquiera
poseer un depurador, habilidad y mucha paciencia puede eventualmente reconstruir su
.

Dicho esto, hay una serie de pasos que se pueden tomar para dificultar la vida de
el potencial cracker. Lo más importante: escriba su filtro de descifrado en C y
enlazar estáticamente el módulo de descifrado en el binario de Perl. Para obtener más consejos para hacer
la vida es difícil para el potencial cracker, vea el archivo desencriptar.pm en la fuente
distribución de filtros.

CREANDO A FUENTE FILTRO AS A SEPARAR EJECUTABLE

Una alternativa a escribir el filtro en C es crear un ejecutable separado en el
idioma de su elección. El ejecutable separado lee de la entrada estándar, hace lo que sea
el procesamiento es necesario y escribe los datos filtrados en la salida estándar. "Filter :: cpp" es
un ejemplo de un filtro de fuente implementado como un ejecutable separado - el ejecutable es el
Preprocesador de C incluido con su compilador de C.

La distribución del filtro de origen incluye dos módulos que simplifican esta tarea:
"Filtro :: exec" y "Filtro :: sh". Ambos le permiten ejecutar cualquier ejecutable externo. Ambos usan un
coproceso para controlar el flujo de datos dentro y fuera del ejecutable externo. (Para
detalles sobre coprocesos, consulte Stephens, WR, "Programación avanzada en UNIX
Environment. "Addison-Wesley, ISBN 0-210-56317-7, páginas 441-445.) La diferencia entre
ellos es que "Filter :: exec" genera el comando externo directamente, mientras que "Filter :: sh"
genera un shell para ejecutar el comando externo. (Unix usa el shell Bourne; NT usa el
cmd shell.) Generar un shell le permite hacer uso de los metacaracteres de shell y
instalaciones de redireccionamiento.

Aquí hay un script de ejemplo que usa "Filter :: sh":

use Filter :: sh 'tr XYZ PQR';
$ a = 1;
imprimir "XYZ a = $ a \ n";

El resultado que obtendrá cuando se ejecute el script:

PQR a = 1

Escribir un filtro de origen como un ejecutable independiente funciona bien, pero tiene un rendimiento reducido
se incurre en penalización. Por ejemplo, si ejecuta el pequeño ejemplo anterior, una
Se creará un subproceso para ejecutar el comando "tr" de Unix. Cada uso del filtro requiere
su propio subproceso. Si la creación de subprocesos es costosa en su sistema, es posible que desee
considerar una de las otras opciones para crear filtros de origen.

ESCRITURA A FUENTE FILTRO IN PERL

La opción más fácil y portátil disponible para crear su propio filtro de fuente es
escríbalo completamente en Perl. Para distinguir esto de las dos técnicas anteriores,
llámelo un filtro de fuente Perl.

Para ayudar a comprender cómo escribir un filtro de fuente Perl, necesitamos un ejemplo para estudiar. Aquí está
un filtro de fuente completo que realiza la decodificación rot13. (Rot13 es un cifrado muy simple
esquema utilizado en publicaciones de Usenet para ocultar el contenido de publicaciones ofensivas. Se mueve cada
letra hacia adelante trece lugares, de modo que A se convierte en N, B se convierte en O y Z se convierte en M.)

paquete Rot13;

use Filter :: Util :: Call;

subimportación {
mi ($ tipo) = @_;
mi ($ ref) = [];
filter_add (bendiga $ ref);
}

subfiltro {
mi ($ yo) = @_;
mi ($ estado);

tr / n-za-mN-ZA-M / a-zA-Z /
if ($ status = filter_read ())> 0;
$ estado;
}

1;

Todos los filtros de origen de Perl se implementan como clases de Perl y tienen la misma estructura básica
como el ejemplo anterior.

Primero, incluimos el módulo "Filter :: Util :: Call", que exporta una serie de funciones
en el espacio de nombres de su filtro. El filtro que se muestra arriba usa dos de estas funciones,
"filter_add ()" y "filter_read ()".

A continuación, creamos el objeto de filtro y lo asociamos con el flujo de origen definiendo el
función "importar". Si conoce Perl lo suficientemente bien, sabrá que "importar" se llama
automáticamente cada vez que se incluye un módulo con una declaración de uso. Esto hace "importación"
el lugar ideal para crear e instalar un objeto de filtro.

En el filtro de ejemplo, el objeto ($ ref) está bendecido como cualquier otro objeto de Perl. Nuestro
ejemplo usa una matriz anónima, pero esto no es un requisito. Porque este ejemplo
no necesita almacenar ninguna información de contexto, podríamos haber usado un escalar o un hash
referencia igualmente. La siguiente sección muestra datos de contexto.

La asociación entre el objeto de filtro y el flujo de origen se realiza con el
Función "filter_add ()". Esto toma un objeto de filtro como parámetro ($ ref en este caso) y
lo instala en el flujo de origen.

Finalmente, está el código que realmente hace el filtrado. Para este tipo de fuente Perl
filter, todo el filtrado se realiza en un método llamado "filter ()". (También es posible
escriba un filtro de fuente Perl usando un cierre. Consulte la página de manual "Filter :: Util :: Call" para
más detalles.) Se llama cada vez que el analizador de Perl necesita otra línea de fuente para
proceso. El método "filter ()", a su vez, lee las líneas del flujo de origen utilizando el
Función "filter_read ()".

Si había una línea disponible en el flujo de origen, "filter_read ()" devuelve un valor de estado
mayor que cero y agrega la línea a $ _. Un valor de estado de cero indica el fin de
archivo, menos de cero significa un error. Se espera que la propia función de filtro devuelva su
estado de la misma manera, y coloque la línea filtrada que desea escribir en el flujo de origen en
PS El uso de $ _ explica la brevedad de la mayoría de los filtros fuente de Perl.

Para hacer uso del filtro rot13 necesitamos alguna forma de codificar el archivo fuente en
formato rot13. El siguiente script, "mkrot13", hace precisamente eso.

muere "use mkrot13 filename \ n" a menos que @ARGV;
my $ in = $ ARGV [0];
my $ out = "$ in.tmp";
abrir (IN, "<$ in") o morir "No se puede abrir el archivo $ in: $! \ n";
abrir (OUT, "> $ out") o morir "No se puede abrir el archivo $ out: $! \ n";

imprimir "use Rot13; \ n";
tiempo ( ) {
tr / a-zA-Z / n-za-mN-ZA-M /;
imprimir;
}

acercarse;
cerrar;
desvincular $ in;
renombrar $ out, $ in;

Si ciframos esto con "mkrot13":

imprimir "hola fred \ n";

el resultado será este:

usar Rot13;
cevag "uryyb serq \ a";

Ejecutarlo produce esta salida:

hola fred

USO CONTEXTO: DEBUG FILTRO

El ejemplo de rot13 fue un ejemplo trivial. Aquí hay otra demostración que muestra algunos
más características.

Supongamos que desea incluir mucho código de depuración en su script Perl durante el desarrollo,
pero no quería que estuviera disponible en el producto lanzado. Los filtros de fuente ofrecen una solución.
Para mantener el ejemplo simple, digamos que desea que la salida de depuración sea
controlado por una variable de entorno, "DEBUG". El código de depuración está habilitado si la variable
existe, de lo contrario está deshabilitado.

Dos líneas de marcador especiales colocarán entre corchetes el código de depuración, como este:

## DEBUG_BEGIN
if ($ año> 1999) {
advertir "Depurar: error del milenio en el año $ año \ n";
}
## DEBUG_END

El filtro asegura que Perl analiza el código entre los y "DEBUG_END"
marcadores sólo cuando existe la variable de entorno "DEBUG". Eso significa que cuando "DEBUG"
existe, el código anterior debe pasarse a través del filtro sin cambios. Las líneas de marcador
también se pueden pasar tal cual, porque el analizador de Perl los verá como líneas de comentarios.
Cuando "DEBUG" no está configurado, necesitamos una forma de deshabilitar el código de depuración. Una forma sencilla de lograr
es decir, convertir las líneas entre los dos marcadores en comentarios:

## DEBUG_BEGIN
#if ($ año> 1999) {
# advertir "Depuración: error del milenio en el año $ año \ n";
#}
## DEBUG_END

Aquí está el filtro de depuración completo:

paquete Debug;

uso estricto
use advertencias;
use Filter :: Util :: Call;

use constante VERDADERO => 1;
use constante FALSE => 0;

subimportación {
mi ($ tipo) = @_;
mi (% contexto) = (
Habilitado => definido $ ENV {DEBUG},
InTraceBlock => FALSO,
Nombre de archivo => (llamador) [1],
LineNo => 0,
LastBegin => 0,
);
filter_add (bendiga \% contexto);
}

morir secundario {
my ($ self) = turno;
mi ($ mensaje) = turno;
my ($ line_no) = turno || $ self -> {LastBegin};
muere "$ mensaje en $ self -> {Nombre de archivo} línea $ line_no. \ n"
}

subfiltro {
mi ($ yo) = @_;
mi ($ estado);
$ estado = filter_read ();
++ $ self -> {LineNo};

# tratar con EOF / error primero
if ($ status <= 0) {
$ self-> Die ("DEBUG_BEGIN no tiene DEBUG_END")
if $ self -> {InTraceBlock};
return $ status;
}

if ($ self -> {InTraceBlock}) {
if (/ ^ \ s * ## \ s * DEBUG_BEGIN /) {
$ self-> Die ("DEBUG_BEGIN anidado", $ self -> {LineNo})
} elsif (/ ^ \ s * ## \ s * DEPURACIÓN_END /) {
$ self -> {InTraceBlock} = FALSE;
}

# comenta las líneas de depuración cuando el filtro está deshabilitado
s / ^ / # / if! $ self -> {Habilitado};
} elsif (/ ^ \ s * ## \ s * DEBUG_BEGIN /) {
$ self -> {InTraceBlock} = VERDADERO;
$ self -> {LastBegin} = $ self -> {LineNo};
} elsif (/ ^ \ s * ## \ s * DEPURACIÓN_END /) {
$ self-> Die ("DEBUG_END no tiene DEBUG_BEGIN", $ self -> {LineNo});
}
return $ status;
}

1;

La gran diferencia entre este filtro y el ejemplo anterior es el uso de datos de contexto.
en el objeto de filtro. El objeto de filtro se basa en una referencia hash y se usa para mantener
varias piezas de información de contexto entre llamadas a la función de filtro. Todos menos dos de
los campos hash se utilizan para informar de errores. El primero de esos dos, habilitado, es utilizado por
el filtro para determinar si el código de depuración debe entregarse al analizador de Perl. los
segundo, InTraceBlock, es verdadero cuando el filtro ha encontrado una línea "DEBUG_BEGIN", pero
aún no ha encontrado la siguiente línea "DEBUG_END".

Si ignora todos los errores comprobando que hace la mayor parte del código, la esencia del filtro
es el siguiente:

subfiltro {
mi ($ yo) = @_;
mi ($ estado);
$ estado = filter_read ();

# tratar con EOF / error primero
devuelve $ status si $ status <= 0;
if ($ self -> {InTraceBlock}) {
if (/ ^ \ s * ## \ s * DEBUG_END /) {
$ self -> {InTraceBlock} = FALSE
}

# comentar las líneas de depuración cuando el filtro está deshabilitado
s / ^ / # / if! $ self -> {Habilitado};
} elsif (/ ^ \ s * ## \ s * DEBUG_BEGIN /) {
$ self -> {InTraceBlock} = VERDADERO;
}
return $ status;
}

Tenga cuidado: así como el preprocesador C no conoce C, el filtro Debug no conoce Perl.
Se puede engañar con bastante facilidad:

imprimir <
## DEBUG_BEGIN
MOE

Dejando esas cosas a un lado, puede ver que se puede lograr mucho con una cantidad modesta de código.

CONCLUSIÓN

Ahora comprende mejor qué es un filtro de origen e incluso puede tener un
posible uso para ellos. Si tiene ganas de jugar con filtros de fuente pero necesita un poco de
inspiración, aquí hay algunas características adicionales que podría agregar al filtro de depuración.

Primero, uno fácil. En lugar de tener un código de depuración que sea todo o nada, sería
mucho más útil para poder controlar qué bloques específicos de código de depuración obtienen
incluido. Intente ampliar la sintaxis de los bloques de depuración para permitir la identificación de cada uno. los
El contenido de la variable de entorno "DEBUG" se puede utilizar para controlar qué bloques se obtienen
incluido.

Una vez que pueda identificar los bloques individuales, intente permitir que se aniden. Eso no es
difícil tampoco.

Aquí hay una idea interesante que no involucra el filtro de depuración. Actualmente Perl
Las subrutinas tienen un soporte bastante limitado para listas de parámetros formales. Puede especificar el
número de parámetros y su tipo, pero aún tiene que sacarlos manualmente del
@_ array usted mismo. Escriba un filtro de origen que le permita tener una lista de parámetros con nombre.
Tal filtro convertiría esto:

sub MySub ($ primero, $ segundo, @resto) {...}

dentro de esto:

sub MySub ($$ @) {
my ($ primero) = turno;
mi ($ segundo) = turno;
mi (@resto) = @_;
...
}

Finalmente, si se siente como un verdadero desafío, intente escribir una macro Perl en toda regla
preprocesador como filtro de origen. Tome prestadas las funciones útiles del preprocesador de C y
cualquier otro macroprocesador que conozca. La parte complicada será elegir cuánto conocimiento de
La sintaxis de Perl que desea que tenga su filtro.

LIMITACIONES

Los filtros de origen solo funcionan a nivel de cadena, por lo que su capacidad para
cambiar el código fuente sobre la marcha. No puede detectar comentarios, cadenas entre comillas, heredocs, es
no sustituye a un analizador sintáctico real. El único uso estable de los filtros de origen es
cifrado, compresión o el cargador de bytes, para traducir el código binario de nuevo al código fuente.

Vea, por ejemplo, las limitaciones en Switch, que usa filtros de origen y, por lo tanto, no
trabajar dentro de una cadena eval, la presencia de expresiones regulares con nuevas líneas incrustadas que son
especificado con delimitadores sin procesar /.../ y no tienen un modificador // x son indistinguibles
de fragmentos de código que comienzan con el operador de división /. Como solución alternativa, debe utilizar
m /.../ o m? ...? para tales patrones. Además, ¿la presencia de expresiones regulares especificadas con raw? ...?
los delimitadores pueden causar errores misteriosos. La solución es utilizar m? ...? en lugar de. Ver
http://search.cpan.org/perldoc? Switch # LIMITACIONES

Actualmente, las longitudes del búfer interno están limitadas a solo 32 bits.

COSAS A Mire OUT PARA

Algunos filtros golpean el identificador "DATOS"
Algunos filtros de origen utilizan el identificador "DATA" para leer el programa que realiza la llamada. Cuando usas
estos filtros de origen no puede confiar en este identificador, ni esperar ningún tipo en particular
de comportamiento al operar en él. Filtros basados ​​en Filter :: Util :: Call (y por lo tanto
Filter :: Simple) no modifique el identificador de archivo "DATA".

REQUISITOS

La distribución de filtros de origen está disponible en CPAN, en

CPAN / módulos / por módulo / Filtro

A partir de Perl 5.8 Filter :: Util :: Call (la parte central de los filtros de origen
distribución) es parte de la distribución estándar de Perl. También se incluye un más amigable
interfaz llamada Filter :: Simple, de Damian Conway.

Use perlfilter en línea usando los servicios de onworks.net