<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8"/>
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <meta name="Date-Revision-yyyymmdd" content="20140918"/>
  <meta http-equiv="Content-Language" content="en"/>
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

  <title>Announcements 2023</title>

  <link href="//fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,600,700,400italic,600italic,700italic" rel="stylesheet" type="text/css">
  <link href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.css" rel="stylesheet">
  <link href="/css/main.css" rel="stylesheet">
  <link href="/css/custom.css" rel="stylesheet">
  <link href="/css/syntax.css" rel="stylesheet">

  <script src="//code.jquery.com/jquery-1.11.0.min.js"></script>
  <script type="text/javascript" src="/bootstrap/js/bootstrap.js"></script>
  <script type="text/javascript" src="/js/community.js"></script>

  <!-- Matomo -->
  <script>
    var _paq = window._paq = window._paq || [];
    /* tracker methods like "setCustomDimension" should be called before "trackPageView" */
    /* We explicitly disable cookie tracking to avoid privacy issues */
    _paq.push(['disableCookies']);
    _paq.push(['trackPageView']);
    _paq.push(['enableLinkTracking']);
    (function() {
      var u="//analytics.apache.org/";
      _paq.push(['setTrackerUrl', u+'matomo.php']);
      _paq.push(['setSiteId', '41']);
      var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
      g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
    })();
  </script>
  <!-- End Matomo Code -->
</head>
<body>

<a href="https://github.com/apache/struts" class="github-ribbon">
  <img decoding="async" loading="lazy" style="position: absolute; right: 0; border: 0;" width="149" height="149" src="https://github.blog/wp-content/uploads/2008/12/forkme_right_red_aa0000.png?resize=149%2C149" class="attachment-full size-full" alt="Fork me on GitHub" data-recalc-dims="1">
</a>

<header>
  <nav>
    <div role="navigation" class="navbar navbar-default navbar-fixed-top">
      <div class="container">
        <div class="navbar-header">
          <button type="button" data-toggle="collapse" data-target="#struts-menu" class="navbar-toggle">
            Menu
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
          </button>
          <a href="/index.html" class="navbar-brand logo"><img src="/img/struts-logo.svg"></a>
        </div>
        <div id="struts-menu" class="navbar-collapse collapse">
          <ul class="nav navbar-nav">
            <li class="dropdown">
              <a data-toggle="dropdown" href="#" class="dropdown-toggle">
                Home<b class="caret"></b>
              </a>
              <ul class="dropdown-menu">
                <li><a href="/index.html">Welcome</a></li>
                <li><a href="/download.cgi">Download</a></li>
                <li><a href="/releases.html">Releases</a></li>
                <li><a href="/announce-2024.html">Announcements</a></li>
                <li><a href="http://www.apache.org/licenses/">License</a></li>
                <li><a href="https://www.apache.org/foundation/thanks.html">Thanks!</a></li>
                <li><a href="https://www.apache.org/foundation/sponsorship.html">Sponsorship</a></li>
                <li><a href="https://privacy.apache.org/policies/privacy-policy-public.html">Privacy Policy</a></li>
              </ul>
            </li>
            <li class="dropdown">
              <a data-toggle="dropdown" href="#" class="dropdown-toggle">
                Support<b class="caret"></b>
              </a>
              <ul class="dropdown-menu">
                <li><a href="/mail.html">User Mailing List</a></li>
                <li><a href="https://issues.apache.org/jira/browse/WW">Issue Tracker</a></li>
                <li><a href="/security.html">Reporting Security Issues</a></li>
                <li><a href="/commercial-support.html">Commercial Support</a></li>
                <li class="divider"></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/Migration+Guide">Version Notes</a></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/Security+Bulletins">Security Bulletins</a></li>
                <li class="divider"></li>
                <li><a href="/maven/project-info.html">Maven Project Info</a></li>
                <li><a href="/maven/struts2-core/dependencies.html">Struts Core Dependencies</a></li>
                <li><a href="/maven/struts2-plugins/modules.html">Plugin Dependencies</a></li>
              </ul>
            </li>
            <li class="dropdown">
              <a data-toggle="dropdown" href="#" class="dropdown-toggle">
                Documentation<b class="caret"></b>
              </a>
              <ul class="dropdown-menu">
                <li><a href="/birdseye.html">Birds Eye</a></li>
                <li><a href="/primer.html">Key Technologies</a></li>
                <li><a href="/kickstart.html">Kickstart FAQ</a></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/Home">Wiki</a></li>
                <li class="divider"></li>
                <li><a href="/getting-started/">Getting Started</a></li>
                <li><a href="/security/">Security Guide</a></li>
                <li><a href="/core-developers/">Core Developers Guide</a></li>
                <li><a href="/tag-developers/">Tag Developers Guide</a></li>
                <li><a href="/maven-archetypes/">Maven Archetypes</a></li>
                <li><a href="/plugins/">Plugins</a></li>
                <li><a href="/maven/struts2-core/apidocs/index.html">Struts Core API</a></li>
                <li><a href="/tag-developers/tag-reference.html">Tag reference</a></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/FAQs">FAQs</a></li>
                <li><a href="http://cwiki.apache.org/S2PLUGINS/home.html">Plugin registry</a></li>
              </ul>
            </li>
            <li class="dropdown">
              <a data-toggle="dropdown" href="#" class="dropdown-toggle">
                Contributing<b class="caret"></b>
              </a>
              <ul class="dropdown-menu">
                <li><a href="/youatstruts.html">You at Struts</a></li>
                <li><a href="/helping.html">How to Help FAQ</a></li>
                <li><a href="/dev-mail.html">Development Lists</a></li>
                <li class="divider"></li>
                <li><a href="/submitting-patches.html">Submitting patches</a></li>
                <li><a href="/builds.html">Source Code and Builds</a></li>
                <li><a href="/coding-standards.html">Coding standards</a></li>
                <li><a href="/contributors/">Contributors Guide</a></li>
                <li class="divider"></li>
                <li><a href="/release-guidelines.html">Release Guidelines</a></li>
                <li><a href="/bylaws.html">PMC Charter</a></li>
                <li><a href="/volunteers.html">Volunteers</a></li>
                <li><a href="https://gitbox.apache.org/repos/asf?p=struts.git">Source Repository</a></li>
                <li><a href="/updating-website.html">Updating the website</a></li>
              </ul>
            </li>
            <li class="apache"><a href="http://www.apache.org/"><img src="/img/apache.png"></a></li>
          </ul>
        </div>
      </div>
    </div>
  </nav>
