Attachment #34824 for bug #57665

View | Details | Raw Unified | Return to bug 57665
Collapse All | Expand All

Lines 43-48 Link Here

(-)java/org/apache/catalina/filters/RemoteIpFilter.java (-5 / +65 lines)
43		43
44	import org.apache.catalina.AccessLog;	44	import org.apache.catalina.AccessLog;
45	import org.apache.catalina.Globals;	45	import org.apache.catalina.Globals;
		46	import org.apache.catalina.connector.Request;
46	import org.apache.catalina.core.ApplicationPushBuilder;	47	import org.apache.catalina.core.ApplicationPushBuilder;
47	import org.apache.catalina.util.RequestUtil;	48	import org.apache.catalina.util.RequestUtil;
48	import org.apache.juli.logging.Log;	49	import org.apache.juli.logging.Log;
Lines 59-66 Link Here
59	* "X-Forwarded-For").	60	* "X-Forwarded-For").
60	* </p>	61	* </p>
61	* <p>	62	* <p>
62	* Another feature of this servlet filter is to replace the apparent scheme (http/https) and server port with the scheme presented by a	63	* Another feature of this servlet filter is to replace the apparent scheme (http/https), server host and server port with the scheme presented by a
63	* proxy or a load balancer via a request header (e.g. "X-Forwarded-Proto").	64	* proxy or a load balancer via request headers (e.g. "X-Forwarded-Proto").
64	* </p>	65	* </p>
65	* <p>	66	* <p>
66	* This servlet filter proceeds as follows:	67	* This servlet filter proceeds as follows:
Lines 466-472 Link Here
466	protected String scheme;	467	protected String scheme;
467		468
468	protected boolean secure;	469	protected boolean secure;
469		470
		471	protected String serverName;
		472
470	protected int serverPort;	473	protected int serverPort;
471		474
472	public XForwardedRequest(HttpServletRequest request) {	475	public XForwardedRequest(HttpServletRequest request) {
Lines 476-481 Link Here
476	this.remoteHost = request.getRemoteHost();	479	this.remoteHost = request.getRemoteHost();
477	this.scheme = request.getScheme();	480	this.scheme = request.getScheme();
478	this.secure = request.isSecure();	481	this.secure = request.isSecure();
		482	this.serverName = request.getServerName();
479	this.serverPort = request.getServerPort();	483	this.serverPort = request.getServerPort();
480		484
481	headers = new HashMap<>();	485	headers = new HashMap<>();
Lines 569-574 Link Here
569	}	573	}
570		574
571	@Override	575	@Override
		576	public String getServerName() {
		577	return serverName;
		578	}
		579
		580	@Override
572	public int getServerPort() {	581	public int getServerPort() {
573	return serverPort;	582	return serverPort;
574	}	583	}
Lines 616-621 Link Here
616	this.secure = secure;	625	this.secure = secure;
617	}	626	}
618		627
		628	public void setServerName(String serverName) {
		629	this.serverName = serverName;
		630	}
		631
619	public void setServerPort(int serverPort) {	632	public void setServerPort(int serverPort) {
620	this.serverPort = serverPort;	633	this.serverPort = serverPort;
621	}	634	}
Lines 652-657 Link Here
652		665
653	protected static final String PROTOCOL_HEADER_HTTPS_VALUE_PARAMETER = "protocolHeaderHttpsValue";	666	protected static final String PROTOCOL_HEADER_HTTPS_VALUE_PARAMETER = "protocolHeaderHttpsValue";
654		667
		668	protected static final String HOST_HEADER_PARAMETER = "hostHeader";
		669
655	protected static final String PORT_HEADER_PARAMETER = "portHeader";	670	protected static final String PORT_HEADER_PARAMETER = "portHeader";
656		671
657	protected static final String CHANGE_LOCAL_PORT_PARAMETER = "changeLocalPort";	672	protected static final String CHANGE_LOCAL_PORT_PARAMETER = "changeLocalPort";
Lines 725-730 Link Here
725		740
726	private String protocolHeaderHttpsValue = "https";	741	private String protocolHeaderHttpsValue = "https";
727		742
		743	private String hostHeader = null;
		744
