C'è un modo più semplice per firmare un documento XML in Java?

Question

Sto cercando di firmare digitalmente un documento XML utilizzando Java. Ho un'implementazione di lavoro con alcuni riferimenti che ho trovato che utilizzano varie implementazioni nel pacchetto javax.xml.crypto.dsig .

Tuttavia, la mia attuale implementazione è come molti della esempi ho guardato - è piuttosto prolisso e prevede l'impiego di non meno di 23 diverse classi API dai pacchetti java.xml.crypto.dsig, javax.xml.transform, e java.security, tra gli altri. Ci si sente come ho inserito terra fabbrica fabbrica fabbrica , e ci sono voluti me diverse ore solo per capire cosa stava succedendo.

La mia domanda è, c'è un modo più semplice per fare questo? Se ho i file di chiave pubblica / privata e voglio aggiungere un <Signature/> a un documento XML, c'è una biblioteca fuori lì che solo permette di chiamare me qualcosa di simile:

OutputStream signFile(InputStream xmlFile, File privateKey)

... senza tutte le XMLSignatureFactory / CanonicalizationMethod / DOMSignContext pazzia?

Non sono molto ben versato in crittografia, e le API Java fornito sembra piuttosto scoraggiante per gli sviluppatori come me cercando di prendere confidenza con la firma digitale. Se tutto questo è necessario o non ci sono ancora API amichevole là fuori, va bene e sono disposti ad accettare che come risposta. Vorrei solo sapere se sto inutilmente prendendo la strada difficile qui.

Answer 1

Ho guardato tutte le opzioni per la firma i file XML e ha deciso di andare con un approccio non-standard. Gli standard erano tutti troppo prolisso. Inoltre, non ho bisogno di compatibilità con gli standard --- I soli firme necessarie su un blocco di XML.

Probabilmente il modo più semplice per "firmare" un blocco di XML è quello di utilizzare GPG con una firma distaccata.

Answer 2

Dai un'occhiata al Apache XML Security . Per utilizzare il pacchetto per generare e verificare una firma, checkout i campioni in src_samples/org/apache/xml/security/samples/signature/ .

Answer 3

Edificio dall'esempio CreateSignature Apache Santuario, la cosa più breve ho potuto venire in mente è questo. Senza la main() e la sua output() accompagna, è 20 linee

import java.io.*;
import java.security.Key;
import java.security.KeyStore;
import java.security.cert.X509Certificate;
import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.commons.io.IOUtils;
import org.apache.xml.security.Init;
import org.apache.xml.security.c14n.Canonicalizer;
import org.apache.xml.security.signature.XMLSignature;
import org.apache.xml.security.transforms.Transforms;
import org.apache.xml.security.utils.Constants;
import org.apache.xml.security.utils.ElementProxy;
import org.w3c.dom.Document;

public class CreateSignature {

    private static final String PRIVATE_KEY_ALIAS = "test-alias";
    private static final String PRIVATE_KEY_PASS = "test";
    private static final String KEY_STORE_PASS = "test";
    private static final String KEY_STORE_TYPE = "JKS";

    public static void main(String... unused) throws Exception {
        final InputStream fileInputStream = new FileInputStream("test.xml");
        try {
            output(signFile(fileInputStream, new File("keystore.jks")), "signed-test.xml");
        }
        finally {
            IOUtils.closeQuietly(fileInputStream);
        }
    }

    public static ByteArrayOutputStream signFile(InputStream xmlFile, File privateKeyFile) throws Exception {
        final Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(xmlFile);
        Init.init();
        ElementProxy.setDefaultPrefix(Constants.SignatureSpecNS, "");
        final KeyStore keyStore = loadKeyStore(privateKeyFile);
        final XMLSignature sig = new XMLSignature(doc, null, XMLSignature.ALGO_ID_SIGNATURE_RSA);
        final Transforms transforms = new Transforms(doc);
        transforms.addTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE);
        sig.addDocument("", transforms, Constants.ALGO_ID_DIGEST_SHA1);
        final Key privateKey = keyStore.getKey(PRIVATE_KEY_ALIAS, PRIVATE_KEY_PASS.toCharArray());
        final X509Certificate cert = (X509Certificate)keyStore.getCertificate(PRIVATE_KEY_ALIAS);
        sig.addKeyInfo(cert);
        sig.addKeyInfo(cert.getPublicKey());
        sig.sign(privateKey);
        doc.getDocumentElement().appendChild(sig.getElement());
        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        outputStream.write(Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_WITH_COMMENTS).canonicalizeSubtree(doc));
        return outputStream;
    }

    private static KeyStore loadKeyStore(File privateKeyFile) throws Exception {
        final InputStream fileInputStream = new FileInputStream(privateKeyFile);
        try {
            final KeyStore keyStore = KeyStore.getInstance(KEY_STORE_TYPE);
            keyStore.load(fileInputStream, KEY_STORE_PASS.toCharArray());
            return keyStore;
        }
        finally {
            IOUtils.closeQuietly(fileInputStream);
        }
    }

    private static void output(ByteArrayOutputStream signedOutputStream, String fileName) throws IOException {
        final OutputStream fileOutputStream = new FileOutputStream(fileName);
        try {
            fileOutputStream.write(signedOutputStream.toByteArray());
            fileOutputStream.flush();
        }
        finally {
            IOUtils.closeQuietly(fileOutputStream);
        }
    }
}