Comment vérifier un pot signé avec jarsigner par programmation

Je suis désireux de signer un bocal à l'aide de jarsigner, puis vérifier à l'aide d'une application Java, qui n'a pas signé le pot, car une partie du classpath (c'est à dire juste en utilisant un système de fichiers à l'emplacement du pot)

Maintenant, mon problème est d'obtenir le fichier de signature du pot, est-il un moyen simple de faire cela?

J'ai eu un jeu avec le Inflater et un Pot de InputStreams avec pas de chance.

Ou est-ce quelque chose qui peut être accompli dans une meilleure façon?

Grâce

InformationsquelleAutor James Carr | 2009-09-03
  1. 14

    La Fournisseur de sécurité guide de mise en œuvre décrit le processus de vérification des Pots. Bien que ces instructions sont pour un JCA fournisseur de services de chiffrement de vérifier lui-même, ils devraient être applicables à votre problème.

    Plus précisément, découvrez la verify(X509Certificate targetCert) méthode dans l'exemple de code, "MyJCE.java".

    • Au lieu de vous suggérer le code, ils pourraient avoir ainsi fourni un verifyAllContent() la méthode 😉
    InformationsquelleAutor erickson
  2. 15

    Vous pouvez simplement ouvrir le BOCAL avec java.util.jar.Jarfiles et dites-lui de vérifier le fichier JAR. Si le POT est signé, puis Jarfiles a la possibilité de le vérifier (qui est par défaut). Cependant, Jarfiles également d'ouvrir unsigned Pots heureusement, par conséquent, vous devez également vérifier si le fichier est signé. Vous pouvez le faire en vérifiant le POT de manifeste pour *Digérer les attributs: les Éléments avec un tel attribut attribut sont signés.

    Exemple:

    JarFile jar = new JarFile(new File("path/to/your/jar-file"));

//This call will throw a java.lang.SecurityException if someone has tampered
//with the signature of _any_ element of the JAR file.
//Alas, it will proceed without a problem if the JAR file is not signed at all
InputStream is = jar.getInputStream(jar.getEntry("META-INF/MANIFEST.MF"));
Manifest man = new Manifest(is);
is.close();

Set<String> signed = new HashSet();
for(Map.Entry<String, Attributes> entry: man.getEntries().entrySet()) {
    for(Object attrkey: entry.getValue().keySet()) {
        if (attrkey instanceof Attributes.Name && 
           ((Attributes.Name)attrkey).toString().indexOf("-Digest") != -1)
            signed.add(entry.getKey());
    }
}

Set<String> entries = new HashSet<String>();
for(Enumeration<JarEntry> entry = jar.entries(); entry.hasMoreElements(); ) {
    JarEntry je = entry.nextElement();
    if (!je.isDirectory())
        entries.add(je.getName());
}

//contains all entries in the Manifest that are not signed.
//Ususally, this contains:
// * MANIFEST.MF itself
// * *.SF files containing the signature of MANIFEST.MF
// * *.DSA files containing public keys of the signer

Set<String> unsigned = new HashSet<String>(entries);
unsigned.removeAll(signed);

//contains all the entries with a signature that are not present in the JAR
Set<String> missing = new HashSet<String>(signed);
missing.removeAll(entries);
    • L'ouverture d'un bocal via Jarfiles(nom de fichier) ne vérifie pas les classes dans le POT il permet uniquement de vérification qui se passe sur l'accès. Donc pour vérifier toutes les entrées d'un Jar, vous devez appeler le bocal.getInputStream(..) pour chaque entrée, ce qui déclenche la vérification.
    • voir stackoverflow.com/a/5589898/3934807 pour un peu de code qui implémente la suggestion de Robert
    • il n'y a pas de référence à laquelle fichier de clés à utiliser pour la validation de la signature (celui utilisé pour signer des pots)
    InformationsquelleAutor nd.
  3. 2

    Vous pouvez utiliser l'entrée.getCodeSigners() pour obtenir les signataires d'une entrée particulière dans le POT.

    Assurez-vous d'ouvrir le Jarfiles à vérifier=vrai et de mieux lire le POT à l'entrée avant d'appeler l'entrée.getCodeSigners().

    Quelque chose comme cela pourrait être utilisé pour vérifier chaque entrée qui n'est pas un fichier de signature:

    boolean verify = true;
JarFile jar = new JarFile(signedFile, verify);

//Need each entry so that future calls to entry.getCodeSigners will return anything
Enumeration<JarEntry> entries = jar.entries();
while (entries.hasMoreElements()) {
   JarEntry entry = entries.nextElement();
   IOUtils.copy(jar.getInputStream(entry), new NullOutputStream());
}

//Now check each entry that is not a signature file
entries = jar.entries();
while (entries.hasMoreElements()) {
    JarEntry entry = entries.nextElement();
    String fileName = entry.getName().toUpperCase(Locale.ENGLISH);
    if (!fileName.endsWith(".SF")
       && !fileName.endsWith(".DSA")
       && !fileName.endsWith(".EC")
       && !fileName.endsWith(".RSA")) {

       //Now get code signers, inspect certificates etc here...
       //entry.getCodeSigners();
    }
 }
    InformationsquelleAutor Markus
  4. -2

    Vous pouvez utiliser le jarsigner application pour ce faire. Dans processbuilder (ou de l'Exécution.exec), vous pouvez exécuter la commande avec ces arguments

     ProcessBulider pb = new ProcessBuilder("/usr/bin/jarsigner", "-verify", "-certs", f.getAbsolutePath());

    et si la sortie contient vérifié alors le pot est signé

    Process p = pb.start();
p.waitFor();
InputStream is = p.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null)
{
if(line.contains("verified");
...

    Il y a de plus compliqué les choses que vous pouvez faire lorsque vous avez la sortie de la jarsigner code.

    • L'exemple de la plate-forme et, en outre, la jarsigner outil habituellement seulement avec le JDK.
    • jarsigner de ne pas vérifier le certificat du signataire (de sorte que toute non approuvé signature de le faire), il ne vérifie pas confiance horodateurs (ne peut pas gérer les signatures valides à partir de signataires dont les certificats expirés) et sa sortie est inutile ("vérifiée" est revenue, même en cas d'erreur, un peu plus d'informations peuvent être obtenues par l'analyse d'erreur et messages d'avertissement - mais qui n'est toujours pas suffisant pour décider si un certificat est valide).
    InformationsquelleAutor Milhous