perlfilterp - En ligne dans le Cloud

PROGRAMME:

Nom

perlfilter - Filtres sources

DESCRIPTION

Cet article concerne une fonctionnalité peu connue de Perl appelée source filtres. Filtres sources
modifier le texte du programme d'un module avant que Perl ne le voie, de la même manière qu'un préprocesseur C modifie
le texte source d'un programme C avant que le compilateur ne le voie. Cet article vous en dit plus
sur ce que sont les filtres de source, comment ils fonctionnent et comment écrire les vôtres.

Le but initial des filtres de source était de vous permettre de crypter la source de votre programme pour
empêcher le piratage occasionnel. Ce n'est pas tout ce qu'ils peuvent faire, comme vous l'apprendrez bientôt. Mais d'abord, le
les bases.

NOTIONS

Avant que l'interpréteur Perl puisse exécuter un script Perl, il doit d'abord le lire à partir d'un fichier
en mémoire pour l'analyse et la compilation. Si ce script lui-même inclut d'autres scripts avec
une déclaration « use » ou « require », alors chacun de ces scripts devra être lu à partir de leur
également les fichiers respectifs.

Considérez maintenant chaque connexion logique entre l'analyseur Perl et un fichier individuel comme un
source courant. Un flux source est créé lorsque l'analyseur Perl ouvre un fichier, il continue
exister lorsque le code source est lu en mémoire, et il est détruit lorsque Perl est terminé
l'analyse du fichier. Si l'analyseur rencontre une instruction "require" ou "use" dans une source
stream, un nouveau flux distinct est créé uniquement pour ce fichier.

Le schéma ci-dessous représente un flux source unique, avec le flux de source d'un Perl
script à gauche dans l'analyseur Perl à droite. C'est comme ça que Perl normalement
fonctionne

fichier -------> analyseur

Il y a deux points importants à retenir :

1. Bien qu'il puisse y avoir n'importe quel nombre de flux source à un moment donné,
un seul sera actif.

2. Chaque flux source est associé à un seul fichier.

Un filtre source est un type spécial de module Perl qui intercepte et modifie une source
stream avant qu'il n'atteigne l'analyseur. Un filtre source modifie notre schéma comme ceci :

fichier ----> filtre ----> analyseur

Si cela n'a pas beaucoup de sens, considérez l'analogie d'un pipeline de commandes. Dites que vous avez
un script shell stocké dans le fichier compressé essai.gz. La commande pipeline simple ci-dessous
exécute le script sans avoir besoin de créer un fichier temporaire pour contenir le fichier non compressé.

gunzip -c trial.gz | merde

Dans ce cas, le flux de données du pipeline peut être représenté comme suit :

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

Avec les filtres source, vous pouvez stocker le texte de votre script compressé et utiliser une source
filter pour le décompresser pour l'analyseur de Perl :

gunzip compressé
Programme Perl ---> filtre source ---> analyseur

EN UTILISANT FILTRES

Alors, comment utiliser un filtre source dans un script Perl ? Plus haut, j'ai dit qu'un filtre source est
juste un type spécial de module. Comme tous les modules Perl, un filtre source est invoqué avec un
déclaration d'utilisation.

Supposons que vous vouliez passer votre source Perl via le préprocesseur C avant l'exécution. Tel quel
arrive, la distribution des filtres source est livrée avec un module de filtre de préprocesseur C appelé
Filtre::cpp.

Vous trouverez ci-dessous un exemple de programme, "cpp_test", qui utilise ce filtre. Numéros de ligne
ont été ajoutés pour permettre de référencer facilement des lignes spécifiques.

1 : utilisez le filtre : : cpp ;
2: #définir VRAI 1
3 : $a = VRAI ;
4: print "a = $a\n" ;

Lorsque vous exécutez ce script, Perl crée un flux source pour le fichier. Avant l'analyseur
traite l'une des lignes du fichier, le flux source ressemble à ceci :

cpp_test ---------> analyseur

La ligne 1, "use Filter::cpp", inclut et installe le module de filtrage "cpp". Toutes les sources
les filtres fonctionnent de cette façon. L'instruction use est compilée et exécutée au moment de la compilation, avant
plus le fichier est lu, et il attache le filtre cpp au flux source derrière
les scènes. Maintenant, le flux de données ressemble à ceci :