</header>


<article class="container">
  <section class="col-md-12">
    <a class="edit-on-gh" href="https://github.com/apache/struts-site/edit/master/source/announce-2023.md" title="Edit this page on GitHub">Edit on GitHub</a>
    
    <h1 class="no_toc" id="announcements-2023">Announcements 2023</h1>


<p class="pull-right">
  Skip to: <a href="announce-2022">Announcements - 2022</a>
</p>

<h4 id="a20231207-1">7 December 2023 - Apache Struts version 6.3.0.2 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 6.3.0.2 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>This version addresses a potential <strong>security vulnerability</strong> identified as <strong>CVE-2023-50164</strong> and described 
in <a href="https://cwiki.apache.org/confluence/display/WW/S2-066">S2-066</a> - please read the mentioned security bulletins for more details.
This is a drop-in replacement and upgrade should be straightforward.</p>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+6.3.0.2">Version Notes</a> to find more details about performed
bug fixes and improvements.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20231207-2">7 December 2023 - Apache Struts version 2.5.33 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 2.5.33 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>This version addresses a potential <strong>security vulnerability</strong> identified as <strong>CVE-2023-50164</strong> and described
in <a href="https://cwiki.apache.org/confluence/display/WW/S2-066">S2-066</a> - please read the mentioned security bulletins for more details.
This is a drop-in replacement and upgrade should be straightforward.</p>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+2.5.33">Version Notes</a> to find more details about performed
bug fixes and improvements.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20231030">30 October 2023 - Apache Struts 2.5.x End-Of-Life (EOL) Announcement</h4>

<p>The Apache Struts Project Team would like to inform you that the Struts 2.5.x web framework will reach
its end of life in 6 months and won’t be longer officially supported.</p>

<p>Please check the following reading to find more details.</p>

<ul>
  <li><a href="struts25-eol-announcement">Apache Struts 2.5.x EOL Announcement</a>, including a detailed Q/A section</li>
</ul>

