Problème avec la vérification de mot de passe d'un profil

**0nn2belle** · 27/06/2011, 11h32

Bonjour à tous.
J'ai crée une fonction qui va vérifier le contenu d'un mot de passe (fonction proche de celle prédéfinie par Oracle), cette dernière compile bien avec l'utilisateur SYS. J'ai fait les test en la mettant en mode procédure, elle fonctionne bien.
Je crée un profil avec l'option "password_verify_function" et je lui passe le nom de ma fonction ce qui me donne :

Code :

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

1
2
3
4
 
CREATE PROFILE ProfilUserStd
...
password_verify_fonction verify_password;

Où verify_password est le nom de ma fonction.Je crée mon profil, tout se passe bien.

Mon souci arrive quand j'assigne ce profil à un utilisateur quelconque, en effet quoique je fasse j'obtiens :

Code :

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

1
2
3
4
5
6
7
8
9
 
Rapport d'erreur :
Erreur SQL : ORA-28003: échec de la vérification du mot de passe indiqué
ORA-06503: PL/SQL : La fonction ne ramène aucune valeur
28003. 00000 -  "password verification for the specified password failed"
*Cause:    The new password did not meet the necessary complexity
           specifications and the password_verify_function failed
*Action:   Enter a different password. Contact the DBA to know the rules for
           choosing the new password

Et ce quelque soit le mot de passe, qu'il respecte ou non les conditions de ma fonction.

Au cas où voici le code de ma fonction (à noter que j'ai besoin d'une table DICTIONNAIRE qui contient les mots interdits du mot de passe) :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
CREATE OR REPLACE FUNCTION verify_password
  (
    password varchar2,
    username varchar2,
    old_password varchar2
  )
RETURN boolean
IS
n boolean;
longueur_insuffisante exception;
chiffre_manquant exception;
password_identique_username exception;
mot_interdit exception;
presenceChiffre boolean;
longueurPassword integer;
listeChiffre varchar2(10);
cursor c1 is select mot from dictionnaire;
 
BEGIN
  longueurPassword:=length(password); /*Variable qui sera utilisé tout au long des traitements*/
 
 
  /*----------------Traitement de la longueur d'un mot de passe--------------------------------------------------*/
  IF longueurPassword < 4 THEN /*La fonction length permet de récupérer la longueur du mot de passe*/
    RAISE longueur_insuffisante;
  END IF;
 
  /*----------------Traitement du nombre minimum de chiffre------------------------------------------------------*/
  /*Déclaration et initialisation des variables*/
  listeChiffre :='0123456789';
  presenceChiffre:=false;
 
  FOR i in 1..10 LOOP /*boucle qui va parcourir la liste des chiffres*/
    FOR j in 1..longueurPassword LOOP /*Boucle qui va parcourir le mot de passe*/
      IF substr(password,j,1)=substr(listeChiffre,i,1) THEN /*Cherche une correspondance entre le mot de passe et la liste de chiffre*/
        presenceChiffre:=true;
      END IF;
    END LOOP;
  END LOOP;
  IF presenceChiffre=false THEN
        RAISE chiffre_manquant;
  END IF;
 
  /*----------------Fonction qui détermine si le mot de passe est identique au nom d'utilisateur ----------------*/
  FOR i in 1..longueurPassword LOOP
    IF username = substr(password, i, length(username)) THEN
      RAISE password_identique_username;
    END IF;
  END LOOP;
 
  /*----------------Traitement des mots interdits dans le mot de passe ------------------------------------------*/
  FOR enreg in c1 LOOP
    FOR i in 1..longueurPassword LOOP
      IF enreg.mot=substr(NLS_LOWER(password), i, length(enreg.mot)) THEN
        RAISE mot_interdit;
      END IF;
    END LOOP;
  END LOOP;
 
RETURN(TRUE);
 
