Java XMLCipher.init方法代码示例

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
private void decryptDocument(Document docSource, KeyResolverSpi internalResolver) throws Exception
{
    Document document = (Document)docSource.cloneNode(true);
    Element rootElement = document.getDocumentElement();
    Element encryptedDataElement = (Element)rootElement.getFirstChild();

    XMLCipher decryptCipher = XMLCipher.getInstance();
    decryptCipher.init(XMLCipher.DECRYPT_MODE, null);
    if (internalResolver != null) {
        decryptCipher.registerInternalKeyResolver(internalResolver);
    }
    decryptCipher.doFinal(document, encryptedDataElement);

    Element decryptedElement = (Element) rootElement.getFirstChild();
    assertEquals("elem", decryptedElement.getLocalName());
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
@org.junit.Test
public void testEncryptedKeyWithRecipient() throws Exception {
    String filename =
        "src/test/resources/org/apache/xml/security/encryption/encryptedKey.xml";
    if (basedir != null && !"".equals(basedir)) {
        filename = basedir + "/" + filename;
    }
    File f = new File(filename);

    DocumentBuilder builder = XMLUtils.createDocumentBuilder(false);
    Document document = builder.parse(f);

    XMLCipher keyCipher = XMLCipher.getInstance();
    keyCipher.init(XMLCipher.UNWRAP_MODE, null);

    NodeList ekList =
        document.getElementsByTagNameNS(
            EncryptionConstants.EncryptionSpecNS, EncryptionConstants._TAG_ENCRYPTEDKEY
        );
    for (int i = 0; i < ekList.getLength(); i++) {
        EncryptedKey ek =
            keyCipher.loadEncryptedKey(document, (Element) ekList.item(i));
        assertNotNull(ek.getRecipient());
    }
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
@org.junit.Test
public void testEecryptToByteArray() throws Exception {
    if (!bcInstalled) {
        return;
    }
    KeyGenerator keygen = KeyGenerator.getInstance("AES");
    keygen.init(128);
    Key key = keygen.generateKey();

    Document document = document();

    XMLCipher cipher = XMLCipher.getInstance(XMLCipher.AES_128_GCM);
    cipher.init(XMLCipher.ENCRYPT_MODE, key);
    cipher.getEncryptedData();

    Document encrypted = cipher.doFinal(document, document);

    XMLCipher xmlCipher = XMLCipher.getInstance();
    xmlCipher.init(XMLCipher.DECRYPT_MODE, key);
    Element encryptedData = (Element) encrypted.getElementsByTagNameNS(EncryptionConstants.EncryptionSpecNS, EncryptionConstants._TAG_ENCRYPTEDDATA).item(0);

    xmlCipher.decryptToByteArray(encryptedData);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
/**
 * Decrypt the document using DOM API and run some tests on the decrypted Document.
 */
private Document decryptUsingDOM(
    String algorithm,
    SecretKey secretKey,
    Key wrappingKey,
    Document document
) throws Exception {
    XMLCipher cipher = XMLCipher.getInstance(algorithm);
    cipher.init(XMLCipher.DECRYPT_MODE, secretKey);
    if (wrappingKey != null) {
        cipher.setKEK(wrappingKey);
    }

    NodeList nodeList = document.getElementsByTagNameNS(
            XMLSecurityConstants.TAG_xenc_EncryptedData.getNamespaceURI(),
            XMLSecurityConstants.TAG_xenc_EncryptedData.getLocalPart()
        );
    Element ee = (Element)nodeList.item(0);
    return cipher.doFinal(document, ee);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
@org.junit.Test
public void testRSAOAEP11KW() throws Exception {
    // Read in plaintext document
    InputStream sourceDocument =
            this.getClass().getClassLoader().getResourceAsStream(
                    "ie/baltimore/merlin-examples/merlin-xmlenc-five/plaintext.xml");
    DocumentBuilder builder = XMLUtils.createDocumentBuilder(false);
    Document document = builder.parse(sourceDocument);

    // Set up the Key
    KeyGenerator keygen = KeyGenerator.getInstance("DESede");
    SecretKey key = keygen.generateKey();

    // Set up the Key Wrapping Key
    XMLCipher cipher = XMLCipher.getInstance(XMLCipher.RSA_OAEP_11);
    cipher.init(XMLCipher.WRAP_MODE, rsaKeyPair.getPublic());
    EncryptedKey encryptedKey = cipher.encryptKey(document, key);

    List<String> localNames = new ArrayList<String>();
    localNames.add("PaymentInfo");

    String encryptionAlgorithm = XMLCipher.TRIPLEDES;

    encrypt(encryptedKey, encryptionAlgorithm, document, localNames, key);

    // Check the CreditCard encrypted ok
    NodeList nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 0);

    // XMLUtils.outputDOM(document, System.out);
    document = decrypt(document, rsaKeyPair.getPrivate());

    // Check the CreditCard decrypted ok
    nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 1);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
private void encryptSymmetric(Exchange exchange, Document document, OutputStream stream) throws Exception {
    Key keyEncryptionKey;
    Key dataEncryptionKey;
    if (xmlCipherAlgorithm.equals(XMLCipher.TRIPLEDES)) {
        keyEncryptionKey = generateKeyEncryptionKey("DESede");
        dataEncryptionKey = generateDataEncryptionKey();
    } else if (xmlCipherAlgorithm.equals(XMLCipher.SEED_128)) {
        keyEncryptionKey = generateKeyEncryptionKey("SEED");
        dataEncryptionKey = generateDataEncryptionKey();
    } else if (xmlCipherAlgorithm.contains("camellia")) {
        keyEncryptionKey = generateKeyEncryptionKey("CAMELLIA");
        dataEncryptionKey = generateDataEncryptionKey();
    } else {
        keyEncryptionKey = generateKeyEncryptionKey("AES");
        dataEncryptionKey = generateDataEncryptionKey();
    } 
    
    XMLCipher keyCipher = XMLCipher.getInstance(generateXmlCipherAlgorithmKeyWrap());
    keyCipher.init(XMLCipher.WRAP_MODE, keyEncryptionKey);
    
    encrypt(exchange, document, stream, dataEncryptionKey, keyCipher, keyEncryptionKey);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
private void encrypt(Exchange exchange, Document document, OutputStream stream, Key dataEncryptionKey, 
                     XMLCipher keyCipher, Key keyEncryptionKey) throws Exception {
    XMLCipher xmlCipher = XMLCipher.getInstance(xmlCipherAlgorithm);
    xmlCipher.init(XMLCipher.ENCRYPT_MODE, dataEncryptionKey);

    if (secureTag.equalsIgnoreCase("")) {
        embedKeyInfoInEncryptedData(document, keyCipher, xmlCipher, dataEncryptionKey, keyEncryptionKey);
        document = xmlCipher.doFinal(document, document.getDocumentElement());
    } else {
                      
        XPathBuilder xpathBuilder = new XPathBuilder(secureTag);
        xpathBuilder.setNamespaceContext(getNamespaceContext());
        NodeList nodeList = xpathBuilder.evaluate(exchange, NodeList.class);
        
        
        for (int i = 0; i < nodeList.getLength(); i++) {
            Node node = nodeList.item(i);
            document = node.getOwnerDocument();
            embedKeyInfoInEncryptedData(node.getOwnerDocument(), keyCipher, xmlCipher, 
                                        dataEncryptionKey, keyEncryptionKey);
            Document temp = xmlCipher.doFinal(node.getOwnerDocument(), (Element) node, getSecureTagContents());
            document.importNode(temp.getDocumentElement().cloneNode(true), true);
        }    
    }

    try {
        DOMSource source = new DOMSource(document);
        InputStream sis = exchange.getContext().getTypeConverter().mandatoryConvertTo(InputStream.class, source);
        IOHelper.copy(sis, stream);
    } finally {
        stream.close();
    }
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
/**
 * Configure the public key for the asymmetric key wrap algorithm, create the key cipher, and delegate
 * to common encryption method.
 * 
 * The method first checks the exchange for a declared key alias, and will fall back to the
 * statically-defined instance variable if no value is found in the exchange. This allows different
 * aliases / keys to be used for multiple-recipient messaging integration patterns such as CBR
 * or recipient list.
 */
private void encryptAsymmetric(Exchange exchange, Document document, OutputStream stream) throws Exception {       
    String exchangeRecipientAlias = getRecipientKeyAlias(exchange);
    
    if (null == exchangeRecipientAlias) {
        throw new IllegalStateException("The  recipient's key alias must be defined for asymmetric key encryption.");
    }
    
    if (trustStore == null && null != this.keyOrTrustStoreParameters) {
        trustStore = keyOrTrustStoreParameters.createKeyStore();
        trustStorePassword = keyOrTrustStoreParameters.getPassword();
    }

    if (null == trustStore) {
        throw new IllegalStateException("A trust store must be defined for asymmetric key encryption.");
    }
    
    String password = 
        this.keyPassword != null ? this.keyPassword : this.trustStorePassword;
    Key keyEncryptionKey = getPublicKey(this.trustStore, exchangeRecipientAlias, password);
    
    if (null == keyEncryptionKey) {
        throw new IllegalStateException("No key for the alias [ " + exchangeRecipientAlias 
            + " ] exists in " + "the configured trust store.");
    }
    
    Key dataEncryptionKey = generateDataEncryptionKey();
    
    XMLCipher keyCipher;
    if (null != this.getKeyCipherAlgorithm()) {
        keyCipher = XMLCipher.getInstance(this.getKeyCipherAlgorithm(), null, digestAlgorithm);
    } else {
        keyCipher = XMLCipher.getInstance(XMLCipher.RSA_OAEP, null, digestAlgorithm);
    }
    
    keyCipher.init(XMLCipher.WRAP_MODE, keyEncryptionKey);
    encrypt(exchange, document, stream, dataEncryptionKey, keyCipher, keyEncryptionKey);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
/**
 * Method decryptData
 *
 * Take a file, find an encrypted element decrypt it and return the
 * resulting byte array
 *
 * @param filename File to decrypt from
 */
private byte[] decryptData(String filename) throws Exception {

    XMLCipher cipher;

    // Parse the document in question
    String basedir = System.getProperty("basedir");
    if (basedir != null && !"".equals(basedir)) {
        filename = basedir + "/" + filename;
    }
    File f = new File(filename);

    DocumentBuilder db = XMLUtils.createDocumentBuilder(false);
    Document doc = db.parse(new java.io.FileInputStream(f));

    // Now we have the document, lets build the XMLCipher element
    Element ee = null;

    // Create the XMLCipher element
    cipher = XMLCipher.getInstance();

    // Need to pre-load the Encrypted Data so we can get the key info
    ee = (Element) doc.getElementsByTagName("EncryptedData").item(0);
    cipher.init(XMLCipher.DECRYPT_MODE, null);
    EncryptedData encryptedData = cipher.loadEncryptedData(doc, ee);

    Key key = findKey(encryptedData);
    cipher.init(XMLCipher.DECRYPT_MODE, key);

    return cipher.decryptToByteArray(ee);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
@Override
public String encryptDocument(Key deSedeEncryptKey, String document,
                              RuleExecutionContainer ruleExecutionContainer) {
    Document xmlDocument = null;
    String xmlString = null;
    boolean encryptDoc = false;

    for (final RuleExecutionResponse response : ruleExecutionContainer
            .getExecutionResponseList()) {
        if (response.getDocumentObligationPolicy().equals(
                ObligationPolicyDocument.ENCRYPT)) {
            encryptDoc = true;
            break;
        }
    }

    if (encryptDoc) {

        try {
            xmlDocument = documentXmlConverter.loadDocument(document);

/*
             * Get a key to be used for encrypting the element. Here we are
 * generating an AES key.
 */
            final Key aesSymmetricKey = EncryptTool
                    .generateDataEncryptionKey();

            final String algorithmURI = XMLCipher.TRIPLEDES_KeyWrap;

            final XMLCipher keyCipher = XMLCipher.getInstance(algorithmURI);
            keyCipher.init(XMLCipher.WRAP_MODE, deSedeEncryptKey);
            final EncryptedKey encryptedKey = keyCipher.encryptKey(
                    xmlDocument, aesSymmetricKey);

            // encrypt the contents of the document element
            final Element rootElement = xmlDocument.getDocumentElement();

            encryptElement(xmlDocument, aesSymmetricKey, encryptedKey,
                    rootElement);

            // Output encrypted doc to file
            // FileHelper.writeDocToFile(xmlDocument, "Encrypted_C32.xml");

            xmlString = documentXmlConverter
                    .convertXmlDocToString(xmlDocument);
        } catch (final Exception e) {
            logger.error(e.getMessage(), e);
            throw new DocumentSegmentationException(e.toString(), e);
        }
    }
    return xmlString;
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
public static void main(String unused[]) throws Exception {

        Document document = createSampleDocument();

        /*
         * Get a key to be used for encrypting the element.
         * Here we are generating an AES key.
         */
        Key symmetricKey = GenerateDataEncryptionKey();

        /*
         * Get a key to be used for encrypting the symmetric key.
         * Here we are generating a DESede key.
         */
        Key kek = GenerateAndStoreKeyEncryptionKey();

        String algorithmURI = XMLCipher.TRIPLEDES_KeyWrap;

        XMLCipher keyCipher =
            XMLCipher.getInstance(algorithmURI);
        keyCipher.init(XMLCipher.WRAP_MODE, kek);
        EncryptedKey encryptedKey =
            keyCipher.encryptKey(document, symmetricKey);

        /*
         * Let us encrypt the contents of the document element.
         */
        Element rootElement = document.getDocumentElement();

        algorithmURI = XMLCipher.AES_128;

        XMLCipher xmlCipher =
            XMLCipher.getInstance(algorithmURI);
        xmlCipher.init(XMLCipher.ENCRYPT_MODE, symmetricKey);

        /*
         * Setting keyinfo inside the encrypted data being prepared.
         */
        EncryptedData encryptedData = xmlCipher.getEncryptedData();
        KeyInfo keyInfo = new KeyInfo(document);
        keyInfo.add(encryptedKey);
        encryptedData.setKeyInfo(keyInfo);

        /*
         * doFinal -
         * "true" below indicates that we want to encrypt element's content
         * and not the element itself. Also, the doFinal method would
         * modify the document by replacing the EncrypteData element
         * for the data to be encrypted.
         */
        xmlCipher.doFinal(document, rootElement, true);

        /*
         * Output the document containing the encrypted information into
         * a file.
         */
        outputDocToFile(document, "build/encryptedInfo.xml");
    }
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
@Test
public void testSEED128KW() throws Exception {
    if (!bcInstalled) {
        return;
    }
    // Read in plaintext document
    InputStream sourceDocument =
            this.getClass().getClassLoader().getResourceAsStream(
                    "ie/baltimore/merlin-examples/merlin-xmlenc-five/plaintext.xml");
    DocumentBuilder builder = XMLUtils.createDocumentBuilder(false);
    Document document = builder.parse(sourceDocument);

    // Set up the Key
    KeyGenerator keygen = KeyGenerator.getInstance("SEED");
    keygen.init(128);
    SecretKey key = keygen.generateKey();

    // Set up the Key Wrapping Key
    XMLCipher cipher = XMLCipher.getInstance(XMLCipher.SEED_128_KeyWrap);
    keygen = KeyGenerator.getInstance("SEED");
    keygen.init(128);
    SecretKey keyWrappingKey = keygen.generateKey();
    cipher.init(XMLCipher.WRAP_MODE, keyWrappingKey);
    EncryptedKey encryptedKey = cipher.encryptKey(document, key);

    // Encrypt using DOM
    List<String> localNames = new ArrayList<String>();
    localNames.add("PaymentInfo");

    String encryptionAlgorithm = XMLCipher.SEED_128;
    encrypt(encryptedKey, encryptionAlgorithm, document, localNames, key);

    // Check the CreditCard encrypted ok
    NodeList nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 0);

    // XMLUtils.outputDOM(document, System.out);

    // Convert Document to a Stream Reader
    javax.xml.transform.Transformer transformer = transformerFactory.newTransformer();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    transformer.transform(new DOMSource(document), new StreamResult(baos));
    final XMLStreamReader xmlStreamReader =
            xmlInputFactory.createXMLStreamReader(new ByteArrayInputStream(baos.toByteArray()));

    // Decrypt
    XMLSecurityProperties properties = new XMLSecurityProperties();
    properties.setDecryptionKey(keyWrappingKey);
    InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
    TestSecurityEventListener securityEventListener = new TestSecurityEventListener();
    XMLStreamReader securityStreamReader =
            inboundXMLSec.processInMessage(xmlStreamReader, null, securityEventListener);

    document = StAX2DOM.readDoc(XMLUtils.createDocumentBuilder(false), securityStreamReader);

    // Check the CreditCard decrypted ok
    nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 1);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
@org.junit.Test
public void testSEED128KW() throws Exception {
    if (!bcInstalled) {
        return;
    }
    // Read in plaintext document
    InputStream sourceDocument =
            this.getClass().getClassLoader().getResourceAsStream(
                    "ie/baltimore/merlin-examples/merlin-xmlenc-five/plaintext.xml");
    DocumentBuilder builder = XMLUtils.createDocumentBuilder(false);
    Document document = builder.parse(sourceDocument);

    // Set up the Key
    KeyGenerator keygen = KeyGenerator.getInstance("SEED");
    keygen.init(128);
    SecretKey key = keygen.generateKey();

    // Set up the Key Wrapping Key
    XMLCipher cipher = XMLCipher.getInstance(XMLCipher.SEED_128_KeyWrap);
    keygen = KeyGenerator.getInstance("SEED");
    keygen.init(128);
    SecretKey keyWrappingKey = keygen.generateKey();
    cipher.init(XMLCipher.WRAP_MODE, keyWrappingKey);
    EncryptedKey encryptedKey = cipher.encryptKey(document, key);

    List<String> localNames = new ArrayList<String>();
    localNames.add("PaymentInfo");

    String encryptionAlgorithm = XMLCipher.SEED_128;

    encrypt(encryptedKey, encryptionAlgorithm, document, localNames, key);

    // Check the CreditCard encrypted ok
    NodeList nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 0);

    // XMLUtils.outputDOM(document, System.out);
    document = decrypt(document, keyWrappingKey);

    // Check the CreditCard decrypted ok
    nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 1);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
@Test
public void testTripleDESKW() throws Exception {
    // Read in plaintext document
    InputStream sourceDocument =
            this.getClass().getClassLoader().getResourceAsStream(
                    "ie/baltimore/merlin-examples/merlin-xmlenc-five/plaintext.xml");
    DocumentBuilder builder = XMLUtils.createDocumentBuilder(false);
    Document document = builder.parse(sourceDocument);

    // Set up the Key
    KeyGenerator keygen = KeyGenerator.getInstance("DESede");
    SecretKey key = keygen.generateKey();

    // Set up the Key Wrapping Key
    XMLCipher cipher = XMLCipher.getInstance(XMLCipher.TRIPLEDES_KeyWrap);
    keygen = KeyGenerator.getInstance("DESede");
    SecretKey keyWrappingKey = keygen.generateKey();
    cipher.init(XMLCipher.WRAP_MODE, keyWrappingKey);
    EncryptedKey encryptedKey = cipher.encryptKey(document, key);

    // Encrypt using DOM
    List<String> localNames = new ArrayList<String>();
    localNames.add("PaymentInfo");

    String encryptionAlgorithm = XMLCipher.TRIPLEDES;
    encrypt(encryptedKey, encryptionAlgorithm, document, localNames, key);

    // Check the CreditCard encrypted ok
    NodeList nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 0);

    // XMLUtils.outputDOM(document, System.out);

    // Convert Document to a Stream Reader
    javax.xml.transform.Transformer transformer = transformerFactory.newTransformer();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    transformer.transform(new DOMSource(document), new StreamResult(baos));
    final XMLStreamReader xmlStreamReader =
            xmlInputFactory.createXMLStreamReader(new ByteArrayInputStream(baos.toByteArray()));

    // Decrypt
    XMLSecurityProperties properties = new XMLSecurityProperties();
    properties.setDecryptionKey(keyWrappingKey);
    InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
    TestSecurityEventListener securityEventListener = new TestSecurityEventListener();
    XMLStreamReader securityStreamReader =
            inboundXMLSec.processInMessage(xmlStreamReader, null, securityEventListener);

    document = StAX2DOM.readDoc(XMLUtils.createDocumentBuilder(false), securityStreamReader);

    // Check the CreditCard decrypted ok
    nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 1);
}
 

import org.apache.xml.security.encryption.XMLCipher; //导入方法依赖的package包/类
@Test
public void testRSAv15KW() throws Exception {
    // Read in plaintext document
    InputStream sourceDocument =
            this.getClass().getClassLoader().getResourceAsStream(
                    "ie/baltimore/merlin-examples/merlin-xmlenc-five/plaintext.xml");
    DocumentBuilder builder = XMLUtils.createDocumentBuilder(false);
    Document document = builder.parse(sourceDocument);

    // Set up the Key
    KeyGenerator keygen = KeyGenerator.getInstance("DESede");
    SecretKey key = keygen.generateKey();

    // Set up the Key Wrapping Key
    XMLCipher cipher = XMLCipher.getInstance(XMLCipher.RSA_v1dot5);
    Key keyWrappingKey = rsaKeyPair.getPublic();
    cipher.init(XMLCipher.WRAP_MODE, keyWrappingKey);
    EncryptedKey encryptedKey = cipher.encryptKey(document, key);

    // Encrypt using DOM
    List<String> localNames = new ArrayList<String>();
    localNames.add("PaymentInfo");

    String encryptionAlgorithm = XMLCipher.TRIPLEDES;
    encrypt(encryptedKey, encryptionAlgorithm, document, localNames, key);

    // Check the CreditCard encrypted ok
    NodeList nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 0);

    // XMLUtils.outputDOM(document, System.out);

    // Convert Document to a Stream Reader
    javax.xml.transform.Transformer transformer = transformerFactory.newTransformer();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    transformer.transform(new DOMSource(document), new StreamResult(baos));
    final XMLStreamReader xmlStreamReader =
            xmlInputFactory.createXMLStreamReader(new ByteArrayInputStream(baos.toByteArray()));

    // Decrypt
    XMLSecurityProperties properties = new XMLSecurityProperties();
    properties.setDecryptionKey(rsaKeyPair.getPrivate());
    InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
    TestSecurityEventListener securityEventListener = new TestSecurityEventListener();
    XMLStreamReader securityStreamReader =
            inboundXMLSec.processInMessage(xmlStreamReader, null, securityEventListener);

    document = StAX2DOM.readDoc(XMLUtils.createDocumentBuilder(false), securityStreamReader);

    // Check the CreditCard decrypted ok
    nodeList = document.getElementsByTagNameNS("urn:example:po", "CreditCard");
    Assert.assertEquals(nodeList.getLength(), 1);
}