728	private String portHeader = null;	745	private String portHeader = null;
729		746
730	private boolean changeLocalPort = false;	747	private boolean changeLocalPort = false;
Lines 816-826 Link Here
816	} else if (protocolHeaderHttpsValue.equalsIgnoreCase(protocolHeaderValue)) {	833	} else if (protocolHeaderHttpsValue.equalsIgnoreCase(protocolHeaderValue)) {
817	xRequest.setSecure(true);	834	xRequest.setSecure(true);
818	xRequest.setScheme("https");	835	xRequest.setScheme("https");
819	setPorts(xRequest, httpsServerPort);	836	setHostAndPorts(xRequest, httpsServerPort);
820	} else {	837	} else {
821	xRequest.setSecure(false);	838	xRequest.setSecure(false);
822	xRequest.setScheme("http");	839	xRequest.setScheme("http");
823	setPorts(xRequest, httpServerPort);	840	setHostAndPorts(xRequest, httpServerPort);
824	}	841	}
825	}	842	}
826		843
Lines 857-862 Link Here
857		874
858	}	875	}
859		876
		877	private void setHostAndPorts(XForwardedRequest xrequest, int defaultPort) {
		878	int port = defaultPort;
		879	if (getHostHeader() != null) {
		880	String hostHeaderValue = xrequest.getHeader(getHostHeader());
		881	if (hostHeaderValue != null) {
		882	String hostAndPort[] = hostHeaderValue.split(",")[0].trim().split(":", 2);
		883	String host = hostAndPort[0];
		884	if (hostAndPort.length == 2) {
		885	try {
		886	port = Integer.parseInt(hostAndPort[1]);
		887	} catch (NumberFormatException nfe) {
		888	log.debug("Invalid port value [" + hostHeaderValue +
		889	"] provided in header [" + getHostHeader() + "]");
		890	}
		891	}
		892	xrequest.setServerName(host);
		893	}
		894	}
		895	setPorts(xrequest, port);
		896	}
		897
860	private void setPorts(XForwardedRequest xrequest, int defaultPort) {	898	private void setPorts(XForwardedRequest xrequest, int defaultPort) {
861	int port = defaultPort;	899	int port = defaultPort;
862	if (getPortHeader() != null) {	900	if (getPortHeader() != null) {
Lines 905-910 Link Here
905	return protocolHeader;	943	return protocolHeader;
906	}	944	}
907		945
		946	public String getHostHeader() {
		947	return hostHeader;
		948	}
		949
908	public String getPortHeader() {	950	public String getPortHeader() {
909	return portHeader;	951	return portHeader;
910	}	952	}
Lines 948-953 Link Here
948	setProtocolHeaderHttpsValue(getInitParameter(PROTOCOL_HEADER_HTTPS_VALUE_PARAMETER));	990	setProtocolHeaderHttpsValue(getInitParameter(PROTOCOL_HEADER_HTTPS_VALUE_PARAMETER));
949	}	991	}
950		992
		993	if (getInitParameter(HOST_HEADER_PARAMETER) != null) {
		994	setHostHeader(getInitParameter(HOST_HEADER_PARAMETER));
		995	}
		996