EXCEPTION
  WHEN longueur_insuffisante THEN
    DBMS_OUTPUT.PUT_LINE('Le mot de passe est trop court, il doit contenir au moins 4 caractères');
 
  WHEN chiffre_manquant THEN
    DBMS_OUTPUT.PUT_LINE('Le mot de passe doit contenir au moins 1 chiffre');
 
  WHEN password_identique_username THEN
    DBMS_OUTPUT.PUT_LINE('Mot de passe est identique au nom d''utilisateur');
 
  WHEN mot_interdit THEN
    DBMS_OUTPUT.PUT_LINE('Votre mot de passe contient un mot interdit');
 
END verify_password;

Voici ensuite le code de mon profil :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
create profile ProfilUserStd limit
/* 1session par utilisateur */
sessions_per_user 1
/* temps de connexion maximum = 4h */
connect_time 240
/* si 15min d'inactivité = déconnexion automatique*/
idle_time 15
/* nombre maximales de tentative de connexion =4 */
failed_login_attempts 4
/*expiration mot de passe = 45jours */ 
password_life_time 45
/* appel de la fonction personnalisée pour traiter le mot de passe */ 
password_verify_function verify_password;

Bien entendu, je suppose que le problème vient de ma fonction, mais je ne sais pas d'où, surtout que je l'ai testé en tant que Procédure et ça a fonctionné ! Auriez-vous une idée ? Merci d'avance,
Annabelle

**AbouZaid** · 27/06/2011, 13h46

Bonjour,

D'abord commence par mettre en commentaire tout le code de ta fonction et retourne

Code :

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

True

directement pour voir si ta fonction fonctionne bien.

**0nn2belle** · 27/06/2011, 13h51

Alors dans ma fonction j'ai remplacé tout le code dans le BEGIN par "Return TRUE", la fonction se compile bien et je peux bien l'utiliser dans mon ALTER USER. Mais à quoi cela m'avance ??

**AbouZaid** · 27/06/2011, 13h59

et bien cela nous indique que le problème vient surement de la fonction.

Il suffit alors de faire une petite trace, ou bien d'enlever les commentaires petit à petit, et tu trouveras la requête qui pose problème...

**0nn2belle** · 27/06/2011, 14h01

Ok mais ce que je ne comprends pas c'est que quand j'ai testé la fonction en mode procédure (sans valeur de retour et avec les paramètres en dur) ça a fonctionné !

**AbouZaid** · 27/06/2011, 14h07

Et bien c'est normal.

On vient de faire le test avec une valeur en dur ( True ) et ça a marché avec la fonction.

Moi je dirais que ça vient de l'une des exceptions que tu as. car dans ces dernières il n'y a pas de

Code :

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

Return

.

Tu devrais ajouter un

Code :

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

Return false

dans les exceptions et re-tester.

**mnitu** · 27/06/2011, 14h09

Envoyé par 0nn2belle

Ok mais ce que je ne comprends pas c'est que quand j'ai testé la fonction en mode procédure (sans valeur de retour et avec les paramètres en dur) ça a fonctionné !

Peut être parce que vous ne respectez pas ce qu'on vous demande:

7.4.4.1 Password Verification Routine Formatting Guidelines
You can enhance the existing password verification complexity routine or create other password verification routines using PL/SQL or third-party tools.

The PL/SQL call must adhere to the following format:
routine_name
(
userid_parameter IN VARCHAR(30),
password_parameter IN VARCHAR (30),
old_password_parameter IN VARCHAR (30)
)
RETURN BOOLEAN

**0nn2belle** · 27/06/2011, 14h24

Envoyé par mnitu

Peut être parce que vous ne respectez pas ce qu'on vous demande:

On ne peut pas mettre "IN VARCHAR(30)" dans les paramètres d'entrée d'une fonction. Voici le code prédéfini d'Oracle pour une fonction de vérification également :

Code :

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

1
2
3
4
5
CREATE OR REPLACE FUNCTION verify_function 
(username varchar2, 
   password varchar2, 
   old_password varchar2) 
   RETURN boolean IS

J'ai testé avec les

Code :

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

RETURN FALSE;

dans le WHEN de chaque exception et ça ne fonctionne toujours pas, j'ai l'erreur :

