Discussion :

[nicnictout]

Bonjour,

j'essaie de me mettre à Perl, mais plus ça va, plus ce langage me rend dingue... Bon faut dire que la prog n'est pas mon truc préférée non plus

Bref, j'essaie de faire un petit programme tout con, qui fait une requête vers une base de donnée, récupère des ID et les passe en argument d'un executable d'un autre logiciel.

Voila mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
#!/usr/bin/perl
 
 
#use strict;
use warnings;
use lib '/exploit/OV/share/bin';
use AF_OV;
 
my $request=<<END;
SELECT DISTINCT OPC_ACT_MESSAGES.MESSAGE_NUMBER FROM OPC_ACT_MESSAGES,OPC_ESCAL_ASSIGN_M WHERE (OPC_ACT_MESSAGES.receiving_time Between $DELTA_TIME AND $ACTUAL_TIME) AND (OPC_ACT_MESSAGES.SEVERITY<>2) AND (OPC_ESCAL_ASSIGN_M.MESSAGE_NUMBER=OPC_ACT_MESSAGES.MESSAGE_NUMBER AND (OPC_ESCAL_ASSIGN_M.OP_NAME<>'OpC' OR OPC_ESCAL_ASSIGN_M.OP_NAME is NOT null));
END
my @result = AF_OV::exec_sql($request);
#print "$request";
 
my $id;
my $tmpfile='/tmp/idlist';
 
#nettoyage fichier tmp
unlink $tmpfile;
open (FICHIER, ">>$tmpfile") || die ("Vous ne pouvez pas créer le fichier \"idlist\"");
 
# recuperation des IDs et ecriture dans un fichier tmp
foreach $id (@result) {
        chomp $id;
        my $CMD = ("/opt/OV/bin/OpC/opccmachg -user AF -id $id -async COMMENTAIRE=Ticket_pris_en_charge");
        print FICHIER "$CMD\n";
                }
close (FICHIER);
 
open (my $cmd,'<',$tmpfile) || die ("Vous ne pouvez pas ouvrir le fichier \"idlist\"");
while ($line = <$cmd>) {
system "$line";
}
close (FICHIER);

J'ai tout tenté:
1) Passer directement le $CMD à la commande system
2) Passer par un fichier temporaire et demander a juste executer les lignes, au cas où cela soit un problème de portée de variable
3) Appel d'un script bash extérieur qui lancerait les commandes opccmachg

Mais j'ai toujours et systématiquement le même message d'erreur:
Insecure dependency in system while running with -T switch at <mon script>

J'ai passé la journée entière hier a chercher sur le net (et je me sens étrangement seul sur Google avec ce message d'erreur), a tenter de comprendre ce qui n'allait pas, j'ai tenté plusieurs syntaxe/algo différents.... mais toujours le même mur à la fin.
Franchement je suis a 2 doigts de me dire que je vais repasser au Bash pour faire le job, mais d'un autre coté cela me rend fou de pas comprendre maintenant !

Voilà, j'espère que l'on pourra m'aider, ce n'est plus tant que je sois dans la mouise si je n'y arrive pas, que de refuser que la machine soit plus forte que moi
D'avance merci

[dmganges]

Bonjour,
Juste pour faire démarrer le schmilblick, mais sans grande conviction

1) Peux-tu essayer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
foreach $id (@result) {
        chomp $id;
        my @CMD = "/opt/OV/bin/OpC/opccmachg -user AF -id $id -async COMMENTAIRE=Ticket_pris_en_charge";
  print "==@CMD==\n";
        system @CMD;
}

NB : CMD est un tableau, et sans les parenthèses...

2) Peux-tu copier ici le contenu d'un print "==@CMD==\n";
histoire de voir comment il est formaté... ça pourrait nous donner des idées...

[EDIT 06:30] ajout

3) Peux-tu tester une commande basic, pour s'assurer que ce n'est pas un pb de droit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#!/usr/bin/perl
use strict;
use warnings;
my @CMD = "ps -ef";
system @CMD;

