test/wssec/TestWSSecurityNew3.java - ws-wss4j - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements. See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership. The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package wssec;

 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 import org.apache.axis.Message;
 import org.apache.axis.MessageContext;
 import org.apache.axis.client.AxisClient;
 import org.apache.axis.configuration.NullProvider;
 import org.apache.axis.message.SOAPEnvelope;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.ws.security.WSConstants;
 import org.apache.ws.security.WSEncryptionPart;
 import org.apache.ws.security.WSPasswordCallback;
 import org.apache.ws.security.WSSConfig;
 import org.apache.ws.security.WSSecurityEngine;
 import org.apache.ws.security.handler.RequestData;
 import org.apache.ws.security.handler.WSHandlerConstants;
 import org.apache.ws.security.components.crypto.Crypto;
 import org.apache.ws.security.components.crypto.CryptoFactory;
 import org.apache.ws.security.message.WSSecSignature;
 import org.apache.ws.security.message.WSSecHeader;
 import org.apache.ws.security.message.WSSecTimestamp;
 import org.w3c.dom.Document;

 import javax.security.auth.callback.Callback;
 import javax.security.auth.callback.CallbackHandler;
 import javax.security.auth.callback.UnsupportedCallbackException;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Vector;

 /**
  * WS-Security Test Case
  * <p/>
  *
  * @author Davanum Srinivas (dims@yahoo.com)
  */
 public class TestWSSecurityNew3 extends TestCase implements CallbackHandler {
     private static final Log LOG = LogFactory.getLog(TestWSSecurityNew3.class);
     private static final String SOAPMSG =
         "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
         + "<SOAP-ENV:Envelope "
         +   "xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\" "
         +   "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" "
         +   "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
         +   "<SOAP-ENV:Body>"
         +       "<add xmlns=\"http://ws.apache.org/counter/counter_port_type\">"
         +           "<value xmlns=\"\">15</value>"
         +       "</add>"
         +   "</SOAP-ENV:Body>"
         + "</SOAP-ENV:Envelope>";

     private WSSecurityEngine secEngine = new WSSecurityEngine();
     private Crypto crypto = CryptoFactory.getInstance();
     private MessageContext msgContext;
     private SOAPEnvelope unsignedEnvelope;

     /**
      * TestWSSecurity constructor
      * <p/>
      *
      * @param name name of the test
      */
     public TestWSSecurityNew3(String name) {
         super(name);
     }

     /**
      * JUnit suite
      * <p/>
      *
      * @return a junit test suite
      */
     public static Test suite() {
         return new TestSuite(TestWSSecurityNew3.class);
     }

     /**
      * Setup method
      * <p/>
      *
      * @throws java.lang.Exception Thrown when there is a problem in setup
      */
     protected void setUp() throws Exception {
         AxisClient tmpEngine = new AxisClient(new NullProvider());
         msgContext = new MessageContext(tmpEngine);
         unsignedEnvelope = getSOAPEnvelope();
     }

     /**
      * Constructs a soap envelope
      * <p/>
      *
      * @return soap envelope
      * @throws java.lang.Exception if there is any problem constructing the soap envelope
      */
     protected SOAPEnvelope getSOAPEnvelope() throws Exception {
         InputStream in = new ByteArrayInputStream(SOAPMSG.getBytes());
         Message msg = new Message(in);
         msg.setMessageContext(msgContext);
         return msg.getSOAPEnvelope();
     }

     /**
      * 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 testIssuerSerialSignature() throws Exception {
         WSSecSignature builder = new WSSecSignature();
         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);
     }

     /**
      * 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 testBSTSignature() throws Exception {
         WSSecSignature builder = new WSSecSignature();
         builder.setUserInfo("16c73ab6-b892-458f-abf5-2f875f74882e", "security");
         builder.setKeyIdentifierType(WSConstants.BST_DIRECT_REFERENCE);
         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);
     }

     /**
      * 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 testBSTPKIPathSignature() throws Exception {
         WSSecSignature builder = new WSSecSignature();
         builder.setUserInfo("wss40", "security");
         builder.setKeyIdentifierType(WSConstants.BST_DIRECT_REFERENCE);
         builder.setUseSingleCertificate(false);
         LOG.info("Before Signing....");
         Document doc = unsignedEnvelope.getAsDocument();
         WSSecHeader secHeader = new WSSecHeader();
         secHeader.insertSecurityHeader(doc);

         Crypto pkiCrypto = CryptoFactory.getInstance("wss40.properties");
         Document signedDoc = builder.build(doc, pkiCrypto, secHeader);

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

         secEngine.processSecurityHeader(doc, null, this, pkiCrypto, null);
     }

     /**
      * 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);
     }

     /**
      * This test adds a Timestamp to the security header, and then signs it, and appends
      * the signature element after the Timestamp in the header.
      * @throws Exception
      */
     public void testSignedTimestamp() throws Exception {
         Document doc = unsignedEnvelope.getAsDocument();
         WSSecHeader secHeader = new WSSecHeader();
         secHeader.insertSecurityHeader(doc);

         WSSecTimestamp timestamp = new WSSecTimestamp();
         timestamp.setTimeToLive(300);
         Document createdDoc = timestamp.build(doc, secHeader);

         java.util.Vector parts = new java.util.Vector();
         WSEncryptionPart encP =
             new WSEncryptionPart(
                 "Timestamp",
                 WSConstants.WSU_NS,
                 "");
         parts.add(encP);

         WSSecSignature builder = new WSSecSignature();
         builder.setUserInfo("16c73ab6-b892-458f-abf5-2f875f74882e", "security");
         builder.prepare(createdDoc, crypto, secHeader);
         builder.addReferencesToSign(parts, secHeader);
         builder.appendToHeader(secHeader);
         builder.computeSignature();

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

         verify(doc);
     }

     /**
      * A test for "There is an issue with the position of the <Timestamp> element in the
      * <Security> header when using WSS4J calling .NET Web Services with WS-Security."
      */
     public void testWSS231() throws Exception {
         final WSSConfig cfg = WSSConfig.getNewInstance();
         final int action = WSConstants.SIGN | WSConstants.TS;
         final RequestData reqData = new RequestData();
         reqData.setWssConfig(cfg);
         reqData.setUsername("16c73ab6-b892-458f-abf5-2f875f74882e");

         java.util.Map config = new java.util.TreeMap();
         config.put(WSHandlerConstants.SIG_PROP_FILE, "crypto.properties");
         config.put("password", "security");
         config.put(
                 WSHandlerConstants.SIGNATURE_PARTS, "{}{" + WSConstants.WSU_NS + "}Timestamp"
         );
         reqData.setMsgContext(config);

         final Vector actions = new Vector();
         actions.add(new Integer(WSConstants.SIGN));
         actions.add(new Integer(WSConstants.TS));
         final Document doc = unsignedEnvelope.getAsDocument();
         MyHandler handler = new MyHandler();
         handler.send(
                 action,
                 doc,
                 reqData,
                 actions,
                 true
         );
         String outputString =
                 org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(doc);
         if (LOG.isDebugEnabled()) {
             LOG.debug("Signed message:");
             LOG.debug(outputString);
         }

         Vector results = verify(doc);
         assertTrue(handler.checkResults(results, actions));
     }

     /**
      * Verifies the soap envelope
      * <p/>
      *
      * @param env soap envelope
      * @throws java.lang.Exception Thrown when there is a problem in verification
      */
     private Vector verify(Document doc) throws Exception {
         return secEngine.processSecurityHeader(doc, null, this, crypto, null);
     }

     public void handle(Callback[] callbacks)
         throws IOException, UnsupportedCallbackException {
         for (int i = 0; i < callbacks.length; i++) {
             if (callbacks[i] instanceof WSPasswordCallback) {
                 WSPasswordCallback pc = (WSPasswordCallback) callbacks[i];
                 /*
                  * here call a function/method to lookup the password for
                  * the given identifier (e.g. a user name or keystore alias)
                  * e.g.: pc.setPassword(passStore.getPassword(pc.getIdentfifier))
                  * for Testing we supply a fixed name here.
                  */
                 pc.setPassword("security");
             } else {
                 throw new UnsupportedCallbackException(callbacks[i], "Unrecognized Callback");
             }
         }
     }
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package wssec;

	import junit.framework.Test;
	import junit.framework.TestCase;
	import junit.framework.TestSuite;
	import org.apache.axis.Message;
	import org.apache.axis.MessageContext;
	import org.apache.axis.client.AxisClient;
	import org.apache.axis.configuration.NullProvider;
	import org.apache.axis.message.SOAPEnvelope;
	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;
	import org.apache.ws.security.WSConstants;
	import org.apache.ws.security.WSEncryptionPart;
	import org.apache.ws.security.WSPasswordCallback;
	import org.apache.ws.security.WSSConfig;
	import org.apache.ws.security.WSSecurityEngine;
	import org.apache.ws.security.handler.RequestData;
	import org.apache.ws.security.handler.WSHandlerConstants;
	import org.apache.ws.security.components.crypto.Crypto;
	import org.apache.ws.security.components.crypto.CryptoFactory;
	import org.apache.ws.security.message.WSSecSignature;
	import org.apache.ws.security.message.WSSecHeader;
	import org.apache.ws.security.message.WSSecTimestamp;
	import org.w3c.dom.Document;

	import javax.security.auth.callback.Callback;
	import javax.security.auth.callback.CallbackHandler;
	import javax.security.auth.callback.UnsupportedCallbackException;
	import java.io.ByteArrayInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.util.Vector;

	/**
	* WS-Security Test Case
	* <p/>
	*
	* @author Davanum Srinivas (dims@yahoo.com)
	*/
	public class TestWSSecurityNew3 extends TestCase implements CallbackHandler {
	private static final Log LOG = LogFactory.getLog(TestWSSecurityNew3.class);
	private static final String SOAPMSG =
	"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
	+ "<SOAP-ENV:Envelope "
	+ "xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\" "
	+ "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" "
	+ "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"
	+ "<SOAP-ENV:Body>"
	+ "<add xmlns=\"http://ws.apache.org/counter/counter_port_type\">"
	+ "<value xmlns=\"\">15</value>"
	+ "</add>"
	+ "</SOAP-ENV:Body>"
	+ "</SOAP-ENV:Envelope>";

	private WSSecurityEngine secEngine = new WSSecurityEngine();
	private Crypto crypto = CryptoFactory.getInstance();
	private MessageContext msgContext;
	private SOAPEnvelope unsignedEnvelope;

	/**
	* TestWSSecurity constructor
	* <p/>
	*
	* @param name name of the test
	*/
	public TestWSSecurityNew3(String name) {
	super(name);
	}

	/**
	* JUnit suite
	* <p/>
	*
	* @return a junit test suite
	*/
	public static Test suite() {
	return new TestSuite(TestWSSecurityNew3.class);
	}

	/**
	* Setup method
	* <p/>
	*
	* @throws java.lang.Exception Thrown when there is a problem in setup
	*/
	protected void setUp() throws Exception {
	AxisClient tmpEngine = new AxisClient(new NullProvider());
	msgContext = new MessageContext(tmpEngine);
	unsignedEnvelope = getSOAPEnvelope();
	}

	/**
	* Constructs a soap envelope
	* <p/>
	*
	* @return soap envelope
	* @throws java.lang.Exception if there is any problem constructing the soap envelope
	*/
	protected SOAPEnvelope getSOAPEnvelope() throws Exception {
	InputStream in = new ByteArrayInputStream(SOAPMSG.getBytes());
	Message msg = new Message(in);
	msg.setMessageContext(msgContext);
	return msg.getSOAPEnvelope();
	}

	/**
	* 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 testIssuerSerialSignature() throws Exception {
	WSSecSignature builder = new WSSecSignature();
	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);
	}

	/**
	* 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 testBSTSignature() throws Exception {
	WSSecSignature builder = new WSSecSignature();
	builder.setUserInfo("16c73ab6-b892-458f-abf5-2f875f74882e", "security");
	builder.setKeyIdentifierType(WSConstants.BST_DIRECT_REFERENCE);
	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);
	}

	/**
	* 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 testBSTPKIPathSignature() throws Exception {
	WSSecSignature builder = new WSSecSignature();
	builder.setUserInfo("wss40", "security");
	builder.setKeyIdentifierType(WSConstants.BST_DIRECT_REFERENCE);
	builder.setUseSingleCertificate(false);
	LOG.info("Before Signing....");
	Document doc = unsignedEnvelope.getAsDocument();
	WSSecHeader secHeader = new WSSecHeader();
	secHeader.insertSecurityHeader(doc);

	Crypto pkiCrypto = CryptoFactory.getInstance("wss40.properties");
	Document signedDoc = builder.build(doc, pkiCrypto, secHeader);

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

	secEngine.processSecurityHeader(doc, null, this, pkiCrypto, null);
	}

	/**
	* 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);
	}

	/**
	* This test adds a Timestamp to the security header, and then signs it, and appends
	* the signature element after the Timestamp in the header.
	* @throws Exception
	*/
	public void testSignedTimestamp() throws Exception {
	Document doc = unsignedEnvelope.getAsDocument();
	WSSecHeader secHeader = new WSSecHeader();
	secHeader.insertSecurityHeader(doc);

	WSSecTimestamp timestamp = new WSSecTimestamp();
	timestamp.setTimeToLive(300);
	Document createdDoc = timestamp.build(doc, secHeader);

	java.util.Vector parts = new java.util.Vector();
	WSEncryptionPart encP =
	new WSEncryptionPart(
	"Timestamp",
	WSConstants.WSU_NS,
	"");
	parts.add(encP);

	WSSecSignature builder = new WSSecSignature();
	builder.setUserInfo("16c73ab6-b892-458f-abf5-2f875f74882e", "security");
	builder.prepare(createdDoc, crypto, secHeader);
	builder.addReferencesToSign(parts, secHeader);
	builder.appendToHeader(secHeader);
	builder.computeSignature();

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

	verify(doc);
	}

	/**
	* A test for "There is an issue with the position of the <Timestamp> element in the
	* <Security> header when using WSS4J calling .NET Web Services with WS-Security."
	*/
	public void testWSS231() throws Exception {
	final WSSConfig cfg = WSSConfig.getNewInstance();
	final int action = WSConstants.SIGN \| WSConstants.TS;
	final RequestData reqData = new RequestData();
	reqData.setWssConfig(cfg);
	reqData.setUsername("16c73ab6-b892-458f-abf5-2f875f74882e");

	java.util.Map config = new java.util.TreeMap();
	config.put(WSHandlerConstants.SIG_PROP_FILE, "crypto.properties");
	config.put("password", "security");
	config.put(
	WSHandlerConstants.SIGNATURE_PARTS, "{}{" + WSConstants.WSU_NS + "}Timestamp"
	);
	reqData.setMsgContext(config);

	final Vector actions = new Vector();
	actions.add(new Integer(WSConstants.SIGN));
	actions.add(new Integer(WSConstants.TS));
	final Document doc = unsignedEnvelope.getAsDocument();
	MyHandler handler = new MyHandler();
	handler.send(
	action,
	doc,
	reqData,
	actions,
	true
	);
	String outputString =
	org.apache.ws.security.util.XMLUtils.PrettyDocumentToString(doc);
	if (LOG.isDebugEnabled()) {
	LOG.debug("Signed message:");
	LOG.debug(outputString);
	}

	Vector results = verify(doc);
	assertTrue(handler.checkResults(results, actions));
	}

	/**
	* Verifies the soap envelope
	* <p/>
	*
	* @param env soap envelope
	* @throws java.lang.Exception Thrown when there is a problem in verification
	*/
	private Vector verify(Document doc) throws Exception {
	return secEngine.processSecurityHeader(doc, null, this, crypto, null);
	}

	public void handle(Callback[] callbacks)
	throws IOException, UnsupportedCallbackException {
	for (int i = 0; i < callbacks.length; i++) {
	if (callbacks[i] instanceof WSPasswordCallback) {
	WSPasswordCallback pc = (WSPasswordCallback) callbacks[i];
	/*
	* here call a function/method to lookup the password for
	* the given identifier (e.g. a user name or keystore alias)
	* e.g.: pc.setPassword(passStore.getPassword(pc.getIdentfifier))
	* for Testing we supply a fixed name here.
	*/
	pc.setPassword("security");
	} else {
	throw new UnsupportedCallbackException(callbacks[i], "Unrecognized Callback");
	}
	}
	}
	}