951	if (getInitParameter(PORT_HEADER_PARAMETER) != null) {	997	if (getInitParameter(PORT_HEADER_PARAMETER) != null) {
952	setPortHeader(getInitParameter(PORT_HEADER_PARAMETER));	998	setPortHeader(getInitParameter(PORT_HEADER_PARAMETER));
953	}	999	}
Lines 1047-1052 Link Here
1047		1093
1048	/**	1094	/**
1049	* <p>	1095	* <p>
		1096	* Header that holds a comma separated list of incoming hosts, usually named
		1097	* <code>X-Forwarded-Host</code>.
		1098	* </p>
		1099	* <p>
		1100	* Default value : <code>null</code>
		1101	* </p>
		1102	* @param hostHeader The header name
		1103	*/
		1104	public void setHostHeader(String hostHeader) {
		1105	this.hostHeader = hostHeader;
		1106	}
		1107
		1108	/**
		1109	* <p>
1050	* Header that holds the incoming port, usually named	1110	* Header that holds the incoming port, usually named
1051	* <code>X-Forwarded-Port</code>. If <code>null</code>,	1111	* <code>X-Forwarded-Port</code>. If <code>null</code>,
1052	* {@link #httpServerPort} or {@link #httpsServerPort} will be used.	1112	* {@link #httpServerPort} or {@link #httpsServerPort} will be used.

Lines 43-48 Link Here

(-)java/org/apache/catalina/valves/LocalStrings.properties (+1 lines)
43	errorReportValve.noDescription=No description available	43	errorReportValve.noDescription=No description available
44		44
45	# Remote IP valve	45	# Remote IP valve
		46	remoteIpValve.invalidHostHeader=Invalid value [{0}] found for port in HTTP header [{1}]
46	remoteIpValve.invalidPortHeader=Invalid value [{0}] found for port in HTTP header [{1}]	47	remoteIpValve.invalidPortHeader=Invalid value [{0}] found for port in HTTP header [{1}]
47		48
48	# Request filter valve - RemoteAddrValve, RemoteHostValve	49	# Request filter valve - RemoteAddrValve, RemoteHostValve

Lines 28-33 Link Here

(-)java/org/apache/catalina/valves/LocalStrings_es.properties (+1 lines)
28	errorReportValve.note = nota	28	errorReportValve.note = nota
29	errorReportValve.rootCauseInLogs = La traza completa de la causa de este error se encuentra en los archivos de diario del servidor.	29	errorReportValve.rootCauseInLogs = La traza completa de la causa de este error se encuentra en los archivos de diario del servidor.
30		30
		31	remoteIpValve.invalidHostHeader = Valor inv\u00E1lido [{0}] hallado para el puerto en cabecera HTTP [{1}]
31	remoteIpValve.invalidPortHeader = Valor inv\u00E1lido [{0}] hallado para el puerto en cabecera HTTP [{1}]	32	remoteIpValve.invalidPortHeader = Valor inv\u00E1lido [{0}] hallado para el puerto en cabecera HTTP [{1}]
32	sslValve.certError = No pude procesar cadena de certificado [{0}] para crear un objeto java.security.cert.X509Certificate	33	sslValve.certError = No pude procesar cadena de certificado [{0}] para crear un objeto java.security.cert.X509Certificate
33	sslValve.invalidProvider = El proveedor de SSL especificado en el conecto asociado con este requerimiento de [{0}] ies inv\u00E1lido. No se pueden procesar los datos del certificado.	34	sslValve.invalidProvider = El proveedor de SSL especificado en el conecto asociado con este requerimiento de [{0}] ies inv\u00E1lido. No se pueden procesar los datos del certificado.

Lines 40-47 Link Here

(-)java/org/apache/catalina/valves/RemoteIpValve.java (-4 / +52 lines)
40	* headers (e.g. "X-Forwarded-For").	40	* headers (e.g. "X-Forwarded-For").
41	* </p>	41	* </p>
42	* <p>	42	* <p>
43	* Another feature of this valve is to replace the apparent scheme (http/https) and server port with the scheme presented by a proxy or a	43	* Another feature of this valve is to replace the apparent scheme (http/https), server host and server port with the scheme presented by a proxy or a
44	* load balancer via a request header (e.g. "X-Forwarded-Proto").	44	* load balancer via request headers (e.g. "X-Forwarded-Proto").
45	* </p>	45	* </p>
46	* <p>	46	* <p>
47	* This valve proceeds as follows:	47	* This valve proceeds as follows:
Lines 424-429 Link Here
424	*/	424	*/
425	private String protocolHeaderHttpsValue = "https";	425	private String protocolHeaderHttpsValue = "https";
426		426
		427	private String hostHeader = null;
		428