<h4 id="a20230913-1">13 September 2023 - Apache Struts version 6.3.0.1 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 6.3.0.1 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>This version addresses a potential <strong>security vulnerability</strong> described in <a href="https://cwiki.apache.org/confluence/display/WW/S2-065">S2-065</a> - please read the mentioned security bulletins for more details.
This is a drop-in replacement and upgrade should be straightforward.</p>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+6.3.0.1">Version Notes</a> to find more details about performed
bug fixes and improvements.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20230913-2">13 September 2023 - Apache Struts version 6.1.2.2 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 6.1.2.2 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>This version addresses a potential <strong>security vulnerability</strong> described in <a href="https://cwiki.apache.org/confluence/display/WW/S2-065">S2-065</a> - please read the mentioned security bulletins for more details.
This is a drop-in replacement and upgrade should be straightforward.</p>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+6.1.2.2">Version Notes</a> to find more details about performed
bug fixes and improvements.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20230913-3">13 September 2023 - Apache Struts version 2.5.32 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 2.5.32 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>This version addresses a potential <strong>security vulnerability</strong> described in <a href="https://cwiki.apache.org/confluence/display/WW/S2-065">S2-065</a> - please read the mentioned security bulletins for more details.
This is a drop-in replacement and upgrade should be straightforward.</p>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+2.5.32">Version Notes</a> to find more details about performed
bug fixes and improvements.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20230904">04 September 2023 - Apache Struts version 6.3.0 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 6.3.0 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<blockquote>
  <p>Note: This version includes the whole code of retired The Apache Tiles, when you use the Struts Tiles plugin
please to remove any external dependencies to the Apache Tiles as the whole code is already included in the plugin.
See <a href="https://issues.apache.org/jira/browse/WW-5233">WW-5233</a> for more details.</p>
</blockquote>

<p>Below is a full list of all changes:</p>

<p><strong>Bug</strong></p>

<ul>
  <li>WW-5330 - Issue when submitting a form with a textarea containing more than 4000 characters.</li>
  <li>WW-5331 - Access to request attributes via tags is broken</li>
</ul>

<p><strong>Improvement</strong></p>

<ul>
  <li>WW-5233 - Include Apache Tiles code base in the Tiles plugin</li>
  <li>WW-5321 - notify / document about new maxStringLength limitation</li>
  <li>WW-5327 - Stop using JavaBeans notation for setters in SecurityMemberAccess &amp; MemberAccessValueStack</li>
  <li>WW-5332 - Validate excluded package name list for missing commas</li>
  <li>WW-5334 - Misc VelocityManager code cleanup</li>
  <li>WW-5336 - Merge OgnlTool class into StrutsUtil class</li>
  <li>WW-5337 - Improve performance of excluded classes and packages</li>
</ul>

<p><strong>Dependency</strong></p>

<ul>
  <li>WW-5315 - Upgrades ASM to version 9.5</li>
  <li>WW-5316 - Upgrades commons-io to version 2.13.0</li>
  <li>WW-5317 - Upgrades log4j-api to version 2.20.0</li>
  <li>WW-5318 - Upgrades slf4j-api to version 2.0.7</li>
  <li>WW-5320 - finish Reproducible Builds</li>
  <li>WW-5322 - Upgrade Jackson version to 2.15.2</li>
  <li>WW-5323 - Upgrade JasperReports to version 6.20.5</li>
  <li>WW-5325 - Upgrade commons-lang3 to version 2.13.0</li>
  <li>WW-5329 - Upgrade xstream to version 1.4.20</li>
</ul>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+6.3.0">Version Notes</a> to find more details about performed
bug fixes and improvements.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20230710">10 July 2023 - Apache Struts version 6.2.0 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 6.2.0 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>Below is a full list of all changes:</p>

<p><strong>Bug</strong></p>

