Java XML Signature

package Main;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.KeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.UnrecoverableEntryException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.*;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.xml.crypto.MarshalException;
import javax.xml.crypto.dsig.CanonicalizationMethod;
import javax.xml.crypto.dsig.DigestMethod;
import javax.xml.crypto.dsig.Reference;
import javax.xml.crypto.dsig.SignatureMethod;
import javax.xml.crypto.dsig.SignedInfo;
import javax.xml.crypto.dsig.Transform;
import javax.xml.crypto.dsig.XMLSignature;
import javax.xml.crypto.dsig.XMLSignatureException;
import javax.xml.crypto.dsig.XMLSignatureFactory;
import javax.xml.crypto.dsig.dom.DOMSignContext;
import javax.xml.crypto.dsig.keyinfo.KeyInfo;
import javax.xml.crypto.dsig.keyinfo.KeyInfoFactory;
import javax.xml.crypto.dsig.keyinfo.KeyValue;
import javax.xml.crypto.dsig.spec.C14NMethodParameterSpec;
import javax.xml.crypto.dsig.spec.TransformParameterSpec;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.parsers.DocumentBuilder;
import org.xml.sax.SAXException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class Main {

    /** TEST CODE TO CREATE SOAP XMLDSig
     * https://stackoverflow.com/questions/12528667/xml-digital-signature-java
     * https://www.codota.com/code/java/classes/java.security.PrivateKey
     * https://stackoverflow.com/questions/6358555/obtaining-public-key-from-certificate
     * https://stackoverflow.com/questions/33262/how-do-i-load-an-org-w3c-dom-document-from-xml-in-a-string
     * https://www.oracle.com/technical-resources/articles/javase/dig-signatures.html
     * https://dzone.com/articles/signing-soap-messages
     *
     * @param args
     * @throws NoSuchAlgorithmException
     * @throws SignatureException
     * @throws NoSuchPaddingException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     * @throws KeyStoreException
     * @throws CertificateException
     * @throws FileNotFoundException
     * @throws IOException
     * @throws UnrecoverableEntryException
     * @throws InvalidAlgorithmParameterException
     * @throws ParserConfigurationException
     * @throws SAXException
     * @throws KeyException
     * @throws MarshalException
     * @throws TransformerException
     * @throws org.apache.xml.security.signature.XMLSignatureException
     * @throws XMLSecurityException
     */
    public static void main(String[] args)
            throws NoSuchAlgorithmException,
                   SignatureException,
                   NoSuchPaddingException,
                   IllegalBlockSizeException,
                   BadPaddingException,
                   KeyStoreException,
                   CertificateException,
                   FileNotFoundException,
                   IOException,
                   UnrecoverableEntryException,
                   InvalidAlgorithmParameterException,
                   ParserConfigurationException,
                   SAXException,
                   KeyException,
                   MarshalException,
                   XMLSignatureException,
                   TransformerException,
                   XMLSecurityException {
    // Algorythms to use
    String XMLNS_WSU = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd";
    String XSD_WSSE = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
    String SECURITY = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary";
    String PROFILE = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-profile-1.0#X509v3";
    String XMLDsig = "http://www.w3.org/2000/09/xmldsig#";
    String C14 = "http://www.w3.org/2001/10/xml-exc-c14n#";
    String RSA = "http://www.w3.org/2000/09/xmldsig#rsa-sha1";
    String SHA1 = "http://www.w3.org/2000/09/xmldsig#sha1";

    // Certificate data
    String alias = "ALIAS";
    String path = "CERT PATH";
    String password = "PSSWD";

    // Load cert from keystore in file
    KeyStore keyStore = KeyStore.getInstance("JKS");
    keyStore.load(
        new FileInputStream(path),
        password.toCharArray()
    );

    KeyStore.PrivateKeyEntry pkEntry =
        (KeyStore.PrivateKeyEntry) keyStore.getEntry(
            alias,
            new KeyStore.PasswordProtection(password.toCharArray()
        )
    );

    PrivateKey privateKey = pkEntry.getPrivateKey();
        PublicKey publicKey = keyStore.getCertificate(alias).getPublicKey();

    // Compute binary security token
    String binarySecurityToken = Base64.getEncoder().encodeToString(keyStore.getCertificate(alias).getEncoded());

    // Compute signature and digest
    XMLSignatureFactory fac = XMLSignatureFactory.getInstance();
        DigestMethod digestMethod = fac.newDigestMethod(DigestMethod.SHA1, null);
        Transform transform = fac.newTransform(C14, (TransformParameterSpec) null);
        List<Transform> transforms = new ArrayList<Transform>();
        transforms.add(transform);
        Reference reference = fac.newReference("", digestMethod, transforms, null, null);
        SignatureMethod signatureMethod = fac.newSignatureMethod(RSA, null);
        CanonicalizationMethod canonicalizationMethod = fac.newCanonicalizationMethod(C14, (C14NMethodParameterSpec) null);
        List<Reference> references = new ArrayList<Reference>();
        references.add(reference);
        SignedInfo si = fac.newSignedInfo(canonicalizationMethod, signatureMethod, references);

        String plaintext = "SOAPBody HERE";
        Document doc = loadXMLFromString(plaintext);

        // Method - https://stackoverflow.com/questions/12528667/xml-digital-signature-java
        DOMSignContext dsc = new DOMSignContext(privateKey, doc.getDocumentElement());

        KeyInfoFactory kif = fac.getKeyInfoFactory();
        KeyValue kv = kif.newKeyValue(publicKey);
        KeyInfo ki = kif.newKeyInfo(Collections.singletonList(kv));

        XMLSignature signature = fac.newXMLSignature(si, ki);
        signature.sign(dsc);

        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer trans = tf.newTransformer();
        trans.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        StringWriter output = new StringWriter();
        trans.transform(new DOMSource(doc), new StreamResult(output));

        // Common data
        System.out.println(">> Common data");
        System.out.println("Input data: '" + plaintext + "'");
        System.out.println("Binary Security Token: '" + binarySecurityToken + "'");
        System.out.println();

        // Display results
        System.out.println(">> Values");
        System.out.println("Digest: '" + Base64.getEncoder().encodeToString(reference.getDigestValue()) + "'");
        System.out.println("Signature: '" + Base64.getEncoder().encodeToString(signature.getSignatureValue().getValue()) + "'");
        System.out.println();
    }

    public static Document loadXMLFromString(String xml) throws ParserConfigurationException, SAXException, IOException
    {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        //factory.setNamespaceAware(true);
        DocumentBuilder builder = factory.newDocumentBuilder();
        return builder.parse(new ByteArrayInputStream(xml.getBytes()));
    }
}