Comment vérifier un pot signé avec jarsigner programme

Question

Je suis désireux de signer un pot en utilisant jarsigner, puis vérifiez à l'aide d'une application Java qui ne possède pas le pot signé dans le cadre de celui-ci est classpath (à savoir juste en utilisant un emplacement du système de fichiers du pot)

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

J'ai eu un jeu avec les InputStreams gonfleur et Jar sans chance.

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

Merci

Answer 1

sécurité Guide de mise en œuvre du fournisseur décrit le processus de vérification Jarres. Bien que ces instructions sont pour un fournisseur de services cryptographiques JCA se vérifier, ils devraient être applicables à votre problème.

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

Answer 2

Vous pouvez simplement ouvrir le JAR avec java.util.jar.JarFile et lui dire de vérifier le fichier JAR. Si le JAR est signé, JarFile a la possibilité de le vérifier (qui est activée par défaut). Cependant, JarFile sera également ouvert JARs non signés heureusement, donc vous devez également vérifier, si oui ou non le fichier est signé. Vous pouvez le faire en vérifiant le manifeste du JAR pour * attributs -Digest. Les éléments avec un tel attribut d'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);

Answer 3

Vous pouvez utiliser entry.getCodeSigners () pour obtenir les signataires pour une entrée particulière dans le JAR.

Assurez-vous d'ouvrir le fichier Jar avec vérification = true et de lire entièrement l'entrée JAR avant d'appeler entry.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();
    }
 }

Answer 4

Vous pouvez utiliser l'application jarsigner pour le faire. En ProcessBuilder (ou Runtime.exec) vous pouvez exécuter la commande avec ces arguments

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

et si les CONTIENT LE sorties vérifiés puis 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 des choses plus compliquées que vous pouvez faire lorsque vous avez la sortie du code jarsigner.