<ul>
  <li>WW-4434 - datetextfield.ftl is missing</li>
  <li>WW-5199 - StrutsPrepareFilter and StrutsExecuteFilter do not support forwarding to another action</li>
  <li>WW-5263 - CSP related interceptors have wrong short names</li>
  <li>WW-5270 - Forwarding from a Struts excluded URL to an Action not working</li>
  <li>WW-5271 - Select tag NOT working when using list=”#{ … }”</li>
  <li>WW-5272 - java.lang.UnsupportedOperationException in the Time component</li>
  <li>WW-5276 - Cleanup method of request is not called</li>
  <li>WW-5289 - Execute and Wait Interceptor prevents JVM shutdown</li>
  <li>WW-5295 - s:date ignores LocalTime</li>
  <li>WW-5296 - Wrong DTD version</li>
  <li>WW-5301 - Impossible to select alternate default VelocityManager bean</li>
  <li>WW-5302 - Autogenerated html ID bases on unevaluated value of the name/action/method attributes</li>
  <li>WW-5307 - Confusing documentation about ognl</li>
  <li>WW-5309 - NamedVariablePatternMatcher throws when pattern begins with a variable</li>
  <li>WW-5310 - s:url does not handle equal sign correctly</li>
  <li>WW-5311 - NamedVariablePatternMatcher throws an IllegalArgumentException when named variable is not the last part of the sequence</li>
  <li>WW-5312 - ExecuteAndWaitInterceptor inconsistent wait processing behaviour</li>
</ul>

<p><strong>New Feature</strong></p>

<ul>
  <li>WW-5275 - Allow to configure more flexible Content-Security-Policy</li>
</ul>

<p><strong>Improvement</strong></p>

<ul>
  <li>WW-4404 - Implement HttpInterceptor</li>
  <li>WW-5196 - Make RequestMap and ApplicationMap to use generics, also correct SessionMap to always be of type &lt;String, Object&gt;</li>
  <li>WW-5243 - Removes support for “struts.mapper.action.prefix.crossNamespaces”</li>
  <li>WW-5251 - Remove deprecated interfaces used with ServletConfigInterceptor</li>
  <li>WW-5253 - Remove deprecated methods from DefaultUrlHelper</li>
  <li>WW-5261 - Refactor TagUtils#getStack()</li>
  <li>WW-5262 - Extract excluded classes and beans out of struts-default.xml</li>
  <li>WW-5264 - Extract XSLT result into a dedicated plugin</li>
  <li>WW-5265 - Allow removal of a single/specific container provider</li>
  <li>WW-5266 - Add configuration option for a per-file max size for  multipart requests</li>
  <li>WW-5268 - Add configuration option to exempt classes from OGNL  package exclusions</li>
  <li>WW-5273 - Support fileupload using native Servlet API 3.1 logic</li>
  <li>WW-5280 - Cleanup NoParameters interfaces</li>
  <li>WW-5283 - Update Struts Archetypes</li>
  <li>WW-5285 - Upgrade commons-fileupload to ver 1.5 and add option to  limit number of accepted files</li>
  <li>WW-5288 - Make excluded package exemption logic more strict</li>
  <li>WW-5290 - Refactor ConfigurationManager</li>
  <li>WW-5292 - Allow overriding of Operations classes in two filter setup  and assorted clean up</li>
  <li>WW-5293 - Allow loading XML configuration from other than filesystem</li>
  <li>WW-5304 - Drop deprecated methods from ActionContext</li>
  <li>WW-5308 - Add minlength and maxlength to textarea on javatemplates plugin</li>
  <li>WW-5314 - Do not log warnings for bad user input from JakartaMultiPartRequest</li>
</ul>

<p><strong>Task</strong></p>

<ul>
  <li>WW-5278 - Clean up duplicated code across ActionValidatorManagers</li>
  <li>WW-5279 - Improve readability of XmlConfigurationProvider class</li>
  <li>WW-5284 - Further clean up ActionValidatorManager implementations</li>
  <li>WW-5298 - Clean up StrutsVelocityContext</li>
  <li>WW-5299 - Clean up ActionChainResult</li>
  <li>WW-5300 - Make Dispatcher methods overridable</li>
</ul>

<p><strong>Dependency</strong></p>

<ul>
  <li>WW-5269 - Upgrade Jackson to version 2.14.1</li>
  <li>WW-5274 - Mark Pell Multipart plugin as deprecated</li>
  <li>WW-5277 - Upgrade Freemarker to version 3.2.32</li>
