Extensión de SSL para Struts

    <action path="/MiAccion" type="test.ssl.MiAccion" >
      <set-property property="secure" value="true"/>
      <forward name="success" path="/home.jsp" />
      <forward name="failure" path="/error.jsp" />

/**

 * SecureActionMapping class

 */

package org.apache.struts.action;

public class SecureActionMapping extends ActionMapping {

 

    protected boolean secure;

 

    public void setSecure(boolean b){
        this.secure = b;
    }

    public boolean getSecure(){
        return this.secure;
    }
}

  <servlet id="Servlet_1">
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

    <!-- Struts Config -->
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>

    <init-param>
      <param-name>mapping</param-name>
      <param-value>org.apache.struts.action.SecureActionMapping</param-value>
    </init-param>

    <!- other initialization parameters -->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet id="Servlet_1">
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.SecureActionServlet</servlet-class>

    <!-- Struts Config -->
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <init-param>
      <param-name>mapping</param-name>
      <param-value>org.apache.struts.action.SecureActionMapping</param-value>
    </init-param>

    <!- other initialization parameters -->
    <init-param>
      <param-name>http-port</param-name>
      <param-value>8080</param-value>
    </init-param>
    <init-param>
      <param-name>https-port</param-name>
      <param-value>8443</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

package org.apache.struts.action;

import org.apache.struts.util.SecureRequestUtils;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

/**
* An extension of the ActionServlet class to add properties for
* http and https ports.  Performs logic to determine if
* requests should be redirected to http or to https protocol.
*/
public class SecureActionServlet extends ActionServlet {

    protected String httpPort = "80";
    protected String httpsPort = "443";

    public void init() throws ServletException {

        super.init();
        initPorts();
    }

    /**
     * Initializes the http and http port properties
     * from init parameters specified in the web.xml file.
     * If not found there, default values remain.
     */
    protected void initPorts(){
        String value = getServletConfig().getInitParameter("http-port");

        if( value != null ){
        // Other validation code here.
            httpPort = value;
        }

        value = getServletConfig().getInitParameter("https-port");

        if( value != null ){
        // Other validation code here.
            httpsPort = value;
        }
    }

    public void setHttpsPort( String s ){
        this.httpsPort = s;
    }
    public void setHttpPort( String s ){
        this.httpPort = s;
    }
    public String getHttpsPort( ){
        return this.httpsPort;
    }
    public String getHttpPort( ){
        return this.httpPort;
    }

    /**
     * Checks whether servlet should redirect to another protocol
     * before calling the superclass process method.
     *  @param aRequest is the current request object.
     *  @param aResponse is the current response object.
     *  @throws IOException if an input/output error occurs.
     *  @throws ServletException  if a servlet error occurs.
     */
    protected void process(HttpServletRequest request,
                HttpServletResponse response
            ) throws IOException, ServletException {

        // Identify the path component we will use to select a mapping.
        String path = processPath(request);
        if (path == null) {
            if (debug >= 1)
            log(" No path available for request URI " +
                request.getRequestURI());
            response.sendError(HttpServletResponse.SC_BAD_REQUEST,
                       internal.getMessage("processPath"));
            return;
        }

        // Look up the corresponding mapping.
        SecureActionMapping mapping = (SecureActionMapping)processMapping(path, request);
        if (mapping == null) {
            if (debug >= 1)
            log(" No mapping available for path " + path);
            response.sendError(HttpServletResponse.SC_BAD_REQUEST,
                       internal.getMessage("processInvalid", path));
            return;
        }

        // Redirect to https/http if necessary.
        if( checkSsl(mapping, request, response) ){
            return ;
        }

        super.process(request, response);
    }

    /** Checks to see if SSL should be toggled for this
     *  action.
     *  @param aMapping is the mapping object for this Action.
     *  @param aRequest is the current request object.
     *  @param aResponse is the current response object.
     */
    private boolean checkSsl(SecureActionMapping aMapping,
            HttpServletRequest aRequest,
            HttpServletResponse aResponse){

        String redirectString =
                SecureRequestUtils.getRedirectString(aRequest,
                getHttpPort(),
                getHttpsPort(),
                aMapping.getSecure());

        if( redirectString != null ){
            try{
                // Redirect the page to the desired URL.
                aResponse.sendRedirect(aResponse.encodeRedirectURL( redirectString));
                return true;
            }catch(Exception ioe){
                System.out.println("IOException in redirect" + ioe.getMessage());
            }
        }
        return false;
    }
}