[EDIT 06:50] Ajout
Désolé ça me vient au compte gouttes
Tester également :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
foreach $id (@result) {
        chomp $id;
        my @CMD = "/opt/OV/bin/OpC/opccmachg -user AF -id " $id " -async COMMENTAIRE=Ticket_pris_en_charge";
  print "==$id==@CMD==\n";
        system @CMD;
}

[EDIT 08:23] Dernière goutte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
foreach $id (@result) {
        chomp $id;
        my @CMD = ('/opt/OV/bin/OpC/opccmachg -user AF -id ', $id, ' -async COMMENTAIRE=Ticket_pris_en_charge');
  print "==$id==@CMD==\n";
        system @CMD;
}

[Lolo78]

Bonjour,

d'abord quelques questions:

• Peux-tu donner le message d'erreur en entier (je suppose qu'il doit y avoir un numéro de ligne où l'erreur a lieu)?
• C'est quoi comme base de données?
• C'est quoi, le module AF_OV?
• Est-ce un module fait maison ou un module fourni par un tiers?

C'est très probablement le module AF_OV qui est responsable du problème en activant le mode taint (en utilisant l'option -T au début). Peux-tu vérifier si le début de ce module contient -T ?

Ce mode t'interdit d'utiliser certaines commandes système jugées dangereuses du point de vue de la sécurité. Ou, plus précisément, il t'interdit d'utiliser des données provenant de l'extérieur de ton programme pour affecter quelque chose d'autre également extérieur à ton programme, car ces données sont susceptibles d'être dangereuses ou de faire quelque chose de dangereux.

Dans ton cas, les lignes récupérées dans la base de données sont sans doute "contaminées" (tainted). Ici, tu fais plusieurs choses susceptibles d'être dangereuses avec ces données contaminées, en particulier l'appel système utilisant les données récupérées de la base, mais peut-être aussi d'autres. C'est la raison pour laquelle je te demande le numéro de ligne de l'erreur (ou, si ton code n'est pas exactement le même que celui présenté ci-dessus, le code se trouvant dans la ligne en question).

On peut vérifier si les données sont contaminées en utilisant le module standard Scalar::Util. Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
use Scalar::Util qw/tainted/;
# ...
print "Contaminé!\n" if tainted($result[0];

On peut "décontaminer" (untaint) ces données notamment à l'aide d'expressions régulières, mais j'aurais besoin de connaître le contenu de ce qui a été récupéré dans la base (le tableau @result) pour suggérer une manière précise (et si possible sûre) de le faire.

Peux-tu donc:

• Vérifier si les lignes du tableau @result sont bien contaminées comme je le crois (en utilisant par exemple le bout de code ci-dessus);
• Afficher ces lignes et les poster pour que l'on puisse réfléchir à comment les décontaminer.

[nicnictout]

Bonjour,

dors et déjà merci de votre aide sur le sujet, et désolé de ne pas avoir répondu hier, on m'a bloqué en urgence sur le "Run".
Alors je vais essayé de répondre à toutes vos questions:

Question Dmganges (je fournis les output de chaque bout de code fourni):
1-2)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

==/opt/OV/bin/OpC/opccmachg -user AF -id 072a948c-a295-71e7-06cb-0a465e190000 -async COMMENTAIRE=Ticket_pris_en_charge==

Insecure dependency in system while running with -T switch at /tech/OV/mgmt/bin/OML_CMA_OPERATOR.pl line 46.

3)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @CMD = "ps -ef";

OK ça marche (suis root de la machine)

4)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @CMD = "/opt/OV/bin/OpC/opccmachg -user AF -id " $id " -async COMMENTAIRE=Ticket_pris_en_charge";

Erreur de compilation:
Scalar found where operator expected at /tech/OV/mgmt/bin/OML_CMA_OPERATOR.pl line 45, near ""/opt/OV/bin/OpC/opccmachg -user AF -id " $id"
(Missing operator before $id?)
String found where operator expected at /tech/OV/mgmt/bin/OML_CMA_OPERATOR.pl line 45, near "$id " -async COMMENTAIRE=Ticket_pris_en_charge""
(Missing operator before " -async COMMENTAIRE=Ticket_pris_en_charge"?)
syntax error at /tech/OV/mgmt/bin/OML_CMA_OPERATOR.pl line 45, near ""/opt/OV/bin/OpC/opccmachg -user AF -id " $id "