</ul>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+6.2.0">Version Notes</a> to find more details about performed
bug fixes and improvements.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20230613-1">13 June 2023 - Apache Struts version 6.1.2.1 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 6.1.2.1 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>This version addresses two potential <strong>security vulnerabilities</strong> described in <a href="https://cwiki.apache.org/confluence/display/WW/S2-063">S2-063</a> 
and <a href="https://cwiki.apache.org/confluence/display/WW/S2-064">S2-064</a> - please read the mentioned security bulletins for more details. 
This is a drop-in replacement and upgrade should be straightforward.</p>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+6.1.2.1">Version Notes</a> to find more details about performed
bug fixes and improvements. Also, a dedicated <a href="https://cwiki.apache.org/confluence/display/WW/Struts+2.5+to+6.0.0+migration">migration guide</a>
has been prepared.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20230613-2">13 June 2023 - Apache Struts version 2.5.31 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 2.5.31 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>This version addresses two potential <strong>security vulnerabilities</strong> described in <a href="https://cwiki.apache.org/confluence/display/WW/S2-063">S2-063</a>
and <a href="https://cwiki.apache.org/confluence/display/WW/S2-064">S2-064</a> - please read the mentioned security bulletins for more details.
This is a drop-in replacement and upgrade should be straightforward.</p>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+2.5.31">Version Notes</a> to find more details about performed
bug fixes and improvements</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<h4 id="a20230310">10 March 2023 - Apache Struts version 6.1.2 General Availability</h4>

<p>The Apache Struts group is pleased to announce that Apache Struts version 6.1.2 is available as a “General Availability”
release. The GA designation is our highest quality grade.</p>

<p>The Apache Struts is an elegant, extensible framework for creating enterprise-ready Java web applications.
The framework has been designed to streamline the full development cycle, from building, to deploying,
to maintaining applications over time.</p>

<p>Below is a full list of all changes:</p>

<p><strong>Improvement</strong></p>

<ul>
  <li>WW-5285 - Upgrade commons-fileupload to ver 1.5 and add option to limit number of accepted files</li>
</ul>

<blockquote>
  <p>Please read the <a href="https://cwiki.apache.org/confluence/display/WW/Version+Notes+6.1.2">Version Notes</a> to find more details about performed
bug fixes and improvements. Also, a dedicated <a href="https://cwiki.apache.org/confluence/display/WW/Struts+2.5+to+6.0.0+migration">migration guide</a> 
has been prepared.</p>
</blockquote>

<p><strong>All developers are strongly advised to perform this upgrade.</strong></p>

<p>The 6.x series of the Apache Struts framework has a minimum requirement of the following specification versions:
Servlet API 3.1, JSP API 2.1, and Java 8.</p>

<p>Should any issues arise with your use of any version of the Struts framework, please post your comments to the user list,
and, if appropriate, file <a href="https://issues.apache.org/jira/projects/WW/">a tracking ticket</a>.</p>

<p>You can download this version from our <a href="download.cgi#struts-ga">download</a> page.</p>

<p class="pull-right">
  Skip to: <a href="announce-2022">Announcements - 2022</a>
</p>

<p class="pull-left">
  <strong>Next:</strong>
  <a href="kickstart">Kickstart FAQ</a>
</p>

  </section>
</article>


<footer class="container">
  <div class="col-md-12">
    Copyright &copy; 2000-2022 <a href="https://www.apache.org/">The Apache Software Foundation</a>.
    Apache Struts, Struts, Apache, the Apache feather logo, and the Apache Struts project logos are
    trademarks of The Apache Software Foundation. All Rights Reserved.
  </div>
  <div class="col-md-12">Logo and website design donated by <a href="https://softwaremill.com/">SoftwareMill</a>.</div>
</footer>

<script>!function (d, s, id) {
  var js, fjs = d.getElementsByTagName(s)[0];
  if (!d.getElementById(id)) {
    js = d.createElement(s);
    js.id = id;
    js.src = "//platform.twitter.com/widgets.js";
    fjs.parentNode.insertBefore(js, fjs);
  }
}(document, "script", "twitter-wjs");</script>
<script src="https://apis.google.com/js/platform.js" async="async" defer="defer"></script>

<div id="fb-root"></div>

<script>(function (d, s, id) {
  var js, fjs = d.getElementsByTagName(s)[0];
  if (d.getElementById(id)) return;
  js = d.createElement(s);
  js.id = id;
  js.src = "//connect.facebook.net/en_GB/all.js#xfbml=1";
  fjs.parentNode.insertBefore(js, fjs);
}(document, 'script', 'facebook-jssdk'));</script>


</body>
</html>