Code :

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

Echec de la vérification du mot de passe indiqué

**0nn2belle** · 27/06/2011, 14h28

Bon, voici mon code avec les modifications faites :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 CREATE OR REPLACE FUNCTION verify_password
  (
    password varchar2,
    username varchar2,
    old_password varchar2
  )
RETURN BOOLEAN
IS
n BOOLEAN;
longueur_insuffisante exception;
chiffre_manquant exception;
password_identique_username exception;
mot_interdit exception;
presenceChiffre BOOLEAN;
longueurPassword integer;
listeChiffre varchar2(10);
cursor c1 IS SELECT mot FROM dictionnaire;
 
BEGIN
  longueurPassword:=length(password); /*Variable qui sera utilisé tout au long des traitements*/
 
 
  /*----------------Traitement de la longueur d'un mot de passe--------------------------------------------------*/
  IF longueurPassword < 4 THEN /*La fonction length permet de récupérer la longueur du mot de passe*/
    RAISE longueur_insuffisante;
  END IF;
 
  /*----------------Traitement du nombre minimum de chiffre------------------------------------------------------*/
  /*Déclaration et initialisation des variables*/
  listeChiffre :='0123456789';
  presenceChiffre:=false;
 
  FOR i IN 1..10 LOOP /*boucle qui va parcourir la liste des chiffres*/
    FOR j IN 1..longueurPassword LOOP /*Boucle qui va parcourir le mot de passe*/
      IF substr(password,j,1)=substr(listeChiffre,i,1) THEN /*Cherche une correspondance entre le mot de passe et la liste de chiffre*/
        presenceChiffre:=true;
      END IF;
    END LOOP;
  END LOOP;
  IF presenceChiffre=false THEN
        RAISE chiffre_manquant;
  END IF;
 
  /*----------------Fonction qui détermine si le mot de passe est identique au nom d'utilisateur ----------------*/
  FOR i IN 1..longueurPassword LOOP
    IF username = substr(password, i, length(username)) THEN
      RAISE password_identique_username;
    END IF;
  END LOOP;
 
  /*----------------Traitement des mots interdits dans le mot de passe ------------------------------------------*/
  FOR enreg IN c1 LOOP
    FOR i IN 1..longueurPassword LOOP
      IF enreg.mot=substr(NLS_LOWER(password), i, length(enreg.mot)) THEN
        RAISE mot_interdit;
      END IF;
    END LOOP;
  END LOOP;
 
RETURN(TRUE);
 
EXCEPTION
  WHEN longueur_insuffisante THEN
    DBMS_OUTPUT.PUT_LINE('Le mot de passe est trop court, il doit contenir au moins 4 caractères');
    RETURN(FALSE);
 
  WHEN chiffre_manquant THEN
    DBMS_OUTPUT.PUT_LINE('Le mot de passe doit contenir au moins 1 chiffre');
    RETURN(FALSE);
 
  WHEN password_identique_username THEN
    DBMS_OUTPUT.PUT_LINE('Mot de passe est identique au nom d''utilisateur');
    RETURN(FALSE);
 
  WHEN mot_interdit THEN
    DBMS_OUTPUT.PUT_LINE('Votre mot de passe contient un mot interdit');
    RETURN(FALSE);
 
END verify_password;

La fonction ne marche que lorsque le mot de passe contient ou est égal au nom d'utilisateur (visiblement le fait de marquer RETURN(FALSE) au lieu de RETURN FALSE fait une différence)

**ORA-007** · 27/06/2011, 14h30

Bonjour,

Ceci marche chez moi

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
CREATE OR REPLACE FUNCTION verify_password
  (
    password varchar2,
    username varchar2,
    old_password varchar2
  )
RETURN BOOLEAN
IS
 
n                BOOLEAN;
presenceChiffre   BOOLEAN;
longueurPassword   integer;
--listeChiffre     varchar2(10);
 
longueur_insuffisante     exception;
chiffre_manquant     exception;
password_identique_username   exception;
mot_interdit       exception;
 