5)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @CMD = ('/opt/OV/bin/OpC/opccmachg -user AF -id ', $id, ' -async COMMENTAIRE=Ticket_pris_en_charge');

==072a948c-a295-71e7-06cb-0a465e190000==/opt/OV/bin/OpC/opccmachg -user AF -id 072a948c-a295-71e7-06cb-0a465e190000 -async COMMENTAIRE=Ticket_pris_en_charge==
Insecure dependency in system while running with -T switch at /tech/OV/mgmt/bin/OML_CMA_OPERATOR.pl line 47.




Question Lolo:
1) Peux-tu donner le message d'erreur en entier (je suppose qu'il doit y avoir un numéro de ligne où l'erreur a lieu)?
Voici le bout de code de mon prog:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 37 # recuperation des IDs et ecriture dans un fichier tmp
     38 foreach $id (@result) {
     39         chomp $id;
     40         my @CMD = "/opt/OV/bin/OpC/opccmachg -user AF -id $id -async COMMENTAIRE=Ticket_pris_en_charge";
     41         system @CMD;
     42 }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Insecure dependency in system while running with -T switch at /tech/OV/mgmt/bin/OML_CMA_OPERATOR.pl line 41.

2) C'est quoi comme base de données?
Oracle

3) C'est quoi, le module AF_OV?
C'est un module maison pour traiter les données du logiciel HPOM (supervision)

4) Est-ce un module fait maison ou un module fourni par un tiers?
C'est un module dev par un autre collègue

5) AF_OV Tainted ?
Non il ne l'est pas, voici les déclarations en début de module:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
use 5.8.8;
use warnings;
use strict;
use IPC::Open3;
use File::Basename;
 
# XXX only for tests
use Data::Dumper;
 
require Exporter;
our $VERSION = 0.1;
our @ISA = qw(Exporter);
our @EXPORT = qw(abort moan pv is_a);

6) test contamination + contenu tableau result (en gros l'id d'un message, toutes les IDs ont un pattern identique)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Contaminé!
072a948c-a295-71e7-06cb-0a465e190000

Je vais continuer de faire des recherches mais merci de votre aide en tout cas

[dmganges]

Bonjour,

1)
En fait la dernière goutte est à ne pas perdre de vue pour les commandes system complexes envoyées depuis Perl.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @CMD = ('/opt/OV/bin/OpC/opccmachg -user AF -id ', $id, ' -async COMMENTAIRE=Ticket_pris_en_charge');

Je n'ai pas d'idée supplémentaire, justes quelques remarques avant la sieste :
2)
Lorsque tu es root ça ne veut pas dire que tu as tous les droits sur Oracle, loin de là !
Même l'administrateur de la base ne peut pas intervenir sur les données des utilisateurs, s'il n'a pas les grant nécessaires...

3)
Insecure dependency in system while running with
Cette erreur on la trouve de façon récurrente sur internet, il est peu probable (mais pas impossible) qu'un module "maison" la contienne in extenso

4)
La détection de données corrompues dans une base sur un SELECT me semble improbable, à l'INSERT passe encore...
Je n'ai pas touché à Oracle depuis la 9i
Ils n'y auraient pas ajouté un process supplémentaire, par hasard qui ferait des contrôles supplémentaires...

5)
Pourrais-tu simplifier ton select au maximum, essayer qqc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT date from dual;

Mon idée :
J'ai eu pas mal de soucis avec le traitement des ' et " imbriqués dans des requêtes Oracle générées avec Pro*C et dernièrement pour un essai ici avec Perl.
La partie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

AND (OPC_ESCAL_ASSIGN_M.OP_NAME<>'OpC' OR OPC_ESCAL_ASSIGN_M.OP_NAME is NOT null)

Me chagrine justement à cause des ', ainsi que l’absence d'espaces :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

AND (OPC_ESCAL_ASSIGN_M.OP_NAME <> 'OpC' OR OPC_ESCAL_ASSIGN_M.OP_NAME is NOT null)

