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

Question

Sto provando a digitally sign an XML document utilizzando Java. Ho una implementazione che funziona con alcuni riferimenti che ho trovato che utilizzano varie implementazioni nel pacchetto javax.xml.crypto.dsig.

Tuttavia, la mia attuale implementazione è come many del examples Ho guardato - è piuttosto prolisso e coinvolge utilizzando non meno di 23 diverse classi API dalle java.xml.crypto.dsig, javax.xml.transform, e java.security pacchetti, tra gli altri. Mi sembra di aver inserito il terreno factory factory factory e mi ci sono volute diverse ore per capire cosa stava succedendo.

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

OutputStream signFile(InputStream xmlFile, File privateKey) 

... senza tutti la follia XMLSignatureFactory/CanonicalizationMethod/DOMSignContext?

Non sono molto esperto di crittografia e l'API fornita da Java sembra piuttosto scoraggiante per sviluppatori come me che cercano di familiarizzare con la firma digitale. Se tutto ciò è necessario o se al momento non ci sono API più amichevoli, va bene e sono disposto ad accettarlo come risposta. Vorrei solo sapere se sto prendendo inutilmente la strada difficile qui.

Answer 1

Ho esaminato tutte le opzioni per la firma di file XML e ho deciso di adottare un approccio non standard. Gli standard erano troppo verbosi. Inoltre, non avevo bisogno di compatibilità con gli standard --- avevo solo bisogno di firme su un blocco di XML.

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

Answer 2

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

Answer 3

Edificio da Apache Santuario CreateSignature esempio, la cosa più breve che ho potuto inventare è questa. Senza la main() e lo accompagna output(), è 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); 
     } 
    } 
}