cpp_test ----> filtre cpp ----> analyseur

Au fur et à mesure que l'analyseur lit la deuxième ligne et les suivantes du flux source, il alimente ces
lignes à travers le filtre source "cpp" avant de les traiter. Le filtre "cpp" simplement
passe chaque ligne à travers le vrai préprocesseur C. La sortie du préprocesseur C est
puis réinséré dans le flux source par le filtre.

.-> cpp --.
| |
| |
| <-'
cpp_test ----> filtre cpp ----> analyseur

L'analyseur voit alors le code suivant :

utiliser Filter::cpp;
$ a = 1;
print "a = $a\n" ;

Considérons ce qui se passe lorsque le code filtré inclut un autre module avec use :

1 : utilisez le filtre : : cpp ;
2: #définir VRAI 1
3 : utilisez Fred ;
4 : $a = VRAI ;
5: print "a = $a\n" ;

Le filtre "cpp" ne s'applique pas au texte du module Fred, uniquement au texte du
fichier qui l'a utilisé ("cpp_test"). Bien que la déclaration d'utilisation à la ligne 3 passera par le
filtre cpp, le module qui est inclus ("Fred") ne le sera pas. Les flux source ressemblent à
ceci après l'analyse de la ligne 3 et avant l'analyse de la ligne 4 :

cpp_test ---> filtre cpp ---> analyseur (INACTIF)

Fred.pm ----> analyseur

Comme vous pouvez le voir, un nouveau flux a été créé pour lire la source de "Fred.pm". Cette
stream restera actif jusqu'à ce que tout "Fred.pm" ait été analysé. Le flux source pour
"cpp_test" existera toujours, mais est inactif. Une fois que l'analyseur a fini de lire
Fred.pm, le flux source qui lui est associé sera détruit. Le flux source pour
"cpp_test" redevient alors actif et l'analyseur lit la ligne 4 et les lignes suivantes à partir de
"cpp_test".

Vous pouvez utiliser plusieurs filtres source sur un même fichier. De même, vous pouvez réutiliser le
même filtre dans autant de fichiers que vous le souhaitez.

Par exemple, si vous avez un fichier source uuencodé et compressé, il est possible d'empiler un
filtre uudecode et un filtre de décompression comme celui-ci :

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

Une fois la première ligne traitée, le flux ressemblera à ceci :

fichier ---> uudecode ---> décompresser ---> analyseur
filtre filtre

Les données traversent les filtres dans le même ordre qu'elles apparaissent dans le fichier source. L'uudecode
le filtre est apparu avant le filtre de décompression, le fichier source sera donc codé avant
c'est non compressé.

L'ÉCRITURE A SOURCE FILTRE

Il existe trois façons d'écrire votre propre filtre source. Vous pouvez l'écrire en C, utilisez un
programme externe en tant que filtre, ou écrivez le filtre en Perl. Je ne couvrirai pas les deux premiers dans
tous les détails, donc je vais les éliminer d'abord. L'écriture du filtre en Perl est
le plus pratique, je vais donc lui consacrer le plus d'espace.

L'ÉCRITURE A SOURCE FILTRE IN C

La première des trois techniques disponibles consiste à écrire le filtre complètement en C. Le
module externe vous créez des interfaces directement avec les crochets de filtre source fournis par
Perle.