Les interpréteurs de requêtes SQL en font un peu à leur tête.

Si le SELECT from dual fonctionne, tente :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT DISTINCT OPC_ACT_MESSAGES.MESSAGE_NUMBER FROM OPC_ACT_MESSAGES,OPC_ESCAL_ASSIGN_M WHERE (OPC_ACT_MESSAGES.receiving_time Between $DELTA_TIME AND $ACTUAL_TIME) AND (OPC_ACT_MESSAGES.SEVERITY <> 2) AND (OPC_ESCAL_ASSIGN_M.MESSAGE_NUMBER=OPC_ACT_MESSAGES.MESSAGE_NUMBER);

[nicnictout]

Alors j'ai tenté:

1) réduire a la portion congrue mon select "SELECT DISTINCT OPC_ACT_MESSAGES.MESSAGE_NUMBER FROM OPC_ACT_MESSAGES,OPC_ESCAL_ASSIGN_M WHERE (OPC_ACT_MESSAGES.receiving_time Between $DELTA_TIME AND $ACTUAL_TIME)" => Insecure dependency in system while running with
Du coup ce n'est pas un problème de query

2) changer le type de données renvoyée par la query pour être sur une string sans caractères spéciaux => Insecure dependency in system while running with

3) si je remplace le $id dans ma variable $CMD pas sa vraie valeur en dure => tout marche nickel
my @CMD2 = "/opt/OV/bin/OpC/opccmachg -user AF -id d875c34a-a2b3-71e7-06df-0a465e190000 -async COMMENTAIRE=Ticket_pris_en_charge";
system @CMD2;


Des lectures que j'ai pu faire, et des pistes levées, j'essaie de voir pour untaint ma variable en passant par les regex, du coup j'ai la regex, mais étant encore newbee en perl je suis toujours en train de chercher la manière de coder cette fonction à mon cas. Je vous tiens au jus dès que j'ai réussi, ou pas...

Merci et bonne journée a vous

[dmganges]

mais étant encore newbee en perl

Moi aussi

Sur ce coup Lolo78 te sera de meilleur conseil que moi, en attendant qu'il arrive, tente :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @CMD2 = "/opt/OV/bin/OpC/opccmachg -user AF -id ${id} -async COMMENTAIRE=Ticket_pris_en_charge";

[EDIT 15:25] mieux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @CMD2 = '/opt/OV/bin/OpC/opccmachg -user AF -id ' ${id} ' -async COMMENTAIRE=Ticket_pris_en_charge';

[nicnictout]

oui et je suis newBY en anglais je me rends compte aussi

bon j'ai testé ta syntaxe (ou plutôt retenté) et toujours le même problème.
Du coup je vais attendre le retour du sauveur Perlistique Lolo

Merci en tout cas

[dmganges]

OK bon courage !

[Lolo78]

OK, donc confirmation que le tableau @result est contaminé (tainted). Il faut donc le décontaminer. Puisque le tableau semble contenir des adresses hexadécimales et des tirets, on va essayer de nettoyer comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
my @clean_result = map { /([\w-]+)/; $1 } @result;

Ensuite tester que les lignes de @clean_result ne sont pas contaminées et qu'elles ont le même contenu que @result (ce devrait être le cas si je n'ai pas foiré un truc). Si c'est ben le cas, utiliser le contenu @clean_result pour alimenter la commande system. Et là tu ne devrais plus avoir ce message d'erreur.

[Lolo78]

Un exemple de décontamination, vite fait à la ligne de commande.

Le paramètre ("toto") passé au programme est contaminé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
$ perl -T -e  'use Scalar::Util qw/tainted/; my $c = shift; print "Contaminé\n"  if tainted $c;' toto 
Contaminé

La capture effectuée dans l'expression régulière décontamine la variable $1 extraite:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
$ perl -T -e  'use Scalar::Util qw/tainted/; my $c = shift; $c =~ /(\w+)/; print "$1\n";  print "Contaminé\n"  if tainted $1;' toto
toto