cursor c1 
IS 
  SELECT 'interdit' as mot
  FROM dual
;
 
BEGIN
  longueurPassword:=length(password); /*Variable qui sera utilisé tout au long des traitements*/
 
 
  /*----------------Traitement de la longueur d'un mot de passe--------------------------------------------------*/
  IF longueurPassword < 4 THEN /*La fonction length permet de récupérer la longueur du mot de passe*/
    RAISE longueur_insuffisante;
  END IF;
 
  /*----------------Traitement du nombre minimum de chiffre------------------------------------------------------*/
  /*Déclaration et initialisation des variables*/
--  listeChiffre :='0123456789';
 
  presenceChiffre:=FALSE;
  /*Cherche une correspondance entre le mot de passe et la liste de chiffre*/
  FOR i IN 0..9 
  LOOP
    IF INSTR(password,i) > 0 THEN
       presenceChiffre:=TRUE;
    END IF;  
  END LOOP;
 
  IF NOT presenceChiffre THEN
     RAISE chiffre_manquant;
  END IF;
 
 
  /*----------------Fonction qui détermine si le mot de passe est identique au nom d'utilisateur ----------------*/
 
  IF INSTR(lower(password),lower(username) ) > 0 THEN
    RAISE password_identique_username;
  END IF;
 
  /*----------------Traitement des mots interdits dans le mot de passe ------------------------------------------*/
  FOR enreg IN c1 LOOP
      IF INSTR(lower(password),lower(enreg.mot)) > 0 THEN
        RAISE mot_interdit;
      END IF;
  END LOOP;
 
DBMS_OUTPUT.PUT_LINE('Success !!!');
 
RETURN(TRUE);
 
 
EXCEPTION
  WHEN longueur_insuffisante THEN
    DBMS_OUTPUT.PUT_LINE('Le mot de passe est trop court, il doit contenir au moins 4 caractères');
    RETURN(FALSE);
 
  WHEN chiffre_manquant THEN
    DBMS_OUTPUT.PUT_LINE('Le mot de passe doit contenir au moins 1 chiffre');
    RETURN(FALSE);
 
  WHEN password_identique_username THEN
    DBMS_OUTPUT.PUT_LINE('Mot de passe est identique au nom d''utilisateur');
    RETURN(FALSE);
 
  WHEN mot_interdit THEN
    DBMS_OUTPUT.PUT_LINE('Votre mot de passe contient un mot interdit');
    RETURN(FALSE);
 
END verify_password;
 
DECLARE
RETOUR BOOLEAN;
BEGIN
   RETOUR := verify_password('123','toto','toto02');
 
   RETOUR := verify_password('abcdef','toto','toto02');
 
   RETOUR := verify_password('toto01','toto','toto02');
 
   RETOUR := verify_password('interdit01','toto','toto02');
 
   RETOUR := verify_password('sldfhqs;dfbh01','toto','toto02');
 
END;
/
 
 
DROP FUNCTION verify_password;

Cordialement.

**0nn2belle** · 27/06/2011, 14h49

