Intégration de la branche release-6.5.0

CHANGES.md

@@ -1,3 +1,10 @@
+## Version 6.5.0 du 30/05/2017-17:12
+
+* `f9f0ffc` toinst: les options -r et -B ne requièrent pas que la webapp source existe
+* `d4591df` rtoinst: ne pas copier les fichiers de VCS lors du déploiement
+* `bef927c` umirror: ajouter les options -g et -n pour faciliter le téléchargement des livraisons APOGEE
+* `5d3f576` upassword: nouvelles options -m et -n pour la gestion des salts
+
 ## Version 6.4.0 du 05/05/2017-16:50
 
 * `c25160c` fndate: maj doc et améliorations ergonomiques

VERSION.txt

@@ -1 +1 @@
-6.4.0
+6.5.0

rtoinst

@@ -208,7 +208,7 @@ while [ $# -gt 0 ]; do
         src="$wadir"
     elif [ -d "$src" ]; then
         estep "$(ppath2 "$src")"
-        cp_R "$src" "$workdir/$srcname" || die
+        cpdirnovcs "$src" "$workdir/$srcname" || die
     elif [ -e "$src" ]; then
         die "$osrc: fichier invalide"
     else

toinst

@@ -412,7 +412,10 @@ fi
 # A partir de la liste des webapps et de WAMAPS, construire une liste de couples
 # waname:src pour la sauvegarde et/ou le déploiement
 
-[ -n "$fake" -o "$action" == config-template ] && will_deploy= || will_deploy=1
+[ -n "$fake" \
+     -o "$action" == config-template \
+     -o "$action" == restart \
+     -o "$action" == backup ] && will_deploy= || will_deploy=1
 
 if [ $# -eq 0 -a -n "$will_deploy" ]; then
     [ -d WEB-INF ] && src=. || src=
@@ -423,10 +426,14 @@ elif [ $# -eq 0 -a "$action" == config-template ]; then
 fi
 
 srcs=()
-[ -n "$istmpdir" ] || ac_set_tmpdir tmpdir
+[ -n "$istmpdir" -o -z "$will_deploy" ] || ac_set_tmpdir tmpdir
 for src in "$@"; do
     if [ -f "$src" ] && is_archive "$src"; then
         setx waname=get_archive_appname "$src"
+        if [ -z "$will_deploy" ]; then
+            setxx wadir=dirname -- "$src" // abspath
+            array_add srcs "$wadir/$waname"
+        else
             wadir="$tmpdir/$waname"
             mkdir "$wadir"
             if extract_archive "$src" "$wadir"; then
@@ -434,8 +441,11 @@ for src in "$@"; do
             else
                 eerror "$src: erreur lors de l'extraction de l'archive"
             fi
+        fi
     elif [ -d "$src" ]; then
         array_add srcs "$(abspath "$src")"
+    elif [ -z "$will_deploy" ]; then
+        array_add srcs "$(abspath "$src")"
     elif [ -e "$src" ]; then
         eerror "$src: fichier invalide"
     else

umirror

@@ -10,14 +10,23 @@ USAGE
     $scriptname [options] url [wget_options]
 
 OPTIONS
-    -l
+    -l, --local
-        Convertir les liens pour consultation locale"
+        Convertir les liens pour consultation locale
+    -g, --no-robots
+        Ne pas tenir compte du fichier robots.txt
+    -n, --no-index
+        Ne pas télécharger les fichiers de la forme 'index.html*'. Utile pour
+        faire un miroir d'un site ftp qui est servi en http."
 }
 
 local=
+no_robots=
+no_index=
 parse_opts + "${PRETTYOPTS[@]}" \
     --help '$exit_with display_help' \
-    -l local=1 \
+    -l,--local local=1 \
+    -g,--no-robots no_robots=1 \
+    -n,--no-index no_index=1 \
     @ args -- "$@" && set -- "${args[@]}" || die "$args"
 
 url="$1"; shift
@@ -31,4 +40,6 @@ fi
 
 args=(-m -p -np)
 [ -n "$local" ] && args=("${args[@]}" -k -K)
+[ -n "$no_robots" ] && args=("${args[@]}" -e robots=off)
+[ -n "$no_index" ] && args=("${args[@]}" -R "index.html*")
 wget "${args[@]}" "$@" "$url"

upassword

@@ -4766,6 +4766,10 @@ public class upassword {
         HASH_PASSWORD, GEN_AESKEY, SHOW_AESKEY, AES_ENCRYPT, AES_DECRYPT;
     }
 
+    private static enum EHashAction {
+        AUTO, CHECK_MATCH, SAME_OR_NEW, NEW;
+    }
+
     private static final void checkExisting(String aeskeyfile) {
         if (aeskeyfile == null) die("Vous devez spécifier l'option -f", null);
         if (!new File(aeskeyfile).exists()) die(aeskeyfile + ": Fichier introuvable", null);
@@ -4873,6 +4877,16 @@ public class upassword {
                     + "\n    -p, --hash-password"
                     + "\n        Crypter un mot de passe (option par défaut). Si le mot de passe en clair"
                     + "\n        et/ou le salt ne sont pas spécifiés, ils sont choisis au hasard."
+                    + "\n    -m, --salt-check-match-hash"
+                    + "\n    -n, --salt-same-or-new-hash"
+                    + "\n        Spécifier le comportement à adopter si les salts qui sont spécifiés sont"
+                    + "\n        des hashes normalisés."
+                    + "\n        Avec l'option -m (par défaut), pour chacun des hashes, le salt est"
+                    + "\n        extrait et le mot de passe en clair est hashé avec ce salt et le scheme"
+                    + "\n        spécifiés. Si le hash résultant est le même, afficher 'match: true'"
+                    + "\n        Avec l'option -n, si l'un des hashes correspond au mot de passe en"
+                    + "\n        clair, alors afficher ce hash. Sinon, faire comme si le mot de passe en"
+                    + "\n        clair avait été spécifié sans salt et choisir un nouveau salt au hasard."
                     + "\n    -j, --clear-is-codetu JKEY"
                     + "\n        Indiquer que l'argument clear est un numéro d'étudiant, à partir duquel"
                     + "\n        il faut générer le mot de passe. Cette option n'est valide qu'avec -p"
@@ -4921,6 +4935,7 @@ public class upassword {
         }
 
         EAction action = EAction.HASH_PASSWORD;
+        EHashAction hashAction = EHashAction.AUTO;
         boolean codEtu = false, crypted = false, shell = false;
         String codEtuKey = null;
         String aeskeyfile = null;
@@ -4946,6 +4961,12 @@ public class upassword {
             } else if (arg.equals("-k") || args.equals("--clear-is-crypted")) {
                 crypted = true;
                 i++;
+            } else if (arg.equals("-m") || args.equals("--salt-check-match-hash")) {
+                hashAction = EHashAction.CHECK_MATCH;
+                i++;
+            } else if (arg.equals("-n") || args.equals("--salt-same-or-new-hash")) {
+                hashAction = EHashAction.SAME_OR_NEW;
+                i++;
             } else if (arg.equals("-G") || arg.equals("--aes-genkey")) {
                 action = EAction.GEN_AESKEY;
                 i++;
@@ -5014,7 +5035,58 @@ public class upassword {
                 clear = pg.generate();
             }
 
+            String newCryptSalt = null;
+            byte[] newBinarySalt = null;
             if (args.length <= 1) {
+                hashAction = EHashAction.NEW;
+            } else if (hashAction == EHashAction.AUTO) {
+                hashAction = EHashAction.CHECK_MATCH;
+            } else if (hashAction == EHashAction.SAME_OR_NEW) {
+                i = 1;
+                max = args.length;
+                while (i < max) {
+                    String salt = args[i++];
+                    if (Password.isNormalizedFormat(salt)) {
+                        if (Password.isCryptScheme(salt)) {
+                            String cryptSalt = Salt.getCryptSalt(salt);
+                            String crypt = getPasswordCryptSalt(clear, Password.CRYPT, cryptSalt)
+                                    .getNormalized();
+                            if (salt.equals(crypt)) newCryptSalt = cryptSalt;
+                        } else if (Password.isSshaScheme(salt)) {
+                            byte[] sshaSalt = Salt.getSshaSalt(salt);
+                            String ssha = getPasswordBinarySalt(clear, Password.SSHA, sshaSalt)
+                                    .getNormalized();
+                            if (salt.equals(ssha)) newBinarySalt = sshaSalt;
+                        } else if (Password.isSmd5Scheme(salt)) {
+                            byte[] smd5Salt = Salt.getSmd5Salt(salt);
+                            String smd5 = getPasswordBinarySalt(clear, Password.SMD5, smd5Salt)
+                                    .getNormalized();
+                            if (salt.equals(smd5)) newBinarySalt = smd5Salt;
+                        }
+                    } else if (isHex(salt)) {
+                        byte[] binarySalt = fromHex(salt);
+                        String ssha = getPasswordBinarySalt(clear, Password.SSHA, binarySalt)
+                                .getNormalized();
+                        String smd5 = getPasswordBinarySalt(clear, Password.SMD5, binarySalt)
+                                .getNormalized();
+                        if (salt.length() >= 2) {
+                            String cryptSalt = Salt.getCryptSalt(salt);
+                            String crypt = getPasswordCryptSalt(clear, Password.CRYPT, cryptSalt)
+                                    .getNormalized();
+                            if (salt.equals(crypt)) newCryptSalt = cryptSalt;
+                        }
+                        if (salt.equals(ssha) || salt.equals(smd5)) newBinarySalt = binarySalt;
+                    } else {
+                        String cryptSalt = Salt.getCryptSalt(salt);
+                        String crypt = getPasswordCryptSalt(clear, Password.CRYPT, cryptSalt)
+                                .getNormalized();
+                        if (salt.equals(crypt)) newCryptSalt = cryptSalt;
+                    }
+                }
+                hashAction = EHashAction.NEW;
+            }
+
+            if (hashAction == EHashAction.NEW) {
                 // Pas de salt, afficher simplement les versions cryptées des mots
                 // de passe pour tous les schemes. Le salt est choisi au hasard pour
                 // chaque mot de passe. Il est donc différent à chaque fois.
@@ -5026,12 +5098,15 @@ public class upassword {
                     ntlm = p.getNtlmHash();
                 } catch (Password.NotAvailableException e) {
                 }
-                String crypt = getPasswordAnySalt(clear, Password.CRYPT, null).getNormalized();
+                String crypt = getPasswordCryptSalt(clear, Password.CRYPT, newCryptSalt)
+                        .getNormalized();
                 String sha = getPasswordAnySalt(clear, Password.SHA, null).getNormalized();
                 String xsha = getPasswordAnySalt(clear, Password.XSHA, null).getNormalized();
-                String ssha = getPasswordAnySalt(clear, Password.SSHA, null).getNormalized();
+                String ssha = getPasswordBinarySalt(clear, Password.SSHA, newBinarySalt)
+                        .getNormalized();
                 String md5 = getPasswordAnySalt(clear, Password.MD5, null).getNormalized();
-                String smd5 = getPasswordAnySalt(clear, Password.SMD5, null).getNormalized();
+                String smd5 = getPasswordBinarySalt(clear, Password.SMD5, newBinarySalt)
+                        .getNormalized();
                 String aes = null;
                 if (aeskey != null) {
                     try {
@@ -5051,7 +5126,7 @@ public class upassword {
                 printvar("md5", md5, shell);
                 printvar("smd5", smd5, shell);
                 if (aes != null) printvar("aes", aes, shell);
-            } else {
+            } else if (hashAction == EHashAction.CHECK_MATCH) {
                 // Afficher uniquement les versions cryptées des mots de passe avec
                 // les schemes correspondant aux salts spécifiés, pour chacun des
                 // salts spécifiés.
@@ -5113,6 +5188,8 @@ public class upassword {
                         if (salt.equals(crypt)) printvar("match", "true", shell);
                     }
                 }
+            } else {
+                throw new Error("bug: hashAction==" + hashAction);
             }
             break;
         }