On voit que le second script uniligne n'affiche plus "Contaminé". La valeur extraite ($1) n'est pas contaminée, bien qu'elle ait le même contenu que $c (avec toutefois, dans le cas de cet exemple, un retour à la ligne en moins, mais ça ne change rien et on pourrait le garder si on voulait). L'important est qu'on ait réussi à décontaminer le contenu.

[nicnictout]

@Lolo super ca marche nickel ton truc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @clean_result = map { /([\w-]+)/; $1 } @result;

tu m'enlèves une belle épine du pied, et je sens que je vais me la scarifier sur le bras pour être sur de pas le perdre

Mil merci a vous 2 en tout cas, vous avez été super

[dmganges]

Perso je n'ai pas tout compris, mais j'ai appris
Lolo78

[Lolo78]

Bonsoir,

Perso je n'ai pas tout compris, mais j'ai appris

Donc, quelques explications complémentaires.

Il existe en Perl un mode taint (tache, contamination, pollution) qui permet d'assurer une certaine sécurité (ou plutôt d'aider le développeur à prendre les conditions nécessaires), en interdisant certaines opérations sur les données considérées comme tainted ou contaminées (ou souillées, polluées, etc.).

Si ce mode est activé, sont considérées comme souillées les données provenant de l'extérieur d'un programme: argument de la ligne de commande (voir mon exemple ci-dessus où la chaîne toto était contaminée), les fichiers lus, les variables d'environnement, les données récupérées par l'entrée standard (par un pipe d'un autre programme ou saisies par un utilisateur), les données reçues par le réseau ou provenant d'une bases de données, etc. Si le mode est activé, toutes ces données potentiellement contaminées ne peuvent pas être utilisées pour des opérations agissant sur l'extérieur du programme (à l'exception de quelques fonctions comme print ou syswrite), en particulier dans une commande de type system ....

Il existe deux options pour activer le mode taint: -t et -T. Avec -t, Perl émettra un warning si on essaie d'effectuer une de ces opérations dangereuses, alors qu'avec -T ce sera une erreur fatale (le programme avortera), avec le message d'erreur signalé (Insecure dependency in system while running with -T switch). C'est ce qui arrivait à notre ami nicnictout.