L'avantage de cette technique est que vous avez un contrôle total sur la mise en œuvre
de votre filtre. Le gros inconvénient est la complexité accrue requise pour écrire le
filter - non seulement vous devez comprendre les crochets du filtre source, mais vous avez également besoin d'un
connaissance raisonnable des tripes de Perl. L'une des rares fois où cela vaut la peine de se donner la peine
est lors de l'écriture d'un brouilleur source. Le filtre "déchiffrer" (qui déchiffre la source
avant que Perl ne l'analyse) inclus avec la distribution du filtre source est un exemple de C
filtre source (voir Filtres de décryptage, ci-dessous).

décryptage Filtres
Tous les filtres de décryptage fonctionnent sur le principe de la "sécurité par l'obscurité".
Indépendamment de la qualité de l'écriture d'un filtre de déchiffrement et de la force de votre chiffrement
algorithme est, toute personne suffisamment déterminée peut récupérer le code source d'origine. Les
la raison est assez simple - une fois que le filtre de déchiffrement a déchiffré la source à
sa forme originale, des fragments de celui-ci seront stockés dans la mémoire de l'ordinateur en tant que Perl
l'analyse. La source peut n'être en mémoire que pendant une courte période, mais n'importe qui
posséder un débogueur, des compétences et beaucoup de patience peut éventuellement reconstruire votre
.

Cela dit, il existe un certain nombre de mesures qui peuvent être prises pour rendre la vie difficile aux
le cracker potentiel. Le plus important : Ecrivez votre filtre de décryptage en C et
lier statiquement le module de déchiffrement au binaire Perl. Pour plus de conseils pour faire
vie difficile pour le cracker potentiel, voir la fiche décrypter.pm dans la source
diffusion des filtres.

CRÉATEUR A SOURCE FILTRE AS A SÉPARÉ EXÉCUTABLE

Une alternative à l'écriture du filtre en C est de créer un exécutable séparé dans le
langue de votre choix. L'exécutable séparé lit à partir de l'entrée standard, fait n'importe quoi
le traitement est nécessaire et écrit les données filtrées sur la sortie standard. "Filtre :: cpp" est
un exemple de filtre source implémenté en tant qu'exécutable séparé - l'exécutable est le
Préprocesseur C fourni avec votre compilateur C.

La distribution du filtre source comprend deux modules qui simplifient cette tâche :
"Filter::exec" et "Filter::sh". Les deux vous permettent d'exécuter n'importe quel exécutable externe. Les deux utilisent un
coprocess pour contrôler le flux de données entrant et sortant de l'exécutable externe. (Pour
détails sur les coprocessus, voir Stephens, WR, "Advanced Programming in the UNIX
Environnement." Addison-Wesley, ISBN 0-210-56317-7, pages 441-445.) La différence entre
c'est que "Filter::exec" génère directement la commande externe, tandis que "Filter::sh"
génère un shell pour exécuter la commande externe. (Unix utilise le shell Bourne ; NT utilise le
cmd shell.) Générer un shell vous permet d'utiliser les métacaractères du shell et
facilités de redirection.

Voici un exemple de script qui utilise "Filter::sh":

utiliser Filter::sh 'tr XYZ PQR';
$ a = 1;
print "XYZ a = $a\n" ;

La sortie que vous obtiendrez lorsque le script est exécuté :

PQRa = 1

L'écriture d'un filtre source en tant qu'exécutable séparé fonctionne bien, mais une petite performance
pénalité est encourue. Par exemple, si vous exécutez le petit exemple ci-dessus, un
un sous-processus sera créé pour exécuter la commande Unix "tr". Chaque utilisation du filtre nécessite
son propre sous-processus. Si la création de sous-processus coûte cher sur votre système, vous voudrez peut-être
d'envisager l'une des autres options de création de filtres source.

L'ÉCRITURE A SOURCE FILTRE IN PERL

L'option la plus simple et la plus portable disponible pour créer votre propre filtre source est de
écrivez-le complètement en Perl. Pour distinguer cela des deux techniques précédentes, je vais
appelez cela un filtre source Perl.

Pour aider à comprendre comment écrire un filtre source Perl, nous avons besoin d'un exemple à étudier. Voici
un filtre source complet qui effectue le décodage rot13. (Rot13 est un cryptage très simple
schéma utilisé dans les publications Usenet pour masquer le contenu des publications offensantes. Il bouge chaque
lettre en avant de treize places, de sorte que A devienne N, B devienne O et Z devienne M.)

paquet Rot13;

utiliser Filter::Util::Call;

sous-importation {
mon ($type) = @_;
mon ($ref) = [];
filter_add(bénis $ref);
}

sous-filtre {
mon ($self) = @_;
mon (statut) ;

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

1;

Tous les filtres source Perl sont implémentés en tant que classes Perl et ont la même structure de base
comme l'exemple ci-dessus.

Tout d'abord, nous incluons le module "Filter::Util::Call", qui exporte un certain nombre de fonctions
dans l'espace de noms de votre filtre. Le filtre ci-dessus utilise deux de ces fonctions,
"filter_add()" et "filter_read()".

Ensuite, nous créons l'objet filtre et l'associons au flux source en définissant le
fonction "importation". Si vous connaissez assez bien Perl, vous savez que "import" s'appelle
automatiquement chaque fois qu'un module est inclus avec une instruction use. Cela fait "importer"
l'endroit idéal pour créer et installer un objet filtre.

Dans l'exemple de filtre, l'objet ($ref) est béni comme n'importe quel autre objet Perl. Notre
exemple utilise un tableau anonyme, mais ce n'est pas une exigence. Parce que cet exemple
n'a pas besoin de stocker d'informations contextuelles, nous aurions pu utiliser un scalaire ou un hachage
référence tout aussi bien. La section suivante présente les données contextuelles.

L'association entre l'objet filtre et le flux source se fait avec le
fonction "filter_add()". Cela prend un objet filtre comme paramètre ($ref dans ce cas) et
l'installe dans le flux source.

Enfin, il y a le code qui fait réellement le filtrage. Pour ce type de source Perl
filter, tout le filtrage est effectué dans une méthode appelée "filter()". (Il est également possible de
écrire un filtre source Perl en utilisant une fermeture. Voir la page de manuel "Filter::Util::Call" pour
plus de détails.) Il est appelé chaque fois que l'analyseur Perl a besoin d'une autre ligne de source pour
traiter. La méthode "filter()", à son tour, lit les lignes du flux source en utilisant le
fonction "filter_read()".

Si une ligne était disponible depuis le flux source, "filter_read()" renvoie une valeur d'état
supérieur à zéro et ajoute la ligne à $_. Une valeur d'état de zéro indique la fin de
fichier, moins de zéro signifie une erreur. La fonction de filtrage elle-même devrait renvoyer son
status de la même manière, et mettre la ligne filtrée qu'il veut écrite dans le flux source dans
$_. L'utilisation de $_ explique la brièveté de la plupart des filtres source Perl.

Afin d'utiliser le filtre rot13, nous avons besoin d'un moyen d'encoder le fichier source dans
format rot13. Le script ci-dessous, "mkrot13", fait exactement cela.

die "utilisation mkrot13 filename\n" sauf si @ARGV ;
mon $in = $ARGV[0] ;
mon $out = "$in.tmp" ;
open(IN, "<$in") ou die "Impossible d'ouvrir le fichier $in : $!\n" ;
open(OUT, ">$out") ou die "Impossible d'ouvrir le fichier $out : $!\n" ;

print OUT "utiliser Rot13;\n" ;
tandis que ( ) {
tr/a-zA-Z/n-za-mN-ZA-M/ ;
imprimer;
}

fermer dans;
liquider;
dissocier $in ;
renommer $out, $in ;

Si nous chiffrons cela avec "mkrot13":

print " bonjour fred \n" ;

le résultat sera celui-ci :

utilisez Rot13 ;
cevag "uryyb serq\a" ;

L'exécuter produit cette sortie :

bonjour fred

EN UTILISANT CONTEXTE: THE DEBUG FILTRE

L'exemple rot13 était un exemple trivial. Voici une autre démonstration qui montre quelques
plus de fonctionnalités.

Supposons que vous vouliez inclure beaucoup de code de débogage dans votre script Perl pendant le développement,
mais vous ne vouliez pas qu'il soit disponible dans le produit publié. Les filtres de source offrent une solution.
Afin de garder l'exemple simple, disons que vous vouliez que la sortie de débogage soit
contrôlé par une variable d'environnement, "DEBUG". Le code de débogage est activé si la variable
existe, sinon il est désactivé.

Deux lignes de repère spéciales encadreront le code de débogage, comme ceci :

## DEBUG_BEGIN
si ($année > 1999) {
avertir "Debug : bug du millénaire dans l'année $year\n" ;
}
## DEBUG_END

Le filtre garantit que Perl analyse le code entre le et "DEBUG_END"
marqueurs uniquement lorsque la variable d'environnement "DEBUG" existe. Cela signifie que lorsque "DEBUG"
existe, le code ci-dessus doit être passé à travers le filtre sans modification. Les lignes de repère
peuvent également être transmises telles quelles, car l'analyseur Perl les verra comme des lignes de commentaires.
Lorsque "DEBUG" n'est pas défini, nous avons besoin d'un moyen de désactiver le code de débogage. Un moyen simple d'atteindre
c'est à dire convertir les lignes entre les deux marqueurs en commentaires :

## DEBUG_BEGIN
#if ($année > 1999) {
# warn "Debug : bug du millénaire dans l'année $year\n" ;
#}
## DEBUG_END

Voici le filtre de débogage complet :

Débogage du paquet ;

utiliser strict;
utiliser des avertissements ;
utiliser Filter::Util::Call;

utiliser la constante VRAI => 1 ;
utiliser la constante FAUX => 0 ;

sous-importation {
mon ($type) = @_;
mon (%contexte) = (
Activé => défini $ENV{DEBUG},
InTraceBlock => FAUX,
Nom de fichier => (appelant)[1],
LineNo => 0,
LastBegin => 0,
);
filter_add(bénir \%context);
}

sous Die {
mon ($self) = décalage ;
mon ($message) = décalage;
mon ($line_no) = décalage || $self->{LastBegin} ;
die "$message at $self->{Filename} line $line_no.\n"
}

sous-filtre {
mon ($self) = @_;
mon (statut) ;
$statut = filtre_read();
++ $self->{LineNo} ;

# traiter d'abord l'EOF/l'erreur
si ($statut <= 0) {
$self->Die("DEBUG_BEGIN n'a pas de DEBUG_END")
if $self->{InTraceBlock} ;
renvoie $statut ;
}

if ($self->{InTraceBlock}) {
si (/^\s*##\s*DEBUG_BEGIN/ ) {
$self->Die("Imbriqué DEBUG_BEGIN", $self->{LineNo})
} elsif (/^\s*##\s*DEBUG_END/) {
$self->{InTraceBlock} = FALSE ;
}

# commente les lignes de débogage lorsque le filtre est désactivé
s/^/#/ si ! $self->{Activé} ;
} elsif ( /^\s*##\s*DEBUG_BEGIN/ ) {
$self->{InTraceBlock} = TRUE;
$self->{LastBegin} = $self->{LineNo} ;
} elsif ( /^\s*##\s*DEBUG_END/ ) {
$self->Die("DEBUG_END n'a pas de DEBUG_BEGIN", $self->{LineNo});
}
renvoie $statut ;
}

1;

La grande différence entre ce filtre et l'exemple précédent est l'utilisation de données contextuelles
dans l'objet filtre. L'objet filter est basé sur une référence de hachage et est utilisé pour conserver
diverses informations contextuelles entre les appels à la fonction de filtrage. Tous sauf deux
les champs de hachage sont utilisés pour le rapport d'erreurs. Le premier de ces deux, Enabled, est utilisé par
le filtre pour déterminer si le code de débogage doit être transmis à l'analyseur Perl. Les
deuxièmement, InTraceBlock, est vrai lorsque le filtre a rencontré une ligne "DEBUG_BEGIN", mais
n'a pas encore rencontré la ligne "DEBUG_END" suivante.

Si vous ignorez toutes les vérifications d'erreurs que la plupart du code fait, l'essence du filtre
est comme suit:

sous-filtre {
mon ($self) = @_;
mon (statut) ;
$statut = filtre_read();

# traiter d'abord l'EOF/l'erreur
renvoie $status si $status <= 0 ;
if ($self->{InTraceBlock}) {
si (/^\s*##\s*DEBUG_END/) {
$self->{InTraceBlock} = FAUX
}

# commente les lignes de débogage lorsque le filtre est désactivé
s/^/#/ si ! $self->{Activé} ;
} elsif ( /^\s*##\s*DEBUG_BEGIN/ ) {
$self->{InTraceBlock} = TRUE;
}
renvoie $statut ;
}

Attention : tout comme le préprocesseur C ne connaît pas le C, le filtre Debug ne connaît pas Perl.
Il peut être trompé assez facilement :

imprimer <
##DEBUG_BEGIN
MOE

De telles choses mises à part, vous pouvez voir que beaucoup de choses peuvent être réalisées avec une quantité modeste de code.

CONCLUSION

Vous avez maintenant une meilleure compréhension de ce qu'est un filtre source, et vous pourriez même avoir un
utilisation possible pour eux. Si vous avez envie de jouer avec les filtres source mais que vous avez besoin d'un peu de
inspiration, voici quelques fonctionnalités supplémentaires que vous pouvez ajouter au filtre Debug.

Tout d'abord, facile. Plutôt que d'avoir un code de débogage qui est tout ou rien, ce serait
beaucoup plus utile pour pouvoir contrôler quels blocs spécifiques de code de débogage obtiennent
inclus. Essayez d'étendre la syntaxe des blocs de débogage pour permettre à chacun d'être identifié. Les
le contenu de la variable d'environnement "DEBUG" peut ensuite être utilisé pour contrôler quels blocs sont
inclus.

Une fois que vous pouvez identifier les blocs individuels, essayez de les autoriser à être imbriqués. Ce n'est pas
difficile non plus.

Voici une idée intéressante qui n'implique pas le filtre Debug. Actuellement Perl
les sous-routines ont un support assez limité pour les listes de paramètres formels. Vous pouvez spécifier le
nombre de paramètres et leur type, mais encore faut-il les sortir manuellement du
@_ tableau vous-même. Écrivez un filtre source qui vous permet d'avoir une liste de paramètres nommés.
Un tel filtre transformerait ceci :

sub MySub ($ first, $second, @rest) { ... }

dans ceci:

sous MonSub($$@) {
mon ($premier) = décalage ;
mon ($second) = décalage ;
mon (@rest) = @_;
...
}

Enfin, si vous avez envie d'un vrai défi, essayez d'écrire une macro Perl complète
préprocesseur comme filtre source. Emprunter les fonctionnalités utiles du préprocesseur C et
tout autre macro processeur que vous connaissez. Le plus délicat sera de choisir le niveau de connaissance de
la syntaxe de Perl que vous voulez que votre filtre ait.

LIMITATIONS

Les filtres source ne fonctionnent qu'au niveau de la chaîne, sont donc très limités dans leur capacité à
changer le code source à la volée. Il ne peut pas détecter les commentaires, les chaînes entre guillemets, les heredocs, il est
pas de remplacement pour un vrai parseur. La seule utilisation stable des filtres source est
le cryptage, la compression ou le byteloader, pour traduire le code binaire en code source.

Voir par exemple les limitations dans Switch, qui utilise des filtres source, et n'est donc pas
fonctionnent à l'intérieur d'une chaîne eval, la présence de regex avec des nouvelles lignes intégrées qui sont
spécifiés avec des délimiteurs bruts "/.../" et n'ont pas de modificateur "//x" sont
impossible à distinguer des morceaux de code commençant par l'opérateur de division "/". Comme un
solution de contournement, vous devez utiliser "m/.../" ou "m?...?" pour de tels modèles. Aussi, la présence de
expressions régulières spécifiées avec brut "?...?" les délimiteurs peuvent provoquer des erreurs mystérieuses. La solution de contournement
est d'utiliser "m?...?" au lieu. Voirhttp://search.cpan.org/perldoc?Switch#LIMITATIONS>

Actuellement, le contenu du bloc "__DATA__" n'est pas filtré.

Actuellement, les longueurs de mémoire tampon internes sont limitées à 32 bits uniquement.

DES CHOSES À REGARDEZ ARCHIVER POUR LES CANADIENS

Certains filtres écrasent la poignée « DONNÉES »
Certains filtres source utilisent le descripteur "DATA" pour lire le programme appelant. Lors de l'utilisation
ces filtres source, vous ne pouvez pas vous fier à ce handle, ni vous attendre à un type particulier
de comportement lors de l'opération sur elle. Filtres basés sur Filter::Util::Call (et donc
Filter::Simple) n'altère pas le handle de fichier "DATA", mais en revanche totalement
ignorez le texte après "__DATA__".

EXIGENCES

La distribution Source Filters est disponible sur CPAN, en

CPAN/modules/par module/Filtre

À partir de Perl 5.8 Filter::Util::Call (la partie centrale des filtres source
distribution) fait partie de la distribution Perl standard. Un plus convivial est également inclus
interface appelée Filter::Simple, par Damian Conway.

Utilisez perlfilterp en ligne en utilisant les services onworks.net