427	private String portHeader = null;	429	private String portHeader = null;
428		430
429	/**	431	/**
Lines 475-480 Link Here
475		477
476	/**	478	/**
477	* Obtain the name of the HTTP header used to override the value returned	479	* Obtain the name of the HTTP header used to override the value returned
		480	* by {@link Request#getServerName()}.
		481	*
		482	* @return The HTTP header name
		483	*/
		484	public String getHostHeader() {
		485	return hostHeader;
		486	}
		487
		488	/**
		489	* Set the name of the HTTP header used to override the value returned
		490	* by {@link Request#getServerName()}.
		491	*
		492	* @param hostHeader The HTTP header name
		493	*/
		494	public void setHostHeader(String hostHeader) {
		495	this.hostHeader = hostHeader;
		496	}
		497
		498	/**
		499	* Obtain the name of the HTTP header used to override the value returned
478	* by {@link Request#getServerPort()} and (optionally depending on {link	500	* by {@link Request#getServerPort()} and (optionally depending on {link
479	* {@link #isChangeLocalPort()} {@link Request#getLocalPort()}.	501	* {@link #isChangeLocalPort()} {@link Request#getLocalPort()}.
480	*	502	*
Lines 567-572 Link Here
567	final String originalRemoteHost = request.getRemoteHost();	589	final String originalRemoteHost = request.getRemoteHost();
568	final String originalScheme = request.getScheme();	590	final String originalScheme = request.getScheme();
569	final boolean originalSecure = request.isSecure();	591	final boolean originalSecure = request.isSecure();
		592	final String originalServerName = request.getServerName();
570	final int originalServerPort = request.getServerPort();	593	final int originalServerPort = request.getServerPort();
571	final String originalProxiesHeader = request.getHeader(proxiesHeader);	594	final String originalProxiesHeader = request.getHeader(proxiesHeader);
572	final String originalRemoteIpHeader = request.getHeader(remoteIpHeader);	595	final String originalRemoteIpHeader = request.getHeader(remoteIpHeader);
Lines 639-651 Link Here
639	// use request.coyoteRequest.scheme instead of request.setScheme() because request.setScheme() is no-op in Tomcat 6.0	662	// use request.coyoteRequest.scheme instead of request.setScheme() because request.setScheme() is no-op in Tomcat 6.0
640	request.getCoyoteRequest().scheme().setString("https");	663	request.getCoyoteRequest().scheme().setString("https");
641		664
642	setPorts(request, httpsServerPort);	665	setHostAndPorts(request, httpsServerPort);
643	} else {	666	} else {
644	request.setSecure(false);	667	request.setSecure(false);
645	// use request.coyoteRequest.scheme instead of request.setScheme() because request.setScheme() is no-op in Tomcat 6.0	668	// use request.coyoteRequest.scheme instead of request.setScheme() because request.setScheme() is no-op in Tomcat 6.0
646	request.getCoyoteRequest().scheme().setString("http");	669	request.getCoyoteRequest().scheme().setString("http");
647		670
648	setPorts(request, httpServerPort);	671	setHostAndPorts(request, httpServerPort);
649	}	672	}
650	}	673	}
651		674
Lines 685-690 Link Here
685	// use request.coyoteRequest.scheme instead of request.setScheme() because request.setScheme() is no-op in Tomcat 6.0	708	// use request.coyoteRequest.scheme instead of request.setScheme() because request.setScheme() is no-op in Tomcat 6.0
686	request.getCoyoteRequest().scheme().setString(originalScheme);	709	request.getCoyoteRequest().scheme().setString(originalScheme);
687		710
		711	request.getCoyoteRequest().serverName().setString(originalServerName);
688	request.setServerPort(originalServerPort);	712	request.setServerPort(originalServerPort);
689		713
690	if (originalProxiesHeader == null \|\| originalProxiesHeader.length() == 0) {	714	if (originalProxiesHeader == null \|\| originalProxiesHeader.length() == 0) {
Lines 701-706 Link Here
701	}	725	}
702	}	726	}
703		727
		728	private void setHostAndPorts(Request request, int defaultPort) {
		729	int port = defaultPort;
		730	if (hostHeader != null) {
		731	String hostHeaderValue = request.getHeader(hostHeader);
		732	if (hostHeaderValue != null) {
		733	String hostAndPort[] = hostHeaderValue.split(",")[0].trim().split(":", 2);
		734	String host = hostAndPort[0];
		735	if (hostAndPort.length == 2) {
		736	try {
		737	port = Integer.parseInt(hostAndPort[1]);
		738	} catch (NumberFormatException nfe) {
		739	if (log.isDebugEnabled()) {
		740	log.debug(sm.getString(
		741	"remoteIpValve.invalidHostHeader",
		742	hostHeaderValue, hostHeader), nfe);
		743	}
		744	}
		745	}
		746	request.getCoyoteRequest().serverName().setString(host);
		747	}
		748	}
		749	setPorts(request, port);
		750	}
		751
704	private void setPorts(Request request, int defaultPort) {	752	private void setPorts(Request request, int defaultPort) {
705	int port = defaultPort;	753	int port = defaultPort;
706	if (portHeader != null) {	754	if (portHeader != null) {




import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import org.junit.Assert;
import org.junit.Test;

            writer.println("request.remoteHost=" + request.getRemoteHost());
            writer.println("request.secure=" + request.isSecure());
            writer.println("request.scheme=" + request.getScheme());
            writer.println("request.serverName=" + request.getServerName());
            writer.println("request.serverPort=" + request.getServerPort());

            writer.println();

    }

    @Test
    public void testInvokeXforwardedHost() throws Exception {
        // PREPARE
        FilterDef filterDef = new FilterDef();
        filterDef.addInitParameter("hostHeader", "x-forwarded-host");
        filterDef.addInitParameter("portHeader", "x-forwarded-port");
        filterDef.addInitParameter("protocolHeader", "x-forwarded-proto");
        
        MockHttpServletRequest request = new MockHttpServletRequest();
        // client ip
        request.setRemoteAddr("192.168.0.10");
        request.setRemoteHost("192.168.0.10");
        // protocol
        request.setSecure(false);
        request.setServerPort(8080);
        request.setScheme("http");
        // host and port
        request.getCoyoteRequest().serverName().setString("10.0.0.1");
        request.setHeader("x-forwarded-host", "example.com");
        request.setHeader("x-forwarded-port", "8443");
        request.setHeader("x-forwarded-proto", "https");

        // TEST
        HttpServletRequest actualRequest = testRemoteIpFilter(filterDef, request).getRequest();
        
        // VERIFY
        // protocol
        String actualServerName = actualRequest.getServerName();
        assertEquals("postInvoke serverName", "example.com", actualServerName);
        
        String actualScheme = actualRequest.getScheme();
        assertEquals("postInvoke scheme", "https", actualScheme);
        
        int actualServerPort = actualRequest.getServerPort();
        assertEquals("postInvoke serverPort", 8443, actualServerPort);

        boolean actualSecure = actualRequest.isSecure();
        assertTrue("postInvoke secure", actualSecure);
    }

    @Test
    public void testInvokeXforwardedHostAndPort() throws Exception {
        // PREPARE
        FilterDef filterDef = new FilterDef();
        filterDef.addInitParameter("hostHeader", "x-forwarded-host");
        filterDef.addInitParameter("portHeader", "x-forwarded-port");
        filterDef.addInitParameter("protocolHeader", "x-forwarded-proto");
        
        MockHttpServletRequest request = new MockHttpServletRequest();
        // client ip
        request.setRemoteAddr("192.168.0.10");
        request.setRemoteHost("192.168.0.10");
        // protocol
        request.setSecure(false);
        request.setServerPort(8080);
        request.setScheme("http");
        // host and port
        request.getCoyoteRequest().serverName().setString("10.0.0.1");
        request.setHeader("x-forwarded-host", "example.com:8443");
        request.setHeader("x-forwarded-proto", "https");

        // TEST
        HttpServletRequest actualRequest = testRemoteIpFilter(filterDef, request).getRequest();
        
        // VERIFY
        // protocol
        String actualServerName = actualRequest.getServerName();
        assertEquals("postInvoke serverName", "example.com", actualServerName);
        
        String actualScheme = actualRequest.getScheme();
        assertEquals("postInvoke scheme", "https", actualScheme);
        
        int actualServerPort = actualRequest.getServerPort();
        assertEquals("postInvoke serverPort", 8443, actualServerPort);

        boolean actualSecure = actualRequest.isSecure();
        assertTrue("postInvoke secure", actualSecure);
    }
    
    @Test
    public void testListToCommaDelimitedString() {
        String[] actual = RemoteIpFilter.commaDelimitedListToStringArray("element1, element2, element3");
        String[] expected = new String[] { "element1", "element2", "element3" };

Lines 47-52 Link Here

(-)test/org/apache/catalina/valves/TestRemoteIpValve.java (-1 / +117 lines)
47	private String remoteHost;	47	private String remoteHost;
48	private String scheme;	48	private String scheme;
49	private boolean secure;	49	private boolean secure;
		50	private String serverName;
50	private int serverPort;	51	private int serverPort;
51	private String forwardedFor;	52	private String forwardedFor;
52	private String forwardedBy;	53	private String forwardedBy;
Lines 63-68 Link Here
63	return scheme;	64	return scheme;
64	}	65	}
65		66
		67	public String getServerName() {
		68	return serverName;
		69	}
		70
66	public int getServerPort() {	71	public int getServerPort() {
67	return serverPort;	72	return serverPort;
68	}	73	}
Lines 85-90 Link Here
85	this.remoteAddr = request.getRemoteAddr();	90	this.remoteAddr = request.getRemoteAddr();
86	this.scheme = request.getScheme();	91	this.scheme = request.getScheme();
87	this.secure = request.isSecure();	92	this.secure = request.isSecure();
		93	this.serverName = request.getServerName();
88	this.serverPort = request.getServerPort();	94	this.serverPort = request.getServerPort();
89	this.forwardedFor = request.getHeader("x-forwarded-for");	95	this.forwardedFor = request.getHeader("x-forwarded-for");
90	this.forwardedBy = request.getHeader("x-forwarded-by");	96	this.forwardedBy = request.getHeader("x-forwarded-by");
Lines 659-665 Link Here
659	assertEquals("x-forwarded-proto is null", "https", actualScheme);	665	assertEquals("x-forwarded-proto is null", "https", actualScheme);
660		666
661	int actualServerPort = remoteAddrAndHostTrackerValve.getServerPort();	667	int actualServerPort = remoteAddrAndHostTrackerValve.getServerPort();
662	assertEquals("x-forwarded-proto is null", 8443, actualServerPort);	668	assertEquals("x-forwarded-port is null", 8443, actualServerPort);
663		669
664	boolean actualSecure = remoteAddrAndHostTrackerValve.isSecure();	670	boolean actualSecure = remoteAddrAndHostTrackerValve.isSecure();
665	assertTrue("x-forwarded-proto is null", actualSecure);	671	assertTrue("x-forwarded-proto is null", actualSecure);
Lines 675-680 Link Here
675	}	681	}
676		682
677	@Test	683	@Test
		684	public void testInvokeXforwardedHost() throws Exception {
		685
		686	// PREPARE
		687	RemoteIpValve remoteIpValve = new RemoteIpValve();
		688	remoteIpValve.setHostHeader("x-forwarded-host");
		689	remoteIpValve.setProtocolHeader("x-forwarded-proto");
		690	RemoteAddrAndHostTrackerValve remoteAddrAndHostTrackerValve = new RemoteAddrAndHostTrackerValve();
		691	remoteIpValve.setNext(remoteAddrAndHostTrackerValve);
		692
		693	Request request = new MockRequest();
		694	request.setCoyoteRequest(new org.apache.coyote.Request());
		695	// client ip
		696	request.setRemoteAddr("192.168.0.10");
		697	request.setRemoteHost("192.168.0.10");
		698	// protocol
		699	request.setSecure(false);
		700	request.setServerPort(8080);
		701	request.getCoyoteRequest().scheme().setString("http");
		702	// host and port
		703	request.getCoyoteRequest().serverName().setString("10.0.0.1");
		704	request.getCoyoteRequest().getMimeHeaders().addValue("x-forwarded-host").setString("example.com:8443");
		705	request.getCoyoteRequest().getMimeHeaders().addValue("x-forwarded-proto").setString("https");
		706
		707	// TEST
		708	remoteIpValve.invoke(request, null);
		709
		710	// VERIFY
		711	// protocol
		712	String actualServerName = remoteAddrAndHostTrackerValve.getServerName();
		713	assertEquals("tracked serverName", "example.com", actualServerName);
		714
		715	String actualScheme = remoteAddrAndHostTrackerValve.getScheme();
		716	assertEquals("tracked scheme", "https", actualScheme);
		717
		718	int actualServerPort = remoteAddrAndHostTrackerValve.getServerPort();
		719	assertEquals("tracked serverPort", 8443, actualServerPort);
		720
		721	boolean actualSecure = remoteAddrAndHostTrackerValve.isSecure();
		722	assertTrue("tracked secure", actualSecure);
		723
		724	String actualPostInvokeServerName = request.getServerName();
		725	assertEquals("postInvoke serverName", "10.0.0.1", actualPostInvokeServerName);
		726
		727	boolean actualPostInvokeSecure = request.isSecure();
		728	assertFalse("postInvoke secure", actualPostInvokeSecure);
		729
		730	int actualPostInvokeServerPort = request.getServerPort();
		731	assertEquals("postInvoke serverPort", 8080, actualPostInvokeServerPort);
		732
		733	String actualPostInvokeScheme = request.getScheme();
		734	assertEquals("postInvoke scheme", "http", actualPostInvokeScheme);
		735	}
		736
		737	@Test
		738	public void testInvokeXforwardedHostAndPort() throws Exception {
		739
		740	// PREPARE
		741	RemoteIpValve remoteIpValve = new RemoteIpValve();
		742	remoteIpValve.setHostHeader("x-forwarded-host");
		743	remoteIpValve.setPortHeader("x-forwarded-port");
		744	remoteIpValve.setProtocolHeader("x-forwarded-proto");
		745	RemoteAddrAndHostTrackerValve remoteAddrAndHostTrackerValve = new RemoteAddrAndHostTrackerValve();
		746	remoteIpValve.setNext(remoteAddrAndHostTrackerValve);
		747
748	Request request = new MockRequest();
749	request.setCoyoteRequest(new org.apache.coyote.Request());
750	// client ip
751	request.setRemoteAddr("192.168.0.10");
752	request.setRemoteHost("192.168.0.10");
753	// protocol
754	request.setSecure(false);
755	request.setServerPort(8080);
756	request.getCoyoteRequest().scheme().setString("http");
757	// host and port
758	request.getCoyoteRequest().serverName().setString("10.0.0.1");
759	request.getCoyoteRequest().getMimeHeaders().addValue("x-forwarded-host").setString("example.com");
760	request.getCoyoteRequest().getMimeHeaders().addValue("x-forwarded-port").setString("8443");
761	request.getCoyoteRequest().getMimeHeaders().addValue("x-forwarded-proto").setString("https");
762
763	// TEST
764	remoteIpValve.invoke(request, null);
765
766	// VERIFY
767	// protocol
768	String actualServerName = remoteAddrAndHostTrackerValve.getServerName();
769	assertEquals("tracked serverName", "example.com", actualServerName);
770
771	String actualScheme = remoteAddrAndHostTrackerValve.getScheme();
772	assertEquals("tracked scheme", "https", actualScheme);
773
774	int actualServerPort = remoteAddrAndHostTrackerValve.getServerPort();
775	assertEquals("tracked serverPort", 8443, actualServerPort);
776
777	boolean actualSecure = remoteAddrAndHostTrackerValve.isSecure();
778	assertTrue("tracked secure", actualSecure);
779
780	String actualPostInvokeServerName = request.getServerName();
781	assertEquals("postInvoke serverName", "10.0.0.1", actualPostInvokeServerName);
782
783	boolean actualPostInvokeSecure = request.isSecure();
784	assertFalse("postInvoke secure", actualPostInvokeSecure);
785
786	int actualPostInvokeServerPort = request.getServerPort();
787	assertEquals("postInvoke serverPort", 8080, actualPostInvokeServerPort);
788
789	String actualPostInvokeScheme = request.getScheme();
790	assertEquals("postInvoke scheme", "http", actualPostInvokeScheme);
791	}
792
793	@Test
678	public void testInvokeNotAllowedRemoteAddr() throws Exception {	794	public void testInvokeNotAllowedRemoteAddr() throws Exception {
679	// PREPARE	795	// PREPARE
680	RemoteIpValve remoteIpValve = new RemoteIpValve();	796	RemoteIpValve remoteIpValve = new RemoteIpValve();

Return to bug 57665

Lines 40-45 Link Here

(-)test/org/apache/catalina/filters/TestRemoteIpFilter.java (+81 lines)
40	import static org.junit.Assert.assertEquals;	40	import static org.junit.Assert.assertEquals;
41	import static org.junit.Assert.assertFalse;	41	import static org.junit.Assert.assertFalse;
42	import static org.junit.Assert.assertNull;	42	import static org.junit.Assert.assertNull;
		43	import static org.junit.Assert.assertTrue;
43		44
44	import org.junit.Assert;	45	import org.junit.Assert;
45	import org.junit.Test;	46	import org.junit.Test;
Lines 100-105 Link Here
100	writer.println("request.remoteHost=" + request.getRemoteHost());	101	writer.println("request.remoteHost=" + request.getRemoteHost());
101	writer.println("request.secure=" + request.isSecure());	102	writer.println("request.secure=" + request.isSecure());
102	writer.println("request.scheme=" + request.getScheme());	103	writer.println("request.scheme=" + request.getScheme());
		104	writer.println("request.serverName=" + request.getServerName());
103	writer.println("request.serverPort=" + request.getServerPort());	105	writer.println("request.serverPort=" + request.getServerPort());
104		106
105	writer.println();	107	writer.println();
Lines 483-488 Link Here
483	}	485	}
484		486
485	@Test	487	@Test
		488	public void testInvokeXforwardedHost() throws Exception {
		489	// PREPARE
		490	FilterDef filterDef = new FilterDef();
		491	filterDef.addInitParameter("hostHeader", "x-forwarded-host");
		492	filterDef.addInitParameter("portHeader", "x-forwarded-port");
		493	filterDef.addInitParameter("protocolHeader", "x-forwarded-proto");
		494
		495	MockHttpServletRequest request = new MockHttpServletRequest();
		496	// client ip
		497	request.setRemoteAddr("192.168.0.10");
		498	request.setRemoteHost("192.168.0.10");
		499	// protocol
		500	request.setSecure(false);
		501	request.setServerPort(8080);
		502	request.setScheme("http");
		503	// host and port
		504	request.getCoyoteRequest().serverName().setString("10.0.0.1");
		505	request.setHeader("x-forwarded-host", "example.com");
		506	request.setHeader("x-forwarded-port", "8443");
		507	request.setHeader("x-forwarded-proto", "https");
		508
		509	// TEST
		510	HttpServletRequest actualRequest = testRemoteIpFilter(filterDef, request).getRequest();
		511
		512	// VERIFY
		513	// protocol
		514	String actualServerName = actualRequest.getServerName();
		515	assertEquals("postInvoke serverName", "example.com", actualServerName);
		516
		517	String actualScheme = actualRequest.getScheme();
		518	assertEquals("postInvoke scheme", "https", actualScheme);
		519
		520	int actualServerPort = actualRequest.getServerPort();
		521	assertEquals("postInvoke serverPort", 8443, actualServerPort);
		522
		523	boolean actualSecure = actualRequest.isSecure();
		524	assertTrue("postInvoke secure", actualSecure);
		525	}
		526
		527	@Test
		528	public void testInvokeXforwardedHostAndPort() throws Exception {
		529	// PREPARE
		530	FilterDef filterDef = new FilterDef();
		531	filterDef.addInitParameter("hostHeader", "x-forwarded-host");
		532	filterDef.addInitParameter("portHeader", "x-forwarded-port");
		533	filterDef.addInitParameter("protocolHeader", "x-forwarded-proto");
		534
		535	MockHttpServletRequest request = new MockHttpServletRequest();
		536	// client ip
		537	request.setRemoteAddr("192.168.0.10");
		538	request.setRemoteHost("192.168.0.10");
		539	// protocol
		540	request.setSecure(false);
		541	request.setServerPort(8080);
		542	request.setScheme("http");
		543	// host and port
		544	request.getCoyoteRequest().serverName().setString("10.0.0.1");
		545	request.setHeader("x-forwarded-host", "example.com:8443");
		546	request.setHeader("x-forwarded-proto", "https");
		547
		548	// TEST
		549	HttpServletRequest actualRequest = testRemoteIpFilter(filterDef, request).getRequest();
		550
		551	// VERIFY
552	// protocol
553	String actualServerName = actualRequest.getServerName();
554	assertEquals("postInvoke serverName", "example.com", actualServerName);
555
556	String actualScheme = actualRequest.getScheme();
557	assertEquals("postInvoke scheme", "https", actualScheme);
558
559	int actualServerPort = actualRequest.getServerPort();
560	assertEquals("postInvoke serverPort", 8443, actualServerPort);
561
562	boolean actualSecure = actualRequest.isSecure();
563	assertTrue("postInvoke secure", actualSecure);
564	}
565
566	@Test
486	public void testListToCommaDelimitedString() {	567	public void testListToCommaDelimitedString() {
487	String[] actual = RemoteIpFilter.commaDelimitedListToStringArray("element1, element2, element3");	568	String[] actual = RemoteIpFilter.commaDelimitedListToStringArray("element1, element2, element3");
488	String[] expected = new String[] { "element1", "element2", "element3" };	569	String[] expected = new String[] { "element1", "element2", "element3" };