Pourquoi est-ce utile? Supposons que l'on lise un fichier de commandes shell et qu'on les exécute avec une commande system, qx/.../ ou des backticks ` `. Si un petit malin a mis dans ce fichier la chaîne de caractère suivante: ; rm -rf /*;, c'est tout un file system qui risque de disparaître si cette ligne est exécutée aveuglément par une commande system ou équivalente. De même, toute donnée saisie par un utilisateur, au prompt d'un programme ou sur une page Web, est potentiellement dangereuse.

Donc, le mode taint permet d'éviter ce genre de problèmes, ou plutôt d'aider le développeur à les éviter.

Dans notre exemple, nicnictout utilisait des fragments de données provenant d'une base de données, ces données étaient donc contaminées, et le programme sortait en erreur lors de l'utilisation de ces données contaminées dans une commande system.

Pour vérifier si une donnée est contaminée, le plus simple est d'utiliser la fonction is_tainted du module Scalar::Util, comme je l'ai expliqué dans un post précédent:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
use Scalar::Util qw/tainted/;
# ...
print "Contaminé!\n" if tainted($result[0];

Pour utiliser des données contaminées, il faut les "décontaminer" ou les "lessiver". Pour ce faire, il faut capturer le contenu à l'aide d'une expression régulière. Là, le développeur doit être prudent, car Perl lui fait confiance et suppose que le développeur sait ce qu'il fait. Si j'ai une chaîne de caractère $string contaminée et que je la décontamine avec ce code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
my $clean_string = $1 if $string =~ /(.*)/;  # A ne pas faire !!!!

la donnée sera décontaminée et pourra être utilisée comme bon me semble, mais elle sera toujours aussi dangereuse: l'instruction ; rm -rf /*; sera extraite sans problème et $clean_string anéantira mon système de fichiers si je l'insère dans une commande system.

Si j'utilise ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
my $clean_string = $1 if $string =~ /(\w*)/;

ce sera peut-être trop restrictif et je ne parviendrai peut-être pas à extraire ce qui m'intéresse.

Il faut donc bien réfléchir à ce que l'on fait, de façon à être suffisamment restrictif pour éliminer les choses dangereuses, mais pas trop non plus pour réussir à extraire la donnée dont j'ai besoin.

Dans le cas qui nous intéresse, j'ai utilisé /([\w-]+)/, qui permet de ne capturer que des lettres, des chiffres, des caractère de soulignement _ et des tirets -. Cela élimine en particulier les espaces, les barres obliques, les étoiles et les points-virgule, du coup il est à peu près impossible d'extraire une commande dangereuse du shell.

On aurait pu utiliser une regex un peu plus restrictive, comme /(a-f0-9-)/, mais n'ayant vu qu'une seule ligne de @result, je n'avais pas de garantie que le résultat ne pouvait contenir que des caractères hexadécimaux minuscules et des tirets. J'ai donc visé un peu plus large, tout en minimisant au maximum les risques.

Voilà, j'espère que ça clarifie tout ceci.

Un lien avec des informations plus détaillées: http://perl.mines-albi.fr/DocFr/perlsec.html.

[dmganges]

Bonjour Lolo78,
et MERCI pour ces explications qui sont très claires.

- Je ne connaissais pas Scalar::Util mais en lisant le peu de doc Cpan j'avais compris l'utilité et compris le comportement de Perl.
- J'étais déjà sensibilisé aux risques de l'utilisation des commandes comme system et surtout eval.

Ce qui m'a dérouté et me déroute encore c'est ceci :

Ici :

my @result = AF_OV::exec_sql($request);

Perl va s’efforcer de construire un tableau de scalaires, peu importe ce que retourne le select.

6) test contamination + contenu tableau result (en gros l'id d'un message, toutes les IDs ont un pattern identique)

3) si je remplace le $id dans ma variable $CMD pas sa vraie valeur en dure => tout marche nickel
my @CMD2 = "/opt/OV/bin/OpC/opccmachg -user AF -id d875c34a-a2b3-71e7-06df-0a465e190000 -async COMMENTAIRE=Ticket_pris_en_charge";
system @CMD2;

Alors que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @CMD2 = "/opt/OV/bin/OpC/opccmachg -user AF -id ${id} -async COMMENTAIRE=Ticket_pris_en_charge";

Le seul fait de passer le pattern dans une variable plante, et ne plante pas lorsqu'il est passé en dur.

C'est la même information, la même suite de caractère... et Perl se comporte de manières différentes !

Le pattern n'est constitué que de chiffres et de tirets, j'ai du mal à imaginer qu'il y ait autre chose dans la BBD, mais ça seul nicnictout peut le confirmer.
Et en quoi un &, @, § ... pourrait en faire une donnée dangereuse ?

Ne perd pas trop de temps à me répondre, sauf si tu penses que ça peut être utile à d'autres.
Pour moi c'est fini, je ne devrais pas rencontré le pb, et dans le cas contraire j'ai appris à le résoudre

Encore MERCI !

[Lolo78]

Bonjour,

Perl ne peut pas deviner quelles valeurs de variables sont dangereuses. Il peut juste déterminer d'où proviennent les contenus des variables, et il marque comme contaminées les variables dont le contenu provient de l'extérieur du programme (argument passé au programme, fichier extérieur, BDD, saisie de l'utilisateur, variable d'environnement, etc.). Si le contenu d'une variable contaminée est affecté (en partie ou en totalité) à une autre variable, celle-ci est à son tour marquée comme contaminée.

Dans le cas de mon exemple de l'argument "toto" passé en argument à un script uniligne (post # 11), il est évident que la chaîne "toto" n'est pas dangereuse. Mais tout ce que Perl peut déterminer, c'est la variable $c contenant l'argument passé au programme est potentiellement dangereuse, cette variable est donc marquée comme contaminée.

Il en va de même quand nicnictout utilise les données provenant de la base de données, donc de l'extérieur. Les lignes de son tableau @result sont donc contaminées. S'il code en dur la même chaîne de caractère au sein de ce programme, alors la chaîne qui ne provient plus de l'extérieur du programme n'est pas contaminée.

Mais si on en restait là, on ne pourrait pas faire grand chose avec les données du monde extérieur. D'où le principe de décontamination, qui consiste à disséquer en détail les données du monde extérieur à l'aide d'une expression régulière pour renvoyer des données que Perl ne considérera plus comme contaminées. Perl fait alors confiance au développeur et no contamine pas les captures renvoyées par l'expression régulière; à charge au développeur d'utiliser cette possibilité avec toute la prudence requise.

[dmganges]

Encore MERCI Lolo78 pour ce complément d'information.

En fait je m'attendais à cette réponse.

Mais comme perso je lance des commandes system qui contiennent des exécutables et que Perl ne rechigne pas, j'avais des doutes...

Exemple de ce que je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
my $Executable	 = 'C:/Program Files (x86)/Balabolka/balabolka.exe';
my $ParamLigne	 = '-rmnq';
my $ParamFichier = '-rmq';
...
 
$Msg = "\nIl y a : " .$NbTotMsg. " Courrier(s) au total dans ". $Dossier ." sur ". $Mail_Ini{$Bal}{Adresse}."\n";
$Balabolka    = '"'. $Msg .'"';
@Cde = ( $Executable , $ParamLigne , $Balabolka );
system @Cde;
...
 
@Cde = ( $Executable , $ParamFichier , $fichier_Bal );
system @Cde;
...

Balabolka.exe est un exécutable qui transforme une suite de caractères en un texte prononcé par une voix de synthèse (Ici Virginie).

Ta réponse me satisfait, ne perd pas d'avantage de temps, la question de nicnictout est résolue, c'est l'essentiel !

Encore MERCI !

[Lolo78]

Mais comme perso je lance des commandes system qui contiennent des exécutables et que Perl ne rechigne pas, j'avais des doutes...

Exemple de ce que je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
my $Executable	 = 'C:/Program Files (x86)/Balabolka/balabolka.exe';
my $ParamLigne	 = '-rmnq';
my $ParamFichier = '-rmq';
...
 
$Msg = "\nIl y a : " .$NbTotMsg. " Courrier(s) au total dans ". $Dossier ." sur ". $Mail_Ini{$Bal}{Adresse}."\n";
$Balabolka    = '"'. $Msg .'"';
@Cde = ( $Executable , $ParamLigne , $Balabolka );
system @Cde;
...
 
@Cde = ( $Executable , $ParamFichier , $fichier_Bal );
system @Cde;
...

Perl ne fait les vérifications de sécurité évoquées dans tout ce fil que si le mode taint est activé (avec l'option -t ou -T). Si ce mode n'est pas activé, Perl te laisse faire ce que tu veux.

Mais même avec le mode taint activé, tu peux lancer des programmes externes si le nom du programme est codé en dur dans ton programme. C'est seulement si le nom ou le chemin vient d'une source extérieure que le mode taint détectera une faille de sécurité possible et le marquera comme contaminé.

[dmganges]

C'est seulement si le nom ou le chemin vient d'une source extérieure que le mode taint détectera une faille de sécurité possible et le marquera comme contaminé.

Oui j'ai bien compris Lolo78.
En fait je prends conscience que mon entêtement est essentiellement dû à mon anglais déplorable et peut-être à mon esprit méditerranéen.
Ayant traduit blessed en corrompu ou contaminé, j'ai essayé d'imaginer comment Perl pouvait faire ce genre de détection, à partir de quels critères et avec quels algorithmes...

Si je reformule en :
Perl décrète toutes données extérieures comme suspecte ça va mieux

Ceci dit, c'est très fort, Perl ne se contente pas de compiler/interpréter...
Je suis bluffé.

Encore MERCI !

[nicnictout]

Oui mille mercis Lolo, j'avoue que j'avais compris le principe dans ses grandes largeurs, mais la c'est absolument limpide, et du coup je ne l'oublierais plus

Merci beaucoup tu temps consacré a éclairer nos lanternes, t'es un chef.

Bonne journée a toute la communauté