Java WSSConfig.getNewInstance方法代码示例

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * A unit test for creating BinarySecurityTokens
 */
public void testCreateBinarySecurityToken() throws Exception {
    SOAPEnvelope unsignedEnvelope = message.getSOAPEnvelope();
    Document doc = unsignedEnvelope.getAsDocument();
    WSSConfig.getNewInstance();

    WSSecHeader secHeader = new WSSecHeader();
    secHeader.insertSecurityHeader(doc);
    
    BinarySecurity bst = new BinarySecurity(doc);
    bst.setValueType(AP_REQ);
    bst.setEncodingType(BASE64_NS);
    bst.setToken("12345678".getBytes());
    WSSecurityUtil.prependChildElement(secHeader.getSecurityHeader(), bst.getElement());
    
    if (LOG.isDebugEnabled()) {
        String outputString = 
            org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(doc);
        LOG.debug(outputString);
    }
    
    assertTrue(AP_REQ.equals(bst.getValueType()));
    assertTrue(BASE64_NS.equals(bst.getEncodingType()));
    assertTrue(bst.getToken() != null);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * Test that signs and verifies a WS-Security envelope
 * <p/>
 * 
 * @throws java.lang.Exception Thrown when there is any problem in signing or verification
 */
public void testSignatureInclusivePrefixes() throws Exception {
    WSSConfig wssConfig = WSSConfig.getNewInstance();
    wssConfig.setWsiBSPCompliant(true);
    WSSecSignature builder = new WSSecSignature();
    builder.setWsConfig(wssConfig);
    builder.setUserInfo("16c73ab6-b892-458f-abf5-2f875f74882e", "security");
    LOG.info("Before Signing....");
    Document doc = unsignedEnvelope.getAsDocument();
    WSSecHeader secHeader = new WSSecHeader();
    secHeader.insertSecurityHeader(doc);
    Document signedDoc = builder.build(doc, crypto, secHeader);

    if (LOG.isDebugEnabled()) {
        LOG.debug("After Signing....");
        String outputString = 
            org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(signedDoc);
        LOG.debug(outputString);
    }
    
    verify(signedDoc);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * A unit test for {@link WSHandler#getPassword(String, int, String, String, RequestData)},
 * where the password is obtained from the Message Context.
 */
public void
testGetPasswordRequestContextUnit() throws Exception {
    
    final WSSConfig cfg = WSSConfig.getNewInstance();
    final RequestData reqData = new RequestData();
    reqData.setWssConfig(cfg);
    java.util.Map messageContext = new java.util.TreeMap();
    messageContext.put("password", "securityPassword");
    reqData.setMsgContext(messageContext);
    
    WSHandler handler = new MyHandler();
    WSPasswordCallback callback = 
        handler.getPassword(
            "bob", 
            WSConstants.UT, 
            "SomeCallbackTag", 
            "SomeCallbackRef",
            reqData
        );
    assertTrue("bob".equals(callback.getIdentifier()));
    assertTrue("securityPassword".equals(callback.getPassword()));
    assertTrue(WSPasswordCallback.USERNAME_TOKEN == callback.getUsage());
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * Test to see that a custom action configured through a
 * WSSConfig instance is called
 */
public void
testCustomAction() throws Exception {
    
    final WSSConfig cfg = WSSConfig.getNewInstance();
    final int action = 0xDEADF000;
    cfg.setAction(action, "wssec.MyAction");
    final RequestData reqData = new RequestData();
    reqData.setWssConfig(cfg);
    reqData.setMsgContext(new java.util.TreeMap());
    
    final java.util.Vector actions = new java.util.Vector();
    actions.add(new Integer(action));
    final Document doc = unsignedEnvelope.getAsDocument();
    MyHandler handler = new MyHandler();
    reqData.setMsgContext("bread");
    assertEquals(reqData.getMsgContext(), "bread");
    handler.doit(
        action, 
        doc, 
        reqData, 
        actions
    );
    assertEquals(reqData.getMsgContext(), "crumb");
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * A test for signing a Kerberos BST
 */
public void testSignBST() throws Exception {
    SOAPEnvelope unsignedEnvelope = message.getSOAPEnvelope();
    Document doc = unsignedEnvelope.getAsDocument();
    WSSConfig.getNewInstance();

    WSSecHeader secHeader = new WSSecHeader();
    secHeader.insertSecurityHeader(doc);
    
    BinarySecurity bst = new BinarySecurity(doc);
    bst.setValueType(AP_REQ);
    bst.setEncodingType(BASE64_NS);
    bst.setToken("12345678".getBytes());
    bst.setID("Id-" + bst.hashCode());
    WSSecurityUtil.prependChildElement(secHeader.getSecurityHeader(), bst.getElement());
    
    WSSecSignature sign = new WSSecSignature();
    sign.setUserInfo("16c73ab6-b892-458f-abf5-2f875f74882e", "security");
    sign.setKeyIdentifierType(WSConstants.ISSUER_SERIAL);
    
    Vector parts = new Vector();
    WSEncryptionPart encP =
        new WSEncryptionPart(bst.getID());
    parts.add(encP);
    sign.setParts(parts);
    
    Document signedDoc = sign.build(doc, crypto, secHeader);
    
    if (LOG.isDebugEnabled()) {
        String outputString = 
            org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(signedDoc);
        LOG.debug(outputString);
    }
    
    verify(signedDoc);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * A test for signing a Kerberos BST as well as a Timestamp
 */
public void testSignBSTTimestamp() throws Exception {
    SOAPEnvelope unsignedEnvelope = message.getSOAPEnvelope();
    Document doc = unsignedEnvelope.getAsDocument();
    WSSConfig.getNewInstance();

    WSSecHeader secHeader = new WSSecHeader();
    secHeader.insertSecurityHeader(doc);
    
    BinarySecurity bst = new BinarySecurity(doc);
    bst.setValueType(AP_REQ);
    bst.setEncodingType(BASE64_NS);
    bst.setToken("12345678".getBytes());
    bst.setID("Id-" + bst.hashCode());
    WSSecurityUtil.prependChildElement(secHeader.getSecurityHeader(), bst.getElement());
    
    WSSecTimestamp timestamp = new WSSecTimestamp();
    timestamp.setTimeToLive(600);
    timestamp.build(doc, secHeader);
    
    WSSecSignature sign = new WSSecSignature();
    sign.setUserInfo("16c73ab6-b892-458f-abf5-2f875f74882e", "security");
    sign.setKeyIdentifierType(WSConstants.ISSUER_SERIAL);
    
    Vector parts = new Vector();
    parts.add(new WSEncryptionPart(bst.getID()));
    parts.add(new WSEncryptionPart(timestamp.getId()));
    sign.setParts(parts);
    
    Document signedDoc = sign.build(doc, crypto, secHeader);
    
    if (LOG.isDebugEnabled()) {
        String outputString = 
            org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(signedDoc);
        LOG.debug(outputString);
    }
    
    verify(signedDoc);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * Test with a null password type. This will pass as the WSSConfig is configured to 
 * handle custom token types.
 */
public void testUsernameTokenCustomPass() throws Exception {
    WSSecUsernameToken builder = new WSSecUsernameToken();
    builder.setPasswordType(null);
    builder.setUserInfo("customUser", null);
    
    Document doc = unsignedEnvelope.getAsDocument();
    WSSecHeader secHeader = new WSSecHeader();
    secHeader.insertSecurityHeader(doc);
    Document signedDoc = builder.build(doc, secHeader);
    
    if (LOG.isDebugEnabled()) {
        LOG.debug("Message with UserNameToken PW Text:");
        String outputString = 
            org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(signedDoc);
        LOG.debug(outputString);
    }
    
    //
    // Configure so that custom token types are accepted
    //
    WSSConfig cfg = WSSConfig.getNewInstance();
    cfg.setHandleCustomPasswordTypes(true);
    secEngine.setWssConfig(cfg);
    verify(signedDoc);
    
    //
    // Go back to default for other tests
    //
    cfg.setHandleCustomPasswordTypes(false);
    secEngine.setWssConfig(cfg);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * Test that encrypts using EncryptedKeySHA1, where it uses a symmetric key, rather than a 
 * generated session key which is then encrypted using a public key. The request is generated
 * using WSHandler, instead of coding it.
 * 
 * @throws java.lang.Exception Thrown when there is any problem in encryption or decryption
 * 
 */
public void testEncryptionSHA1SymmetricBytesHandler() throws Exception {
    final WSSConfig cfg = WSSConfig.getNewInstance();
    final RequestData reqData = new RequestData();
    reqData.setWssConfig(cfg);
    java.util.Map messageContext = new java.util.TreeMap();
    messageContext.put(WSHandlerConstants.ENC_SYM_ENC_KEY, "false");
    messageContext.put(WSHandlerConstants.ENC_KEY_ID, "EncryptedKeySHA1");
    messageContext.put(WSHandlerConstants.PW_CALLBACK_REF, this);
    reqData.setMsgContext(messageContext);
    reqData.setUsername("");
    
    final java.util.Vector actions = new java.util.Vector();
    actions.add(new Integer(WSConstants.ENCR));
    
    Document doc = unsignedEnvelope.getAsDocument();
    MyHandler handler = new MyHandler();
    handler.send(
        WSConstants.ENCR, 
        doc, 
        reqData, 
        actions,
        true
    );
    
    String outputString = 
        org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(doc);
    if (LOG.isDebugEnabled()) {
        LOG.debug(outputString);
    }
    
    verify(doc);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * A WSHandler test for {@link WSHandler#getPassword(String, int, String, String, RequestData)},
 * where the password is obtained from the Message Context.
 */
public void
testGetPasswordRequestContext() throws Exception {
    
    final WSSConfig cfg = WSSConfig.getNewInstance();
    final RequestData reqData = new RequestData();
    reqData.setWssConfig(cfg);
    reqData.setUsername("bob");
    reqData.setPwType(WSConstants.PASSWORD_TEXT);
    java.util.Map messageContext = new java.util.TreeMap();
    messageContext.put("password", "securityPassword");
    reqData.setMsgContext(messageContext);
    
    final java.util.Vector actions = new java.util.Vector();
    actions.add(new Integer(WSConstants.UT));
    Document doc = unsignedEnvelope.getAsDocument();
    MyHandler handler = new MyHandler();
    handler.doit(
        WSConstants.UT, 
        doc, 
        reqData, 
        actions
    );
    
    String outputString = 
        org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(doc);
    if (LOG.isDebugEnabled()) {
        LOG.debug(outputString);
    }
    assertTrue(outputString.indexOf("bob") != -1);
    assertTrue(outputString.indexOf("securityPassword") != -1);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * A test for {@link WSHandler#getPassword(String, int, String, String, RequestData)},
 * where the password is obtained from a Callback Handler, which is placed on the 
 * Message Context using a reference.
 */
public void
testGetPasswordCallbackHandlerRef() throws Exception {
    
    final WSSConfig cfg = WSSConfig.getNewInstance();
    final RequestData reqData = new RequestData();
    reqData.setWssConfig(cfg);
    reqData.setUsername("bob");
    reqData.setPwType(WSConstants.PASSWORD_TEXT);
    java.util.Map messageContext = new java.util.TreeMap();
    messageContext.put(
        WSHandlerConstants.PW_CALLBACK_REF, 
        new MyCallbackHandler()
    );
    reqData.setMsgContext(messageContext);
    
    final java.util.Vector actions = new java.util.Vector();
    actions.add(new Integer(WSConstants.UT));
    Document doc = unsignedEnvelope.getAsDocument();
    MyHandler handler = new MyHandler();
    handler.doit(
        WSConstants.UT, 
        doc, 
        reqData, 
        actions
    );
    
    String outputString = 
        org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(doc);
    if (LOG.isDebugEnabled()) {
        LOG.debug(outputString);
    }
    assertTrue(outputString.indexOf("bob") != -1);
    assertTrue(outputString.indexOf("securityPassword") != -1);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * A test for {@link WSHandler#getPassword(String, int, String, String, RequestData)},
 * where the password is obtained from a Callback Handler, which is placed on the 
 * Message Context using a reference.
 */
public void
testMessageContextRef() throws Exception {
    
    final WSSConfig cfg = WSSConfig.getNewInstance();
    final RequestData reqData = new RequestData();
    reqData.setWssConfig(cfg);
    reqData.setUsername("bob");
    reqData.setPwType(WSConstants.PASSWORD_TEXT);
    java.util.Map messageContext = new java.util.TreeMap();
    messageContext.put(
        WSHandlerConstants.PW_CALLBACK_REF, 
        new MyCallbackHandler()
    );
    reqData.setMsgContext(messageContext);
    
    final java.util.Vector actions = new java.util.Vector();
    actions.add(new Integer(WSConstants.UT));
    Document doc = unsignedEnvelope.getAsDocument();
    MyHandler handler = new MyHandler();
    handler.send(
        WSConstants.UT, 
        doc, 
        reqData, 
        actions,
        true
    );
    
    String outputString = 
        org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(doc);
    if (LOG.isDebugEnabled()) {
        LOG.debug(outputString);
    }
    assertTrue(outputString.indexOf("bob") != -1);
    assertTrue(outputString.indexOf("securityPassword") != -1);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * Test to see that a custom processor (object) configured through a 
 * WSSConfig instance is called
 */
public void 
testCustomUserProcessorObject() throws Exception {
    WSSecSignature builder = new WSSecSignature();
    builder.setUserInfo("16c73ab6-b892-458f-abf5-2f875f74882e", "security");
    builder.setKeyIdentifierType(WSConstants.ISSUER_SERIAL);
    LOG.info("Before Signing IS....");
    Document doc = unsignedEnvelope.getAsDocument();
    WSSecHeader secHeader = new WSSecHeader();
    secHeader.insertSecurityHeader(doc);
    Document signedDoc = builder.build(doc, crypto, secHeader);

    if (LOG.isDebugEnabled()) {
        LOG.debug("Signed message with IssuerSerial key identifier:");
        String outputString = 
            org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(signedDoc);
        LOG.debug(outputString);
    }
    LOG.info("After Signing IS....");
    //
    // Check to make sure we can install/replace and use our own processor
    //
    WSSConfig cfg = WSSConfig.getNewInstance();
    cfg.setProcessor(
        WSSecurityEngine.SIGNATURE,
        new wssec.MyProcessor()
    );
    final WSSecurityEngine engine = new WSSecurityEngine();
    engine.setWssConfig(cfg);
    final java.util.List results = 
        engine.processSecurityHeader(doc, null, null, crypto);
    boolean found = false;
    for (final java.util.Iterator pos = results.iterator();  pos.hasNext(); ) {
        final java.util.Map result = (java.util.Map) pos.next();
        Object obj = result.get("foo");
        if (obj != null) {
            if (obj.getClass().getName().equals(wssec.MyProcessor.class.getName())) {
                found = true;
            }
        }
    }
    assertTrue("Unable to find result from MyProcessor", found);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * Test that uses a 32 byte key length for the secret key, instead of the default 16 bytes.
 */
public void testWSS226() throws Exception {
    Document doc = unsignedEnvelope.getAsDocument();

    WSSecHeader secHeader = new WSSecHeader();
    secHeader.insertSecurityHeader(doc);

    WSSecUsernameToken builder = new WSSecUsernameToken();
    builder.setPasswordType(WSConstants.PASSWORD_TEXT);
    builder.setUserInfo("wernerd", "verySecret");
    builder.addCreated();
    builder.setSecretKeyLength(32);
    builder.addNonce();
    builder.prepare(doc);
    
    WSSecSignature sign = new WSSecSignature();
    sign.setUsernameToken(builder);
    sign.setKeyIdentifierType(WSConstants.UT_SIGNING);
    sign.setSignatureAlgorithm(XMLSignature.ALGO_ID_MAC_HMAC_SHA1);
    LOG.info("Before signing with UT text....");
    sign.build(doc, null, secHeader);
    LOG.info("Before adding UsernameToken PW Text....");
    builder.prependToHeader(secHeader);
    Document signedDoc = doc;
    if (LOG.isDebugEnabled()) {
        LOG.debug("Message using a 32 byte key length:");
        String outputString = 
            org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(signedDoc);
        LOG.debug(outputString);
    }
    
    //
    // It should fail on the default key length of 16...
    //
    try {
        secEngine.processSecurityHeader(doc, null, this, null);
        fail ("An error was expected on verifying the signature");
    } catch (Exception ex) {
        // expected
    }
    
    WSSecurityEngine wss226SecurityEngine = new WSSecurityEngine();
    WSSConfig wssConfig = WSSConfig.getNewInstance();
    wssConfig.setSecretKeyLength(32);
    wss226SecurityEngine.setWssConfig(wssConfig);
    wss226SecurityEngine.processSecurityHeader(doc, null, this, null);
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * Test involving adding a Username Token to a SOAP message and signing it, where the
 * private key for signature is extracted from the KeyStore using a different username/alias
 * to the UsernameToken. 
 */
public void 
testUsernameTokenSignatureHandler() throws Exception {
    final WSSConfig cfg = WSSConfig.getNewInstance();
    final RequestData reqData = new RequestData();
    reqData.setWssConfig(cfg);
    reqData.setUsername("alice");
    reqData.setPwType(WSConstants.PASSWORD_DIGEST);
    java.util.Map messageContext = new java.util.TreeMap();
    messageContext.put(
        WSHandlerConstants.PW_CALLBACK_REF, 
        this
    );
    messageContext.put(WSHandlerConstants.SIGNATURE_USER, "wss86");
    messageContext.put(WSHandlerConstants.SIG_PROP_FILE, "wss86.properties");
    messageContext.put(
        WSHandlerConstants.SIGNATURE_PARTS, 
        "{}{" + WSConstants.WSSE_NS + "}" + "UsernameToken"
    );
    messageContext.put(WSHandlerConstants.SIG_KEY_ID, "DirectReference");
    reqData.setMsgContext(messageContext);
    
    final java.util.Vector actions = new java.util.Vector();
    actions.add(new Integer(WSConstants.UT));
    actions.add(new Integer(WSConstants.SIGN));
    final Document doc = unsignedEnvelope.getAsDocument();
    MyHandler handler = new MyHandler();
    handler.send(
        WSConstants.UT | WSConstants.SIGN, 
        doc, 
        reqData, 
        actions,
        true
    );
    
    if (LOG.isDebugEnabled()) {
        LOG.debug("After Signing....");
        String outputString = 
            org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(doc);
        LOG.debug(outputString);
    }
    
    verify(doc);
    
}
 

import org.apache.ws.security.WSSConfig; //导入方法依赖的package包/类
/**
 * A test for WSS-62: "the crypto file not being retrieved in the doReceiverAction
 * method for the Saml Signed Token"
 * 
 * https://issues.apache.org/jira/browse/WSS-62
 */
public void testWSS62() throws Exception {
    SOAPEnvelope unsignedEnvelope = message.getSOAPEnvelope();
    SAMLIssuer saml = SAMLIssuerFactory.getInstance("saml.properties");

    SAMLAssertion assertion = saml.newAssertion();

    String issuerKeyName = saml.getIssuerKeyName();
    String issuerKeyPW = saml.getIssuerKeyPassword();
    Crypto issuerCrypto = saml.getIssuerCrypto();
    WSSecSignatureSAML wsSign = new WSSecSignatureSAML();
    wsSign.setKeyIdentifierType(WSConstants.BST_DIRECT_REFERENCE);
    
    Document doc = unsignedEnvelope.getAsDocument();

    WSSecHeader secHeader = new WSSecHeader();
    secHeader.insertSecurityHeader(doc);
    
    Document signedDoc = 
        wsSign.build(doc, null, assertion, issuerCrypto, issuerKeyName, issuerKeyPW, secHeader);
    
    //
    // Now verify it but first call Handler#doReceiverAction
    //
    final WSSConfig cfg = WSSConfig.getNewInstance();
    final RequestData reqData = new RequestData();
    reqData.setWssConfig(cfg);
    reqData.setMsgContext(new java.util.TreeMap());
    java.util.Map msgContext = new java.util.HashMap();
    msgContext.put(WSHandlerConstants.SIG_PROP_FILE, "crypto.properties");
    reqData.setMsgContext(msgContext);
    
    MyHandler handler = new MyHandler();
    handler.doit(WSConstants.ST_SIGNED, reqData);
    
    secEngine.processSecurityHeader(
        signedDoc, null, this, reqData.getSigCrypto(), reqData.getDecCrypto()
    );
    
    //
    // Negative test
    //
    msgContext.put(WSHandlerConstants.SIG_PROP_FILE, "crypto.properties.na");
    reqData.setMsgContext(msgContext);
    
    handler = new MyHandler();
    try {
        handler.doit(WSConstants.ST_SIGNED, reqData);
        fail("Failure expected on a bad crypto properties file");
    } catch (RuntimeException ex) {
        // expected
    }
}