Nous avons essayé tel quel en modifiant le code du curseur pour que ce dernier parcoure bien notre table "Dictionnaire", et ça ne fonctionne toujours pas.
Quand j'attribue la fonction au profil, et que je fais un alter user en modifiant le mot de passe, j'ai soit un message d'erreur qui me dit que la vérification n'a pas pu être faite et qu'un nouveau mot de passe doit être rentré uniquement quand le mot de passe contient ou est égal au nom d'utilisateur
Dans les autres cas j'obtiens uniquement un succès de l'élément Alter User.
(c'est un peu confus tout ça !)

Je suis en train de réessayer bloc par bloc de traitement

**0nn2belle** · 27/06/2011, 15h03

Alors j'ai essayé rien qu'en mettant le bloc de vérification de la taille du mot de passe et ça ne fonctionne pas.
J'ai simplement essayé en voulant afficher un message à l'écran et toujours rien.
Il semblerait que le problème vienne de l'appel de la fonction, et non de la fonction en elle même

**mnitu** · 27/06/2011, 15h39

Sample Password Verification Routine

Code :

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

1
2
3
4
5
6
7
 
CREATE OR REPLACE FUNCTION verify_function 
(username varchar2, 
   password varchar2, 
   old_password varchar2) 
   RETURN boolean IS  
...

Je n’aime pas du tout comme c’est codé mais bref, c’est la doc d’Oracle.

**0nn2belle** · 27/06/2011, 15h47

Bon. J'ai trouvé le problème qui n'en est pas un vraiment !!!
En fait tout mon code est bon. Le problème vient de SQL Developer !
J'ai tout fait avec SQL Plus, et tout a fonctionné ! La fonction est correctement appelé et elle m'envoie bien bouler quand le mot de passe n'est pas bon.

Seule précision, elle ne me retourne pas le texte des exceptions que j'ai défini. Une idée pour cela ??

PS : résultat, 3/4 d'une journée de travail bousillée pour ça...

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
 CREATE OR REPLACE FUNCTION verify_password
  (
    username varchar2,
    password varchar2,
    old_password varchar2
  )
RETURN BOOLEAN
IS
n BOOLEAN;
longueur_insuffisante exception;
chiffre_manquant exception;
password_identique_username exception;
mot_interdit exception;
presenceChiffre BOOLEAN;
longueurPassword integer;
listeChiffre varchar2(10);
cursor c1 IS SELECT mot FROM dictionnaire;
 
BEGIN
  DBMS_OUTPUT.PUT_LINE('youhou');
  longueurPassword:=length(password); /*Variable qui sera utilisé tout au long des traitements*/
 
 
  /*----------------Traitement de la longueur d'un mot de passe--------------------------------------------------*/
  IF longueurPassword < 4 THEN /*La fonction length permet de récupérer la longueur du mot de passe*/
    RAISE longueur_insuffisante;
  END IF;
 
  /*----------------Traitement du nombre minimum de chiffre------------------------------------------------------*/
  /*Déclaration et initialisation des variables*/
  listeChiffre :='0123456789';
  presenceChiffre:=false;
 
  FOR i IN 1..10 LOOP /*boucle qui va parcourir la liste des chiffres*/
    FOR j IN 1..longueurPassword LOOP /*Boucle qui va parcourir le mot de passe*/
      IF substr(password,j,1)=substr(listeChiffre,i,1) THEN /*Cherche une correspondance entre le mot de passe et la liste de chiffre*/
        presenceChiffre:=true;
      END IF;
    END LOOP;
  END LOOP;
  IF presenceChiffre=false THEN
        RAISE chiffre_manquant;
  END IF;
 
  /*----------------Fonction qui détermine si le mot de passe est identique au nom d'utilisateur ----------------*/
  FOR i IN 1..longueurPassword LOOP
    IF username = substr(password, i, length(username)) THEN
      RAISE password_identique_username;
    END IF;
  END LOOP;
 
  /*----------------Traitement des mots interdits dans le mot de passe ------------------------------------------*/
  FOR enreg IN c1 LOOP
    FOR i IN 1..longueurPassword LOOP
      IF enreg.mot=substr(NLS_LOWER(password), i, length(enreg.mot)) THEN
        RAISE mot_interdit;
      END IF;
    END LOOP;
  END LOOP;
 
RETURN(TRUE);
 
EXCEPTION
  WHEN longueur_insuffisante THEN
    DBMS_OUTPUT.PUT_LINE('Le mot de passe est trop court, il doit contenir au moins 4 caractères');
    RETURN(FALSE);
 
  WHEN chiffre_manquant THEN
    DBMS_OUTPUT.PUT_LINE('Le mot de passe doit contenir au moins 1 chiffre');
    RETURN(FALSE);
 
  WHEN password_identique_username THEN
    DBMS_OUTPUT.PUT_LINE('Mot de passe est identique au nom d''utilisateur');
    RETURN(FALSE);
 
  WHEN mot_interdit THEN
    DBMS_OUTPUT.PUT_LINE('Votre mot de passe contient un mot interdit');
    RETURN(FALSE);
 
END verify_password;

**AbouZaid** · 27/06/2011, 16h06

A la bonne heure.

**0nn2belle** · 28/06/2011, 09h51

Bon c'est bon tout fonctionne, pour afficher le code de mes exceptions il fallait simplement que je les change par un "raise_application_error", je me permet donc de poster mon code final au cas où :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
 CREATE OR REPLACE FUNCTION verify_password
  (
 
    username varchar2,
    password varchar2,
    old_password varchar2
  )
RETURN BOOLEAN
IS
n BOOLEAN;
longueur_insuffisante exception;
chiffre_manquant exception;
password_identique_username exception;
mot_interdit exception;
presenceChiffre BOOLEAN;
longueurPassword integer;
listeChiffre varchar2(10);
cursor c1 IS SELECT mot FROM dictionnaire;
 
BEGIN
  longueurPassword:=length(password); /*Variable qui sera utilisé tout au long des traitements*/
 
 
  /*----------------Traitement de la longueur d'un mot de passe--------------------------------------------------*/
  IF longueurPassword < 4 THEN /*La fonction length permet de récupérer la longueur du mot de passe*/
    RAISE longueur_insuffisante;
  END IF;
 
  /*----------------Traitement du nombre minimum de chiffre------------------------------------------------------*/
  /*Déclaration et initialisation des variables*/
  listeChiffre :='0123456789';
  presenceChiffre:=false;
 
  FOR i IN 1..10 LOOP /*boucle qui va parcourir la liste des chiffres*/
    FOR j IN 1..longueurPassword LOOP /*Boucle qui va parcourir le mot de passe*/
      IF substr(password,j,1)=substr(listeChiffre,i,1) THEN /*Cherche une correspondance entre le mot de passe et la liste de chiffre*/
        presenceChiffre:=true;
      END IF;
    END LOOP;
  END LOOP;
  IF presenceChiffre=false THEN
        RAISE chiffre_manquant;
  END IF;
 
  /*----------------Fonction qui détermine si le mot de passe est identique au nom d'utilisateur ----------------*/
  FOR i IN 1..longueurPassword LOOP
    IF username = substr(password, i, length(username)) THEN
      RAISE password_identique_username;
    END IF;
  END LOOP;
 
  /*----------------Traitement des mots interdits dans le mot de passe ------------------------------------------*/
  FOR enreg IN c1 LOOP
    FOR i IN 1..longueurPassword LOOP
      IF enreg.mot=substr(NLS_LOWER(password), i, length(enreg.mot)) THEN
        RAISE mot_interdit;
      END IF;
    END LOOP;
  END LOOP;
 
RETURN(TRUE);
 
EXCEPTION
  WHEN longueur_insuffisante THEN
    raise_application_error(-20900,'Le mot de passe est trop court, il doit contenir au moins 4 caractères');
    RETURN(FALSE);
 
  WHEN chiffre_manquant THEN
    raise_application_error(-20901,'Le mot de passe doit contenir au moins 1 chiffre');
    RETURN(FALSE);
 
  WHEN password_identique_username THEN
    raise_application_error(-20902,'Mot de passe est identique au nom d''utilisateur');
    RETURN(FALSE);
 
  WHEN mot_interdit THEN
    raise_application_error(-20903,'Votre mot de passe contient un mot interdit');
    RETURN(FALSE);
 
END verify_password;

Bon courage à tous !

**mnitu** · 28/06/2011, 11h52

Envoyé par 0nn2belle

Bon c'est bon tout fonctionne, pour afficher le code de mes exceptions il fallait simplement que je les change par un "raise_application_error", je me permet donc de poster mon code final au cas où :
...

Comme je l’ai déjà dit je n’aime pas comment c’était codé dans la doc d’Oracle .... De plus, que pensez-vous de l’instruction return false précédée par raise_application_error, sera-t-elle exécutée ou pas ?

Problème avec la vérification de mot de passe d'un profil

PL/SQL Oracle

Discussions similaires

Partager

Partager