Tomcat Server Configuration Automation Reinforcement

目录

. 引言
. 黑客针对WEB Server会有那些攻击面
. 针对Tomcat Server可以做的安全加固
. Managing Security Realms with JMX
. 实现对TOMCAT配置信息的动态修改(hot dynamic edit)
. Tomcat manager弱口令入侵部署WEBSHELL防御
. Tomcat远程war包部署攻防

0. 引言

most weaknesses in Apache Tomcat come from incorrect or inappropriate configuration. It is nearly always possible to make Tomcat more secure than the default out of the box installation.
WEB容器(WEB Server)是运行在操作系统上的一个应用级软件，对服务器的配置(config文件)进行加固处理是防御WEB相关漏洞的一个有效的手段。对于实现WEB服务器的配置加固，我们需要达到如下几个目标

. 使用加固后的标准版的配置文件(config file)对原始文件进行替换
. 对配置文件替换操作需要实现回滚操作
. 对配置文件进行加固后，需要能立刻生效，并对当前服务器的业务运行产生尽量少的影响
    ) 配置文件热加载(hot reload)
    ) 重启web server

Relevant Link:

https://www.owasp.org/index.php/Securing_tomcat

1. 黑客针对WEB Server会有那些攻击面

黑客攻击网站时，有一个简单的杀手锏，即寻找常见的漏洞，例如

. 使用WEB Server默认的账户
    ) tomcat默认安装后，后台管理界面的登录采用basic authentication的身份验证方式，而这个默认的账户是系统默认设置的tomcat、tomcat(在tomcat-users.xml文件中)

. 帐户密码很弱或者没有
    ) IIS使用内置或默认帐户。黑客一般会寻找这些帐户。如果这些账户没有从系统中删除的话，就会被发现并被更改
    ) 用户为了方便管理，常常在tomcat的后台管理界面的basic authentication登录中使用弱口令，很容易遭到黑客的暴力破解

. 大量的开放端口
每一位访问者，无论是善意还是恶意，都可以通过开放端口连接到站点和系统。在默认情况下，Windows与IIS的开放端口远远多于为了正常运行所需的端口。保持系统的开放端口应该保持最少数量，这一点很重要。所有其他的端口都需要关闭。
    ) Windows License Logging Service溢出
　　    通过发送一条经过特殊格式化的信息到运行License Logging Service的Web服务器，黑客能够对未检查的缓冲区进行攻击。这可以导致服务失效，为黑客打开一个开放端口，从而使用“System”权限在服务器上执行代码。
　　    ) 微软服务器信息块(SMB)漏洞
　　    服务器信息块协议被Windows用于文件和打印机的共享以及计算机之间的通信。黑客的SMB服务器可以利用这项功能来使用"System"权限，对客户机执行任意代码。
　　
. 服务器扩展、模块的漏洞
    ) ISAPI扩展缓冲区溢出
　　    IIS安装后，就会自动安装多个Internet ISAPI服务器扩展。ISAPI服务器扩展实际上是动态链接库(DLL)，是用来增强IIS服务器的功能的。一些动态链接库，比如idq.dll ，包含编程错误，可让黑客发送数据到ISAPI服务器扩展，这就是"缓冲区溢出"攻击 因此，攻                

. WEB脚本漏洞
针对WEB脚本(asp、php、jsp)的攻击原则上来说是代码层的攻击，但是从纵深防御的原则上来看，我们在服务器的代码执行层面也是可以部署一些限制的
    ) 利用执行路径限制，将当前web路径强制限定在某个路径下
    ) API白名单、黑名单限制

0x1: Tomcat默认配置

. tomcat-users.xml
Tomcat默认配置了2个角色: tomcat、role1
tomcat默认配置了3个帐号: both、tomcat、role1的默认密码都是tomcat
/*
<user username="tomcat" password="tomcat" roles="tomcat"/>
<user username="both" password="tomcat" roles="tomcat,role1"/>
<user username="role1" password="tomcat" roles="role1"/>
*/
但是这些帐号都不具备直接部署应用的权限，默认需要有manager权限才能够直接部署war包，Tomcat默认需要安装Administration Web Application。Tomcat默认没有配置任何用户以及角色，没办法用默认帐号登录，在正常情况下，如果管理员需要登录manager页面使用管理以及远程部署功能，需要新增一个manager角色，并将指定帐号赋予这个角色，之后管理员才可以使用这个帐号登录manager页面

. context.xml
Tomcat的上下文，一般情况下如果用Tomcat的自身的数据源多在这里配置。找到数据源即可用对应的帐号密码去连接数据库
/*
<Context>
    <WatchedResource>WEB-INF/web.xml</WatchedResource>
    <Resource name="jdbc/u3" auth="Container" type="javax.sql.DataSource"
              maxActive="100" maxIdle="30" maxWait="10000"
              username="xxxxx" password="xxxx" driverClassName="com.mysql.jdbc.Driver"
              url="jdbc:mysql://192.168.0.xxx:3306/xxx?autoReconnect=true"/>
</Context>
*/

. server.xml
Server这个配置文件价值非常高，通常的访问端口、域名绑定和数据源可以在这里找到，如果想知道找到域名对应的目录可以读取这个配置文件。如果有用Https，其配置也在这里面能够找到 

. web.xml
项目初始化的时候会去调用这个配置文件 

0x2: manager页面部署WAR Getshell

. 查看部署情况。从"tomcat-users.xml"文件中、或者直接通过猜解默认密码获取的具有管理员权限的用户名和密码，验证通过后进入部署管理页面
. 部署管理页面中可以"Start"(启动)、"Stop"(停止)、"Reload"(重载)、"Undeploy"(删除部署)已经部署的项目，单击"Undeploy"会对文件进行物理删除
. 部署的文件夹是以*.war文件的名称，例如上传的文件是job.war，则在Tomcat目录中会对应生成一个"job"文件夹
. 部署JSP WebShell后门程序。在部署管理页面的下方有一个"WAR file to deploy"，单击浏览选择一个已经设置好的后门war文件，在本例中的后门程序为job.war，单击“deploy”将该文件部署到服务器上
. 上传文件后，tomcat会自动进行部署并运行
http://127.0.0.1:8080/job/job.jsp[/url] 

Relevant Link:

http://www.searchsecurity.com.cn/showcontent_11382.htm
http://www.searchsecurity.com.cn/guide/webseversetting.htm
http://blog.csdn.net/ablipan/article/details/7840103
http://drops.wooyun.org/tips/604
http://oss.org.cn/ossdocs/apache/tomcat/l-tomcat.htm

2. 针对Tomcat Server可以做的安全加固

0x1:  升级到官方最新版

The first step is to make sure you are running the latest stable releases of software

1. Java Runtime Environment (JRE) or SDK
2. Tomcat
3. Third-party libraries

Many software projects, including Tomcat and Java, maintain multiple branches. New features are added to more recent branches, the older branches receive only bug-fixes and security updates. This allows developers to advance the software without disrupting production environments. Be aware of which branch you have deployed, and track new releases within that branch.
For example, if you are running Tomcat
5.5.26, you should watch for new versions within the 5.5 branch (e.g.
5.5.27) and upgrade to this bug-fix version. If you are content to stick
with the Tomcat 5.5 branch then it is not necessary to upgrade to a new
6.0.18 version.

0x2: 最小权限默认安装

. UNIX
    ) Create a tomcat user/group
    ) Download and unpack the core distribution (referenced as CATALINA_HOME from now on)
    ) Change CATALINA_HOME ownership to tomcat user and tomcat group
    ) Change files in CATALINA_HOME/conf to be readonly ()
    ) Make sure tomcat user has read/write access to /tmp and write ( - yes, only write/execute) access to CATALINA_HOME/logs
//值得注意的是，在LINUX/UNIX系统上，tomcat可以实现降权运行

. Windows
    ) Download the core windows service installer
    ) Start the installation, click Next and Agree to the licence
    ) Untick native, documentation, examples and webapps then click Next
    ) Choose an installation directory (referenced as CATALINA_HOME from now on), preferably on a different drive to the OS.
    ) Choose an administrator username (NOT admin) and a secure password that complies with your organisations password policy.
    ) Complete tomcat installation, but do not start service.

. Common
    ) Remove everything from CATALINA_HOME/webapps (ROOT, balancer, jsp-examples, servlet-examples, tomcat-docs, webdav)
    ) Remove everything from CATALINA_HOME/server/webapps (host-manager, manager). Note that it can be useful to keep the manager webapp installed if you need the ability to redeploy without restarting Tomcat. If you choose to keep it please read the section on Securing the Manager WebApp.
    ) Remove CATALINA_HOME/conf/Catalina/localhost/host-manager.xml and CATALINA_HOME/conf/Catalina/localhost/manager.xml (again, if you are keeping the manager application, do not remove this).
    ) Make sure the default servlet is configured not to serve index pages when a welcome file is not present. In CATALINA_HOME/conf/web.xml
/*
<servlet>
   <servlet-name>default</servlet-name>
   <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
   <init-param>
     <param-name>debug</param-name>
     <param-value>0</param-value>
   </init-param>
   <init-param>
     <param-name>listings</param-name>
     <param-value>false</param-value>  <!-- make sure this is false -->
   </init-param>
   <load-on-startup>1</load-on-startup>
 </servlet>
*/
    ) Remove version string from HTTP error messages by repacking CATALINA_HOME/server/lib/catalina.jar with an updated ServerInfo.properties file.
    ) ename CATALINA_HOME/conf/server.xml to CATALINA_HOME/conf/server-original.xml and rename CATALINA_HOME/conf/server-minimal.xml to CATALINA_HOME/conf/server.xml. The minimal configuration provides the same basic configuration, but without the nested comments is much easier to maintain and understand. Do not delete the original file as the comments make it useful for reference if you ever need to make changes - e.g. enable SSL.
    ) Replace the server version string from HTTP headers in server responses, by adding the server keyword in your Connectors in CATALINA_HOME/conf/server.xml
/*
 <Connector port="8080" ...
            server="Apache" />  <!-- server header is now Apache -->
*/

0x3: 错误页面版本隐藏

Remove version string from HTTP error messages by repacking CATALINA_HOME/server/lib/catalina.jar with an updated ServerInfo.properties file. Note that making this change may prevent Lambda Probe (popular Tomcat monitoring webapp) to initialise as it cannot determine the Tomcat version.

. unpack catalina.jar
cd CATALINA_HOME/server/lib
jar xf catalina.jar org/apache/catalina/util/ServerInfo.properties

. update ServerInfo.properties by changing server.info line to server.info=Apache Tomcat

. repackage catalina.jar
jar uf catalina.jar org/apache/catalina/util/ServerInfo.properties

. remove CATALINA_HOME/server/lib/org (created when extracting the ServerInfo.properties file)

0x4: HTTP响应版本隐藏

Replace the server version string from HTTP headers in server responses, by adding the server keyword in your Connectors in CATALINA_HOME/conf/server.xml

 <Connector port="" ...
            server="Apache" />  <!-- server header is now Apache -->

0x5: Protecting the Shutdown Port

Tomcat uses a port (defaults to 8005) as a shutdown port. What this means is that to stop all webapps and stop Tomcat cleanly the shutdown scripts make a connection to this port and send the shutdown command. This is not as huge a security problem as it may sound considering the connection to the port must be made from the machine running tomcat(必须从本机发起这个关闭请求，无法通过RCE完成) and the shutdown command can be changed to something other than the string SHUTDOWN. However, it's wise to take the following precautions

. if you are running a publicly accessible server make sure you prevent external access to the shutdown port by using a suitable firewall.
. change the shutdown command in CATALINA_HOME/conf/server.xml and make sure that file is only readable by the tomcat user.
/*
 <Server port="8005" shutdown="ReallyComplexWord">
*/

0x6: Securing Manager WebApp

1. By default there are no users with the manager role. To make use of the manager webapp you need to add a new role and user into the CATALINA_HOME/conf/tomcat-users.xml file.

<role rolename="manager"/>
<user username="darren" password="ReallyComplexPassword" roles="manager"/>

2. When you access the password-protected manager webapp, the password you enter will be sent over the network in (nearly) plain text, ripe for interception. By using an SSL connection instead, you can transport the password securely

Fortunately, this is simple to accomplish. After configuring an SSL Connector in server.xml (see your Tomcat documentation), simply add the following to CATALINA_HOME/webapps/manager/WEB-INF/web.xml inside of the <security-constraint></security-constraint> tags.

<user-data-constraint>
     <transport-guarantee>CONFIDENTIAL</transport-guarantee>
  </user-data-constraint>

This will force an SSL connection to be used when accessing the manager webapp. Plus, with a little more work, the SSL Connector can be configured to require a client certificate.

3. Using a valve to filter by IP or hostname to only allow a subset of machines to connect (i.e. LAN machines). Add one of the following within the Context tag in CATALINA_HOME/conf/Catalina/localhost/manager.xml

<!-- allow only LAN IPs to connect to the manager webapp -->
<!-- contrary to the current Tomcat 5.5 documation the value for allow is not a regular expression -->
<!-- future versions may have to be specified as \.\.\.* -->
<Valve className="org.apache.catalina.valves.RemoteAddrValve" allow="192.168.1.*" />

<!-- allow only LAN hosts to connect to the manager webapp -->
<!-- contrary to the current Tomcat 5.5 documation the value for allow is not a regular expression -->
<!-- future versions may have to be specified as *\.localdomain\.com -->
<Valve className="org.apache.catalina.valves.RemoteHostValve" allow="*.localdomain.com" />

4. Rename the manager webapp

This is 'security through obscurity'. Although widely maligned, obscurity is a useful adjunct security measure on a one-off basis. A would-be attacker seeking to gain access to the manager webapp will look for it in its usual location. By renaming it, you force the attacker to guess URLs or assume that it is not installed. It is important to note that you are not relying upon this obscurity for security, but rather using it as a backup measure in case someone finds a way around the remote valve filter you have configured as described above.
To rename the manager webapp, decide on the new name (we'll use foobar in this example), and:

. Move CATALINA_HOME/conf/Catalina/localhost/manager.xml to CATALINA_HOME/conf/Catalina/localhost/foobar.xml
. Update the docBase attribute within CATALINA_HOME/conf/Catalina/localhost/foobar.xml to ${catalina.home}/server/webapps/foobar
. Move CATALINA_HOME/server/webapps/manager to CATALINA_HOME/server/webapps/foobar

0x7: Logging

As of tomcat 5.5 logging is now handled by the commons-logging framework allowing you to choose your preferred logging implementation - log4j or standard JDK logging. By default the standard JDK logging is used (or a compatible extension called juli to be more precise), storing daily log files in CATALINA_HOME/logs.
By default additional webapp log entries are added to CATALINA_HOME/logs/catalina.YYYY-MM-DD.log and System.out/System.err are redirected to CATALINA_HOME/logs/catalina.out. To place webapp log entries in individual log files create a logging.properties file similar to the following within CATALINA_HOME/webapps/APP_NAME/WEB-INF/classes (change the APP_NAME value to create a unique file for each webapp)

handlers = org.apache.juli.FileHandler, java.util.logging.ConsoleHandler
org.apache.juli.FileHandler.level = ALL
org.apache.juli.FileHandler.directory = ${catalina.base}/logs
org.apache.juli.FileHandler.prefix = APP_NAME.

0x8: Java Security

. Running Tomcat with a Security Manager
The default Tomcat configuration provides good protection for most requirements, but does not prevent a malicious application from compromising the security of other applications running in the same instance. To prevent this sort of attack, Tomcat can be run with a Security Manager enabled which strictly controls access to server resources. Tomcat documentation has a good section on enabling the Security Manager.
It's always a good idea to start tomcat with the "-security" parameter. This also makes sure (among other things), that a webapplication isn't able to read/write/execute any file on the local filesystem without enabling it in the catalina.policy file. This effectively stops web shells like described here from working.

0x9: 后台管理界面登录密码强化

这个问题属于口令安全的范畴，我在其他的文章中涉及到了这方面的知识

http://www.cnblogs.com/LittleHann/p/3567908.html
http://www.cnblogs.com/LittleHann/p/3541989.html
http://www.cnblogs.com/LittleHann/p/3543681.html

0x10: 禁用tomcat manage管理页面

禁用Tomcat Manage的后台管理页面，可以通过修改tomcat-users.xml配置文件中和角色，账户身份有关的配置来实现，在研究如何禁用管理界面之前，我们先来学习一下tomcat的身份验证机制

1. tomcat中的Reaml身份验证、管理

. UserDatabaseRealm
//className="org.apache.catalina.realm.UserDatabaseRealm"
UserDatabaseRealm is an implementation of the Tomcat Realm interface that uses a JNDI resource to store user information. By default, the JNDI resource is backed by an XML file. It is not designed for large-scale production use. At startup time, the UserDatabaseRealm loads information about all users, and their corresponding roles, from an XML document (by default, this document is loaded from $CATALINA_BASE/conf/tomcat-users.xml). The users, their passwords and their roles may all be editing dynamically, typically via JMX. Changes may be saved and will be reflected in the XML file.
对于使用 的身份验证，可以使用JMX API接口动态的修改tomcat的身份认证配置，并自动映射到磁盘上的配置文件tomcat-users.xml

. JDBCRealm
//className="org.apache.catalina.realm.JDBCRealm
JDBCRealm is an implementation of the Tomcat Realm interface that looks up users in a relational database accessed via a JDBC driver. There is substantial configuration flexibility that lets you adapt to existing table and column names, as long as your database structure conforms to the following requirements:
    ) There must be a table, referenced below as the users table, that contains one row for every valid user that this Realm should recognize.
    ) The users table must contain at least two columns (it may contain more if your existing applications required it):
    ) Username to be recognized by Tomcat when the user logs in. Password to be recognized by Tomcat when the user logs in. This value may in cleartext or digested
    ) The user roles table must contain at least two columns (it may contain more if your existing applications required it):
        4.1) Username to be recognized by Tomcat (
        4.2) //27Role name of a valid role associated with this user.
    /*
    create table users (
      user_name         varchar(15) not null primary key,
      user_pass         varchar(15) not null
    );

    create table user_roles (
      user_name         varchar(15) not null,
      role_name         varchar(15) not null,
      primary key (user_name, role_name)
    );
    */
When a user attempts to access a protected resource for the first time, Tomcat will call the authenticate() method of this Realm. Thus, any changes you have made to the database directly (new users, changed passwords or roles, etc.) will be immediately reflected.
对于JDBCRealm来说，对保存账户信息的数据库的修改，会实时的映射到tomcat中

. DataSourceRealm
//className="org.apache.catalina.realm.DataSourceRealm"
DataSourceRealm is an implementation of the Tomcat Realm interface that looks up users in a relational database accessed via a JNDI(JNDI(Java Naming and Directory Interface,Java命名和目录接口) named JDBC DataSource.
本质上和JDBCRealm认证原理类似，差别在于使用JNDI接口进行数据源数据获取

. JNDIRealm
//className="org.apache.catalina.realm.JNDIRealm"
JNDIRealm is an implementation of the Tomcat Realm interface that looks up users in an LDAP directory server accessed by a JNDI provider (typically, the standard LDAP provider that is available with the JNDI API classes). The realm supports a variety of approaches to using a directory for authentication.

. MemoryRealm
MemoryRealm is a simple demonstration implementation of the Tomcat Realm interface. It is not designed for production use. At startup time, MemoryRealm loads information about all users, and their corresponding roles, from an XML document (by default, this document is loaded from $CATALINA_BASE/conf/tomcat-users.xml). Changes to the data in this file are not recognized until Tomcat is restarted.

. JAASRealm
//className="org.apache.catalina.realm.JAASRealm"
JAASRealm is an implementation of the Tomcat Realm interface that authenticates users through the Java Authentication & Authorization Service (JAAS) framework which is now provided as part of the standard Java SE API.

. CombinedRealm
//className="org.apache.catalina.realm.CombinedRealm"
CombinedRealm is an implementation of the Tomcat Realm interface that authenticates users through one or more sub-Realms.
Using CombinedRealm gives the developer the ability to combine multiple Realms of the same or different types. This can be used to authenticate against different sources, provide fall back in case one Realm fails or for any other purpose that requires multiple Realms.
Sub-realms are defined by nesting Realm elements inside the Realm element that defines the CombinedRealm. Authentication will be attempted against each Realm in the order they are listed. Authentication against any Realm will be sufficient to authenticate the user.

. LockOutRealm
//className="org.apache.catalina.realm.LockOutRealm"
LockOutRealm is an implementation of the Tomcat Realm interface that extends the CombinedRealm to provide lock out functionality to provide a user lock out mechanism if there are too many failed authentication attempts in a given period of time.
To ensure correct operation, there is a reasonable degree of synchronisation in this Realm.
This Realm does not require modification to the underlying Realms or the associated user storage mechanisms. It achieves this by recording all failed logins, including those for users that do not exist. To prevent a DOS by deliberating making requests with invalid users (and hence causing this cache to grow) the size of the list of users that have failed authentication is limited.
Sub-realms are defined by nesting Realm elements inside the Realm element that defines the LockOutRealm. Authentication will be attempted against each Realm in the order they are listed. Authentication against any Realm will be sufficient to authenticate the user.

我们重点来研究一下tomcat默认的身份验证方式，UserDatabaseRealm的相关知识

...
<Realm className="org.apache.catalina.realm.LockOutRealm">
    <!-- This Realm uses the UserDatabase configured in the global JNDI
         resources under the key "UserDatabase".  Any edits
         that are performed against this UserDatabase are immediately
         available for use by the Realm.  -->
    <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase"/>
</Realm>
...

UserDatabaseRealm类接口

public class UserDatabaseRealm
extends RealmBase
//Implementation of Realm that is based on an implementation of UserDatabase made available through the global JNDI resources configured for this instance of Catalina. Set the resourceName parameter to the global JNDI resources name for the configured instance of UserDatabase that we should consult.

UserDatabaseRealm is an implementation of the Tomcat Realm interface that uses a JNDI resource to store user information. By default, the JNDI resource is backed by an XML file. It is not designed for large-scale production use. At startup time, the UserDatabaseRealm loads information about all users, and their corresponding roles, from an XML document (by default, this document is loaded from $CATALINA_BASE/conf/tomcat-users.xml). The users, their passwords and their roles may all be editing dynamically, typically via JMX. Changes may be saved and will be reflected in the XML file.

2. tomcat中用户角色

tomcat采用"用户角色"的方式对用户的访问权限进行管理，每个用户都被划分到了一个"用户角色"中，toncat的默认预设角色有

. manager-gui
allows access to the HTML GUI and the status pages
也就是我们常用到的
http://localhost:8080/manager/html

. manager-script
allows access to the text interface and the status pages

. manager-jmx
allows access to the JMX proxy and the status pages

. manager-status
allows access to the status pages only

结合以上知识，我们可以得出如果需要对tomcat manager页面进行禁用，可以采取如下的方法

. 将tomcat-users.xml中的<user .../>节点中，设置为"manager-gui"的账户全部修改为"tomcat"
因为只有manager-gui这个role才具有访问tomcat web后台界面的权限，因此，这样实现对tomcat后台页面的禁用

. 修改403.jsp页面
对tomcat-users.xml文件进行修改后，管理员在使用原始的帐号密码登录后台的时候，会被Realm验证模块拒绝，显示403.jsp页面。我们需要在这个页面显示我们的修复动作和可能产生的后果，并告知修改回滚的接口地址

. 修复消息通知推送
通过手机短信的方式通知到管理员tomcat的后台管理界面已经被禁用

3. 删除\webapps\manager\WEB-INF\web.xml文件

Relevant Link:

http://tomcat.apache.org/tomcat-8.0-doc/index.html
http://tomcat.apache.org/tomcat-8.0-doc/realm-howto.html
http://www.cnblogs.com/lanhuahua/archive/2011/08/10/2133685.html
http://blog.csdn.net/feng88724/article/details/7164983
https://tomcat.apache.org/tomcat-7.0-doc/api/org/apache/catalina/realm/UserDatabaseRealm.html

011: 禁用tomcat manager管理界面的WAR Remote Deploy远程部署

0x12: 禁止列目录(index travel)

<init-param>
    <param-name>listings</param-name>
    <param-value>false</param-value>
</init-param>

Relevant Link:

https://www.owasp.org/index.php/Securing_tomcat
http://tomcat.apache.org/tomcat-7.0-doc/security-howto.htm
http://media.techtarget.com/tss/static/articles/content/TomcatSecurity/TomcatSecurity.pdf
https://www.mulesoft.com/tcat/tomcat-security

3. Managing Security Realms with JMX(java management extensions)

和IIS的自动化API操作类似，tomcat同样提供了对外暴露的安全配置接口

//IIS API automatic config相关知识请参阅
http://www.cnblogs.com/LittleHann/p/3988923.html

Java Management Extensions, or JMX, is a Java technology designed for remote administration and monitoring of Java components.  All versions of Tomcat 5.x or later natively support the JMX protocol.

整个tomcat的安全配置体系架构可以分为一个三层的结构

. the Instrumentation Level
The Instrumentation Level contains the components and resources that you would like to manage.  These resources are represented by one or more specialized JavaBeans known as Managed Beans, or MBeans for short
MBeans are Java Beans that implement additional components which allow them to be managed and monitored via the JMX framework.  Each MBean represents a single resource running on the JVM, which is exposed for remote management using JMX.
在这一层就是所谓的providers MBeans

. the Agent Level
There are a few different types of MBeans, each with different functionalities, which offer a greater degree flexibility when designing your administrative framework.  Any MBean that you wish to expose is registered with the MBeanServer, which makes up JMX's Agent Level.
The Agent Level is composed of an intermediate agent called MBeanServer.  The job of this layer is to receive requests or commands from the Remote Management Level, and relay them to the appropriate MBean.  It also can receive notifications from its MBeans, such as state changes, and forward them to the Remote Management Layer.
在这一层就是所谓的security service(APIS)

. the Remote Management Level
The Remote Management Layer is made up of client programs, connectors, and adaptors, and allows the user to send requests to the Agent layer for relay and receive the results of these requests.  Users can connect to the MBeanServer either
    ) through a connector, using a client program such as JConsole and a protocol such as RMI or IIOP
    对应于tomcat-users.xml中的manager-jmx role

    ) or through an adaptor, which adapts the MBeanServer API to another protocol, such as HTTP, allowing JMX to be used with custom web-based GUIs.
    对应于tomcat-users.xml中的manager-gui role
In summary, a user at the Remote Management Level sends a request or command to the Agent Level, which contacts the appropriate MBean at the Instrumentation Level, and relays the response back to the user. 

This distributed system allows users to build highly customized administrative frameworks from scratch.

0x1: Security Realms

A security realm comprises mechanisms for protecting WebLogic resources. Each security realm consists of a set of configured security providers, which are modular components that handle specific aspects of security. You can

. create a JMX client that uses the providers in a realm to add or remove security data such as users and groups.
. You can also create a client that adds or removes providers
. makes other changes to the realm configuration.

0x2: Understanding the Hierarchy of Security MBeans

Like other subsystems, the "WebLogic Server security framework" organizes its MBeans in a hierarchy that JMX clients can navigate without constructing JMX object names. However

. the set of MBean types that are available in a security realm depends on which security providers you have installed in the realm
. the set of services that each security provider enables depends on how the provider was created.

tomcat使用层次结构的MBeans对安全域进行组织管理，每个Mbeans对应于不同方面的安全配置，程序员可以通过JMX Clients连接这些Mbeans，对tomcat的对应的安全配置进行动态的读写

security providers -> security realm(一个realm可以包含多个providers) -> MBean Proxy -> security service(APIS) 

而之所以说tomcat的Mbeans是层次结构的，是由它的类继承关系决定的

Each security provider must extend a base provider type. For example

. DefaultAuthorizerMBean extends AuthorizerMBean
. any custom or third-party authorization provider also extends AuthorizerMBean.
//If a JMX client gets the value of the RealmMBean Authorizers attribute, the MBean server returns all MBeans in the realm that extend AuthorizerMBean. The JMX client can iterate through the list of providers and select one based on the value of its Name attribute or other criteria.

Base provider types can be enhanced by extending a set of optional mix-in interfaces. For example

. if an authentication provider extends the UserEditorMBean, then the provider can add users to the realm.

0x3: Security Providers(the Instrumentation Level)

我们知道，对tomcat中某个MBeans的操作实质上就是在对MBeans后面的Provider的操作，在tomcat的providers中，和安全身份认证有关的providers有

. AuthenticationProviderMBean
The base MBean for all MBean implementations that manage Authentication providers. If your Authentication provider uses the WebLogic Security SSPI to provide login services, then your MBean must extend weblogic.management.security.authentication.Authenticator. If your Authentication provider uses the WebLogic Security SPI to provide identity-assertion services, then your MBean must extend weblogic.management.security.authentication.IdentityAsserter.

. AuthenticatorMBean
The SSPI MBean that all Authentication providers with login services must extend. This MBean provides a ControlFlag to determine whether the Authentication provider is a REQUIRED, REQUISITE, SUFFICENT, or OPTIONAL part of the login sequence.

. IdentityAsserterMBean
The SSPI MBean that all Identity Assertion providers must extend. This MBean enables an Identity Assertion provider to specify the token types for which it is capable of asserting identity.

. ServletAuthenticationFilterMBean
The SSPI MBean that all Servlet Authentication Filter providers must extend. This MBean is just a marker interface. It has no methods on it.

0x4: MBean Mixin Interfaces for Security Providers

在tomcat中，providers模块是数据提供者，而MBeans则提供了对外访问的接口，用来对tomcat的配置进行动态地修改

....
. UserEditorMBean：Provides a set of methods for creating, editing, and removing users
. UserReaderMBean：Provides a set of methods for reading data about users.
. RoleEditorMBean：Provides a set of methods for creating, editing, and removing roles.
. RoleReaderMBean：Provides a set of methods for reading roles.
...

0x5: 通过JMX操作tomcat配置信息编程示例

连接tomcat的JMX Proxy有2种方法

. HTTP URL方式：tomcat manager内置了一个轻量级的JMP HTTP Proxy
. 使用java编写client connector/adaptor客户端程序

1. HTTP方式

The JMX Proxy Servlet is a lightweight proxy to get and set the tomcat internals

JXMProxy HTTP有以下几种操作方式

. JMX Query command
    ) look for a specific MBean by the given name
    http://localhost:8080/manager/jmxproxy/?qry=Catalina%3Atype%3DEnvironment%2Cresourcetype%3DGlobal%2Cname%3DsimpleValue
    ) locate all workers which can process requests and report their state
    http://localhost:8080/manager/jmxproxy/?qry=*%3Atype%3DRequestProcessor%2C*
    ) return all loaded servlets
    http://localhost:8080/manager/jmxproxy/?qry=*%3Aj2eeType=Servlet%2c*

. JMX Get command
    ) fetch the value of a specific MBean's attribute
    http://localhost:8080/manager/jmxproxy/?get=BEANNAME&att=MYATTRIBUTE&key=MYKEY
    ) fetch the current heap memory data:
    http://localhost:8080/manager/jmxproxy/?get=java.lang:type=Memory&att=HeapMemoryUsage
    ) fetch the current heap memory data and only want the "used" key
    http://localhost:8080/manager/jmxproxy/?get=java.lang:type=Memory&att=HeapMemoryUsage&key=used

. JMX Set command
    ) general format
    http://localhost:8080/manager/jmxproxy/?set=BEANNAME&att=MYATTRIBUTE&val=NEWVALUE
    ) turn up debugging on the fly for the ErrorReportValve
    http://localhost:8080/manager/jmxproxy/?set=Catalina%3Atype%3DValve%2Cname%3DErrorReportValve%2Chost%3Dlocalhost&att=debug&val=10

. JMX Invoke command
The invoke command enables methods to be called on MBeans
    ) general format
    http://localhost:8080/manager/jmxproxy/?invoke=BEANNAME&op=METHODNAME&ps=COMMASEPARATEDPARAMETERS
    ) call the findConnectors() method of the Service use
    http://localhost:8080/manager/jmxproxy/?invoke=Catalina%3Atype%3DService&op=findConnectors&ps=
    ) 修改指定用户的密码
    http://localhost:8080/manager/jmxproxy/?set=Users:type=User,username="test",database=UserDatabase&att=password&val=hello
    //将test这个账户的密码修改为hello

Relevant Link:

http://docs.oracle.com/cd/E11035_01/wls100/secintro/index.html
http://docs.oracle.com/cd/E11035_01/wls100/jmx/accessWLS.html#wp1112969
http://tomcat.apache.org/tomcat-8.0-doc/manager-howto.html#Using_the_JMX_Proxy_Servlet
http://tomcat.apache.org/tomcat-8.0-doc/manager-howto.html
http://tomcat.apache.org/tomcat-8.0-doc/realm-howto.html#MemoryRealm
http://docs.oracle.com/cd/E11035_01/wls100/jmx/editsecurity.html
http://www.360doc.com/content/10/1005/14/39755_58581727.shtml

2. JAVA Client Connector/adaptor方式：Creating WebLogic users programmatically from a standalone Java client

使用java编写client connector/adaptor这种方式要求服务端的tomcat服务器要开启"JMX_REMOTE_CONFIG"，即tomcat需要监听一个JMX Proxy端口，默认情况下，tomcat是不会开启这个接口的，所以要进行这个实验，我们还需要对tomcat的启动脚本增加一些额外的配置

. 先修改Tomcat的启动脚本
    ) windows下为bin/catalina.bat
    ) linux下为catalina.sh
添加以下内容
set JMX_REMOTE_CONFIG=-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port= -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false
set CATALINA_OPTS=%CATALINA_OPTS% %JMX_REMOTE_CONFIG%
/*
1. 8999是jmxremote使用的端口号
2. 第二个false表示不需要鉴权
*/

. 要注意以上语句的位置不能太后面
大概在200行左右这个位置就可以了，太前面也不行

. 启动/重启tomcat
    ) D:\tomcat\apache-tomcat-8.0.\bin
    ) catalina.bat run

aaarticlea/png;base64,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" alt="" />

我们配置了无鉴权模式的8999端口jmxproxy监听服务，现在可以开始编写java代码，通过jmx api连接到jmxproxy上了，从而对tomcat的MBeans进行动态的读写

import java.util.HashMap;
import java.util.Map;
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;

public class JMXTest
{
    public static void main(String[] args)
    {
        try
        {
           String jmxURL = "service:jmx:rmi:///jndi/rmi://127.0.0.1:8999/jmxrmi";//tomcat jmx url
           /*
             * JMXServiceURL用于标识JMXConnectorServer，它是采用以下形式的字符串
             * service:jmx:<protocol>://[[[ <host>]: <port>]/ <path>]
                    1. "protocol"
                    指定了协议，例如
                        1) rmi
                        2) iiop
                        3) jmxmp
                        4) soap
                    2. "host"(可选)
                    3. "port"(可选)
                    4. "path"(可选)
            */
           JMXServiceURL serviceURL = new JMXServiceURL(jmxURL);

           Map<String, String[]> map = new HashMap<String, String[]>();
           String[] credentials = new String[] { "monitorRole" , "QED" };
           map.put("jmx.remote.credentials", credentials);
           /*
             * The client end of a JMX API connector. An object of this type can be used to establish a connection to a connector server.
             * A newly-created object of this type is unconnected. Its connect method must be called before it can be used. However, objects created by JMXConnectorFactory.connect are already connected.
           */
           JMXConnector conneactor = JMXConnectorFactory.connect(serviceURL, map);
           MBeanServerConnection  mbsc = conneactor.getMBeanServerConnection();

           /*
           ObjectName threadObjNameSet = new ObjectName("Catalina:type=Valve,host=localhost,context=/host-manager,name=BasicAuthenticator");
           Attribute attrVal = new Attribute("stateName", "STOPED");
           mbsc.setAttribute(threadObjNameSet, attrVal);
           */

           /*
            * 填写需要获取的ObjectName对象名，即MBeans Idntifier
           */
           ObjectName threadObjName = new ObjectName("Catalina:type=Valve,host=localhost,context=/host-manager,name=BasicAuthenticator");
           String attrName = "stateName";
           //通过MBeans的getter方法获取对应的属性值
           System.out.println("password: " + mbsc.getAttribute(threadObjName, attrName));
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

aaarticlea/png;base64,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" alt="" />

可以通过URL的jmxproxy方式验证我们获得的结果

http://localhost:8080/manager/jmxproxy/?get=Catalina:type=Valve,host=localhost,context=/host-manager,name=BasicAuthenticator&att=stateName
result:
OK - Attribute get 'Catalina:type=Valve,host=localhost,context=/host-manager,name=BasicAuthenticator' - stateName = STARTED

Relevant Link:

http://whitesock.iteye.com/blog/246186
http://www.programcreek.com/java-api-examples/index.php?api=javax.management.MBeanServerConnection
http://pic.dhe.ibm.com/infocenter/wxsinfo/v8r6/index.jsp?topic=%2Fcom.ibm.websphere.extremescale.doc%2Ftxsmbeanprog.html
http://blog.csdn.net/airobot008/article/details/3951524
http://sharpspeed.iteye.com/blog/2009770
http://www.blogjava.net/japper/archive/2012/09/05/387092.html

4. 实现对TOMCAT配置信息的动态修改(hot dynamic edit)

了解了tomcat jmx api编程之后，我们回到我们本文的中心，就是自动化的tomcat配置加固，即动态的修改内存中的tomcat配置，实现对tomcat的MBeans(保存tomcat所有维度信息的基本单位)配置信息的动态修改

. HTTP URL JMXPROXY
通过这种方式对tomcat的配置进行动态修改存在如下几个条件、限制
    ) 调用URL接口的用户必须本身是具有"manager-jmx"的角色，并且需要处于登录后的状态才可以调用这个接口
    ) tomcat的MBeans大多数不提供setter接口，而只提供getter接口，很多的设置是不能修改的，例如
        2.1) 取消basic认证
        2.2) 修改账户的role角色

. JAVA CLIENT JXMPROXY API
通过这种方式对tomcat的配置进行动态修改存在如下几个条件、限制
    ) 需要tomcat服务端开启了JMXPROXY端口监听服务，而tomcat默认是不开启这个端口监听的，需要手动设置并重启
    ) tomcat的MBeans大多数不提供setter接口，而只提供getter接口，很多的设置是不能修改的，例如
        2.1) 取消basic认证
        2.2) 修改账户的role角色

需要注意的是，tomcat的jmx自动化操作方式是针对需要对tomcat进行实时性能监控而产生的，所以我们会发现jmx接口中大多数是getter方法，而且不管是ur方式、还是java client方式，在默认情况下tomcat都不支持，需要额外的配置才能启用，所以，我们想要通过tomcat jmx方式对tomcat进行配置加固是有困难的

5. Tomcat manager弱口令入侵部署WEBSHELL防御

0x1: 直接删除manager页面对应的jsp文件、manager目录

或者直接删除\webapps\manager\WEB-INF\web.xml文件，同样得到禁用manager页面的效果

0x2: 修改tomcat-users.xml文件配置

. 将弱密码修改为强密码
. 取消用户的manager-gui，即降权，达到禁止用户访问manager页面的目的
//需要重启tomcat才能使新配置生效

0x3: 针对web应用的轻量级重启：修改应用中的web.xml的和身份认证、禁止登录、POST WAR的相关配置

在开始研究tomcat应用程序的web.xml配置之前，我们先针对这个思路和apache的配置进行一个类比

http://man.chinaunix.net/newsoft/Apache2.2_chinese_manual/howto/htaccess.html

在apache架构的网站应用中.htaccess文件(或者"分布式配置文件")提供了针对每个目录(web应用)改变配置的方法，即在一个特定的目录中放置一个包含指令的文件，其中的指令作用于此目录及其所有子目录

对于tomcat，我们也可以采取相同的思路，从本质上来说，manager这个后台管理界面属于一个J2EE的应用，我们可以直接修改manager目录下的web.xml文件，对其配置项进行修改禁止管理员访问，然后直接重启manager这个应用即可

1. tomcat web.xml配置

The web.xml Deployment Descriptor file describes how to deploy a web application in a servlet container such as Tomcat.
The location of the file is always the same: application root/WEB-INF/web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
        version="2.4"> 

        <!-- ========================================================== -->
        <!-- General -->
        <!-- ========================================================== --> 

        <!-- Name the application -->
        <display-name>Example App</display-name>
        <description>An example application which is used to play with some of the features of Tomcat</description> 

        <!-- This app is cluster-ready -->
        <distributable /> 

        <!-- Set timeout to  minutes -->
        <session-config>
                <session-timeout></session-timeout>
        </session-config> 

        <!-- ========================================================== -->
        <!-- Custom Tag Libraries -->
        <!-- ========================================================== --> 

        <!-- Taglib declarations are no longer required since JSP 2.0, see Removing taglib from web.xml -->
        <!-- The <taglib> did not need to be a child of <jsp-config> in earlier versions but is required as of Tomcat  -->
        <!-- Note that you can only have one <jsp-config> element per web.xml -->
        <!--
        <jsp-config>
                <taglib>
                        <taglib-uri>mytags</taglib-uri>
                        <taglib-location>/WEB-INF/jsp/mytaglib.tld</taglib-location>
                </taglib>
        </jsp-config>
        --> 

        <!-- ========================================================== -->
        <!-- JSP Configuration -->
        <!-- ========================================================== --> 

        <jsp-config>
                <jsp-property-group>
                        <url-pattern>*.jsp</url-pattern>
                        <include-prelude>/WEB-INF/jspf/prelude1.jspf</include-prelude>
                        <include-coda>/WEB-INF/jspf/coda1.jspf</include-coda>
                </jsp-property-group>
        </jsp-config> 

        <!-- ========================================================== -->
        <!-- Context Parameters -->
        <!-- ========================================================== --> 

        <context-param>
                <description>Enable debugging for the application</description>
                <param-name>debug</param-name>
                <param-value>true</param-value>
        </context-param>
        <context-param>
                <description>The email address of the administrator, used to send error reports.</description>
                <param-name>webmaster</param-name>
                <param-value>[e-mail]</param-value>
        </context-param> 

        <!-- ========================================================== -->
        <!-- JNDI Environment Variables -->
        <!-- ========================================================== --> 

        <env-entry>
                <env-entry-name>webmasterName</env-entry-name>
                <env-entry-value>Ms. W. Master</env-entry-value>
                <env-entry-type>java.lang.String</env-entry-type>
        </env-entry>
        <env-entry>
                <env-entry-name>cms/defaultUserSettings/recordsPerPage</env-entry-name>
                <env-entry-value></env-entry-value>
                <env-entry-type>java.lang.Integer</env-entry-type>
        </env-entry>
        <env-entry>
                <env-entry-name>cms/enableXMLExport</env-entry-name>
                <env-entry-value>false</env-entry-value>
                <env-entry-type>java.lang.Boolean</env-entry-type>
        </env-entry>
        <env-entry>
                <env-entry-name>cms/enableEmailNotifications</env-entry-name>
                <env-entry-value>true</env-entry-value>
                <env-entry-type>java.lang.Boolean</env-entry-type>
        </env-entry> 

        <!-- ========================================================== -->
        <!-- Servlets -->
        <!-- ========================================================== --> 

        <!-- Simple Servlet, provide a name, class, description and map to URL /servlet/SimpleServlet -->
        <servlet>
                <servlet-name>Simple</servlet-name>
                <servlet-class>SimpleServlet</servlet-class>
                <description>This is a simple Hello World servlet</description>
        </servlet>
        <servlet-mapping>
                <servlet-name>Simple</servlet-name>
                <url-pattern>/servlet/SimpleServlet</url-pattern>
        </servlet-mapping> 

        <!-- CMS Servlet, responds to *.cms URL's -->
        <servlet>
                <!-- Identification -->
                <servlet-name>cms</servlet-name>
                <servlet-class>com.metawerx.servlets.ContentManagementSystem</servlet-class>
                <description>This servlet handles requests for the CMS (it is a controller in an MVC architecture)</description> 

                <!-- This servlet has two parameters -->
                <init-param>
                        <param-name>debug</param-name>
                        <param-value>true</param-value>
                </init-param>
                <init-param>
                        <param-name>detail</param-name>
                        <param-value></param-value>
                </init-param> 

                <!-- Load this servlet when the application starts (call the init() method of the servlet) -->
                <load-on-startup></load-on-startup>
                <!-- <run-at>:, :, :, :</run-at> This tag is only valid for Resin -->
        </servlet> 

        <!-- Map some URLs to the cms servlet (demonstrates *.extension mapping) -->
        <servlet-mapping>
                <!-- For any URL ending in .cms, the cms servlet will be called -->
                <servlet-name>cms</servlet-name>
                <url-pattern>*.cms</url-pattern>
        </servlet-mapping> 

        <!-- Rewriter Servlet, responds to /content/* and /admin/RewriterStatistics URL's -->
        <!-- Define a servlet to respond to /content/* URL's -->
        <servlet>
                <servlet-name>rewriter</servlet-name>
                <servlet-class>com.metawerx.servlets.URLRewriter</servlet-class>
        </servlet> 

        <!-- Map some URL's to the rewriter servlet (demonstrates /path/* and specific URL mapping) -->
        <servlet-mapping>
                <!-- For any URL starting with /content/, the rewriter servlet will be called -->
                <servlet-name>rewriter</servlet-name>
                <url-pattern>/content/*</url-pattern>
        </servlet-mapping>
        <servlet-mapping>
                <!-- The rewriter servlet can also be called directly as /admin/RewriterStatistics, to return stats -->
                <servlet-name>rewriter</servlet-name>
                <url-pattern>/admin/RewriterStatistics</url-pattern>
        </servlet-mapping> 

        <!-- PathJSP Servlet, maps /shop/item/* URL's to a JSP file -->
        <!-- Define a JSP file to respond to /shop/item/* URL's -->
        <servlet>
                <servlet-name>pathjsp</servlet-name>
                <jsp-file>pathfinder.jsp</jsp-file>
        </servlet> 

        <!-- Map some URL's to the pathjsp servlet (demonstrates /long/path/* URL mapping) -->
        <servlet-mapping>
                <!-- For any URL starting with /shop/item/, the pathjsp servlet will be called -->
                <servlet-name>pathjsp</servlet-name>
                <url-pattern>/shop/item/*</url-pattern>
        </servlet-mapping> 

        <!-- ========================================================== -->
        <!-- Filters -->
        <!-- ========================================================== --> 

        <!-- Example filter to set character encoding on each request (from Tomcat servlets-examples context) -->
        <filter>
                <filter-name>Set Character Encoding</filter-name>
                <filter-class>filters.SetCharacterEncodingFilter</filter-class>
                <init-param>
                        <param-name>encoding</param-name>
                        <param-value>EUC_JP</param-value>
                </init-param>
        </filter>
        <filter-mapping>
                <filter-name>Set Character Encoding</filter-name>
                <url-pattern>/*</url-pattern>
        </filter-mapping> 

        <!-- Example filter to dump the HTTP request at the top of each page (from Tomcat servlets-examples context) -->
        <filter>
                <filter-name>Request Dumper Filter</filter-name>
                <filter-class>filters.RequestDumperFilter</filter-class>
        </filter>
        <filter-mapping>
                <filter-name>Request Dumper Filter</filter-name>
                <url-pattern>/*</url-pattern>
        </filter-mapping> 

        <!-- ========================================================== -->
        <!-- Listeners -->
        <!-- ========================================================== --> 

        <!-- Define example application events listeners -->
        <listener>
                <listener-class>com.metawerx.listener.ContextListener</listener-class>
        </listener>
        <listener>
                <listener-class>com.metawerx.listener.SessionListener</listener-class>
        </listener> 

        <!-- ========================================================== -->
        <!-- Security -->
        <!-- ========================================================== --> 

        <!-- Define roles -->
        <security-role>
                <role-name>admin</role-name>
        </security-role>
        <security-role>
                <role-name>cms_editors</role-name>
        </security-role> 

        <!-- Define a constraint to restrict access to /private/* -->
        <security-constraint> 

                <display-name>Security constraint for the /private folder</display-name> 

                <web-resource-collection> 

                        <web-resource-name>Protected Area</web-resource-name>
                        <url-pattern>/private/*</url-pattern> 

                        <!-- If you list http methods, only those methods are protected. -->
                        <!-- Leave this commented out to protect all access -->
                        <!--
                        <http-method>DELETE</http-method>
                        <http-method>GET</http-method>
                        <http-method>POST</http-method>
                        <http-method>PUT</http-method>
                        --> 

                </web-resource-collection> 

                <auth-constraint>
                        <!-- Only only administrator and CMS editors to access this area -->
                        <role-name>admin</role-name>
                        <role-name>cms_editors</role-name>
                </auth-constraint> 

        </security-constraint> 

        <!-- FORM based authentication -->
        <!-- Leave this commented out, we will use BASIC (HTTP) authentication instead -->
        <!--
        <login-config>
                <auth-method>FORM</auth-method>
                <form-login-config>
                        <form-login-page>/login.jsp</form-login-page>
                        <form-error-page>/error.jsp</form-error-page>
                </form-login-config>
        </login-config>
        -->
        <!-- This application uses BASIC authentication -->
        <login-config>
                <auth-method>BASIC</auth-method>
                <realm-name>Editor Login</realm-name>
        </login-config> 

        <!-- Define a constraint to force SSL on all pages in the application -->
        <security-constraint> 

                <web-resource-collection>
                        <web-resource-name>Entire Application</web-resource-name>
                        <url-pattern>/*</url-pattern>
                </web-resource-collection> 

                <user-data-constraint>
                        <transport-guarantee>CONFIDENTIAL</transport-guarantee>
                </user-data-constraint> 

        </security-constraint> 

        <!-- ========================================================== -->
        <!-- Error Handler -->
        <!-- ========================================================== --> 

        <!-- Define an error handler for 404 pages -->
        <error-page>
                <error-code>404</error-code>
                <location>/error404.jsp</location>
        </error-page> 

        <!-- Define an error handler for java.lang.Throwable -->
        <error-page>
                <exception-type>java.lang.Throwable</exception-type>
                <location>/errorThrowable.jsp</location>
        </error-page> 

        <!-- ========================================================== -->
        <!-- Extra MIME types -->
        <!-- ========================================================== --> 

        <!-- Set XML mime-mapping so spreadsheets open properly instead of being sent as an octet/stream -->
        <mime-mapping>
                <extension>xls</extension>
                <mime-type>application/vnd.ms-excel</mime-type>
        </mime-mapping> 

        <!-- ========================================================== -->
        <!-- Locale -->
        <!-- ========================================================== --> 

        <!-- Set Locale Encoding -->
        <locale-encoding-mapping-list>
                <locale-encoding-mapping>
                        <locale>ja</locale>
                        <encoding>Shift_JIS</encoding>
                </locale-encoding-mapping>
        </locale-encoding-mapping-list> 

        <!-- ========================================================== -->
        <!-- Welcome Files -->
        <!-- ========================================================== --> 

        <!-- Define, in order of preference, which file to show when no filename is defined in the path -->
        <!-- eg: when user goes to http://yoursite.com/ or http://yoursite.com/somefolder -->
        <!-- Defaults are provided in the server-wide web.xml file, such as index.jsp, index.htm -->
        <!-- Note: using this tag overrides the defaults, so don't forget to add them here -->
        <welcome-file-list>
                <!-- Use index.swf if present, or splash.jsp, otherwise just look for the normal defaults -->
                <welcome-file>index.swf</welcome-file>
                <welcome-file>splash.jsp</welcome-file>
                <welcome-file>index.html</welcome-file>
                <welcome-file>index.htm</welcome-file>
                <welcome-file>index.jsp</welcome-file>
        </welcome-file-list> 

</web-app>

关于jsp和web.xml配置的相关知识，请参阅

http://www.cnblogs.com/LittleHann/p/3725886.html
搜索：. web.xml基础语法

2. 配置web.xml禁用管理登录manager后台页面

要达到禁用后台登录的目的，我们可以通过对web.xml作如下修改达到目的

. <security-constraint>(fro html) -> <auth-constraint> ->  <role-name>
. 将"/html/*"(web-gui)的身份鉴权角色限制修改为一个自定义的角色名，例如"just4fun"，这个名字要保证tomcat的默认角色配置不会覆盖到，即达到对管理员的角色降权，禁止管理员
. 针对web.xml的配置修改是立刻在tomcat中生效的，tomcat会对web.xml的修改自动做reload操作
. manager页面会立刻禁止管理员登录

D:\tomcat\apache-tomcat-8.0.14\webapps\manager\WEB-INF\web.xml

修改后，立即生效

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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" alt="" />

回滚后也立即生效

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAABcYAAADsCAIAAADRmeIYAAAgAElEQVR4nO3dX4hcx5n38WNkEDjLetmwsY2lRdHdrt/YgSPw3iy80TKv7ImsaYEzsiCRYWMqxIxfa43sTZCltmVjGWyUaBDBJTaKCTgyiTwtR2NJfskaTFgkyAEHty8MIbCDlpHHyV6Nkr0878UzU1Ndp06dOt1nuufP90MjZrrPnzrn9FzUT1VPJTkAAAAAAABqSkbdAAAAAAAAgPWHSAUAAAAAAKA2IhUAAAAAAIDaiFQAAAAAAABqI1IBAAAAAACojUgFAAAAAACgNiIVAAAAAACA2ohUAAAAAAAAaiNSAQAAAAAAqI1IBQAAAAAAoDYiFQAAAAAAgNqIVAAAAAAAAGojUgEAAAAAAKiNSAUAAAAAAKC2tRipKKVG3QQAAAAAAICQNRepZFn2y8tXR90KAAAAAACAkMYiFa21UirLsr53l307nY6JVPo+GgAAAAAAwKpqcpRKmqZJkvQRrGRZdv7yf1x5///lea617nQ6J149lWWZ1rrB5gEAAAAAADSl4Yk/kqrUDVZ+efnq7K8/kgBFLztx6qx9hCzLtNJa6SzLfjA2oZN0ZvypTqejlb747ed+3WGuEAAAAAAAGJ7ma6kopZJlaZrGBCudTqfzwdKYlBOnzmqtT7x66s2f/9JskGXZr+7cmyUqS5RO0ixRc8mkTtIsSeeTR+eTR68n4xe//dx7P3lLYpdOp9P4dQEAAAAAABhNRirz8/PyQ6fTSSxpmlZO4Tlx6uz5y/9x4tVTJ06dffbF19+8+MGJU2evXLksn+pU2XmK/YPEK1mS6uV4RRKWff97TIa0NHiBAAAAAAAAouFRKnNzczdu3JCf7eEq4WAly7ITr5760fkrWuvvHHlBKX3+8n/IcJU8z3/duaqXYhT109u+niXqw6QlP5h45cOkZfIU3Ruv6CTVSl389nMz409d/PZzl96YJmcBAAAAAAADan7iz9zcnAlWsiwz1VWMdrvthBpZlrVaLaX0j85fOXHmLaXUj85fefbF13/2i06e51rpi8kTF5MnlG+Iip2t2B/NJZMyOUgn6afJhElYPvvipE5TrZRWmngFAAAAAAD0p/lIJc/z+fn5uWV5nrfb7aTAqV87NzfXbrefffF1rbVkK9858oJEKkf/z/M6UTpRasvDF5Mn5OeLyRNZoq4kj9rxSpakV5JH7XjlejJuwhQzgMVOWLIk1UplWUa2AgAAAAAA4q1KpJLn+cLCwpzFO1zFng1048aNubk5rbWMUjlx5q2JyW/JRxKpHN+ilAQry5GKPW6lOHrFVLGdSyZNnvJxsr+YsEjskiWpTtV7P3lrlW4IsNpSn1E3CgAAAAA2rNWKVIQ9XEUSk2KqIsGKDFqZm5t79sXXlVInTp39xz37TaTy1F8dP7h1wg5WzEuylWz5V8lTnKjFSVvMgkHOGJb55NGZv/wnrVSmdaY3y7JBWYTcGmo0zF56oD0o8v5xjbpRAAAAALBhDaPH5QxXccrW2lqtltZaKfW1Rw5OTH5LQg2JVFSinvqr44/cMWkiFbXlYd07YkV+0OUFVspKriyNUknST5OJz744+cd938y1+uilg1PfeKjT6WzsPrx39JBT+yYfRaQS+J4opYbThvWFSAUAAAAAhmlIPa7iPKBAh1k6+VprWUTZjlTkX3mZSMVJWHSSyrgVU79W9+YpV5JH30nGnYTFHrFyPRm3lw36NJnQSXr2+eMbcpTEmo1Uwq0aThvWF24UAAAAAAzTUHtcUjDFDlba7XagS79v374sy7yRyiN3TMqv2iqw4lRaWZ4QlNq/FgetvJOMuwVrrTWYpeTK5Qcncq3kpVWqlXrvJ29tjGzFnlBjnoVaLtkbmPhTmS4NkkB1Op1wpLJJpmXVQqQCAAAAAMM07B6XM1zF1FgJj5VIk1Qlyh6iMvaFh8zPJmGxQxYJVlSSOlVX7JIrkqeYQraSp3yYtMynHyf7Tbzy2RcnLz84YactWZJqpYd8A1eVeQoyMsVmRypOTZziktjO00zTtG6wEhjEJFqt1oAXu/EQqQAAAADAgC7Nzh6eOnR46tD09Olut7u4eCuw8Wh6XFKJ1iGzgQLZyl1b7nZGqZgYxYxhcYrXOr/qRClr0MrF5AlnxIpdhOXDpGUHKM7kIJ2k37/7Aa1SrdLZ15+eff3pTK/7eCUmUvEEXtZUoMDoklqpSjhPISzw4i4BAAAAQNji4q3FxVvdZU5icnjq0O1bt9qvnTu2HZ461O12vUcbWY9LKaWUevbF179z5IWJyW8ppb5z5AWz8mu4L50maZqkxREr9jAW7ctZCplLeiV51FvF9kryqJOnmI+k0sqnycTnDzyWK5VrdWFiTKeplF/RSXpu+9jM+FPrcT3myEhFa+1UwzFxib2NvNNqteSd+JqyZStDOfT6z7CaRaQCAAAAAEWLi7dk7Mme3bt27thWDE327N4lI1Ocj+zXnt27isHKKHtcL7/yqiQpJ8689Z0jLyil/nHP/onJb8m/S4NWkooJQWNfeMiMWHFmA9kJi9mgd9BKmvVWsTWTg0z92rlk8noybpIXnaRZb9Qi8Yp5R2rZnts+dmFi7Nyxve+8fVQppbW+9Mb0pTem1/j6QZETf8ybTqRihqjITB9h8pH4uraVmVqtA4aXYS6OjZKZTTGH1VpLMSBvg2VpcImfIi/cPni73W61WsUpVHJM717euxS+0na7Xbd5nU6nOJpMbkJ/FwsAAAAAq6Tb7R6eOlSMUfp+HZ46ZA9sGdnEnxOvnvrR+StvXvxAVk2WbEUpLT/IzCCVqhfveUGGlgSylbu23F0stuL8Ku/Y41kObp2wZwApq+SKMxvI/OqkJ85KzDJ65cLUuFSxvTA1LkNXZOObd3zj8wce++O+b0q/ViklIculN6a11pm8shEPuxgwUglMDnK69wFZlnnjCe8BYzrwZS2pXHYqcPDI0MeQcr8xl19ZV8hotVrOMcuuNK+qTRM53ieybSxxDQAAAGDkFhdvOaNOZArP9PTp6enTl2Zn5SW/ygCWyFRl545tZrjKCCIVrXXng+zEqbMSpkxMfkspLU6cOvvmxQ9OvHxSatbKVJ0X73lBXpXZSrJcyLZsiIp505kBZFexVdYQFXvBIJ2oLEklPZGhKIXYZSk9+eTvW+e2j9nhixm9Iq/PH3gsT1Wu1IWJsQsTYzJ7SF6zrz89/CdirIVIxdv5l69Kf713b0sqVxSyrytwo2qpTFXqHtZ5TN5tIq+0cgWlum1juAoAAACAUel2u/bIlMNThy7NzoYLzS4u3qo1XOXS7Gw+/EhFay0jU8xAFfl59tcfPfvi629e/ODEq6eyLLtx44ZOV0aISNLx3JeOxGcr22//solXitOCnLK19pLMasvDZrnld5Jx7yyhYp5iAhQJTczQFROmZL0LM8uQlo//ep9kKxKv6DSd2blb5g1d/PZzZ58/LjdnaL3TBif+FA8eeRXernteUvg2Zu5PrSDAe+rIRlYKt7aPY8ZEKvGabVv4gAAAAACwSi7Nzpo8JVBZtqju/KBLs7PD7vbIDIhOp/Pmz38pw1IkMjBVJ7TWsvqPLGZsT7qRbOXVvzlqD10Z+8JD4WwlWS5n60wL8s4PeuSOSVNRxZ4NZGcokrOY2MVZVtke4ZIlKktSnaSSrdibhQuyyDsXJsYypXKtMq3efmX/EFYUGjBSsY9gKmvIM5VaG5UN8M76Meslex9u5fCKukGAwzsQphgxpJbA0cqm2PSXWTQbqdRqm1R1abfbUk3Ge0BmAAEAAAAYskuzsybymJ4+XWvf6enTdUurDDVSsUuWSmnP7n9+Pvvrj+RXeT/Lsvn5ea20jPIwWYbqHSQi2YpEKpJ6SLZy15a7A51GGbpizwCy12NWiVJbHrZnAylrJWazEpDMEnLWYC7OBpI1mCUYskuu2IsxO7tI2mLilc++OGkGsFyYGj93bO+Vk5Pnju2dff3pS29Mr8bQlcEjFW8mUtyxTNmsn8Cnlf32QHuc0Kdsy7Ib1Wq1ygqyls2B8t6E8ALVppHFurC1IpXKxMdEV5VtK97zsufO9B8AAAAAQ2Pm++zcsU0m5tQ1PX261liVEQzOn5+fn5uby/PcHpaite7+5+fyc57nM+NPzSePSgDhZCtXepc0NmVQzNCVmGlByXK8Yo9eeeSOSXtC0Eot2y0PW+NWUnvGkLMGc++MobR3uErPjKG5ZDJbniJkf2rSlpXyK2kqwYqUXMmU0mmqpCxLqt7Y96TEK430XaXH7l3yxow0sbvTppfunN0ZuSB7DVJKVpSVBenjmN7GlNVwLd6NmGspWwo6soXe8zpHjolU0jR1BvKUxR/euKe4mTd5yUvCFxa6BgAAADA0psRsf3mKiFxxeXr6dLfbHXaksrCwMD8/Lz//7BcdyVAkUsmy7MqVywsLC/lypCJTYIrZihOp/Pye539+z/N2pCI/PPelIzHTgoRTe0XilWLVlYNbJ5Q1jKVsDeZinuIkQXp5qEvxU5klJJcpN+GzL07mqfrNZOvYvUtDcuzjXJgaz7T60+Wpt1/Zr7XWSr/3k7fW4+gAbwbhdOC9zy7cb/fuUraxdxBH3xNYYk5dlrxUhhEyRqa/Ky0bFxPTtrKvVtlSTeGrAAAAAIBGmGk7def7BCwu3lpcvNVdJr/aG4ymhOTCwsLc3JyMXJibm7tx40ae50opGaKS57lW2o5U7GzFVCeZSyYlU3jv7qPv3X20GKnYP8sKyuFpQcb227+8/fYvy/yg3oWBlF2Exc5EnBlD9vLMma+6rVmw+WLyhJO2FIerzCeP/vS2rzvhjk7U0gAWrXKtfjA2YRdtyZJUq3U2QKDVahWfhTPCwjuQJNxvj8kOBjm+IUOupLxIq9Uqm2LT4Bn7vtKygSoxbavVACIVAAAAAEOwuHhLRpTs2b1rmOcd5aocMgPIDFppt9syRCXP8yzLJFNwIhXzs0Qqc8nkT2/7+vUvfe/6l76ng5GK/WvMtCDjri13p0n6yB2Tx7eog1snnDWDTBVba+hKT+oh9Vbs9ERtefj4FicccfOUj5P9dp6ireEzdsVcWS3oN5Mt5wgmWLn84MR6Ga4S2cnvo2ZHzGGN+Nk6ZntvEhTgHKHBcTG1Wt532+rq40IAAAAAoBYzRCV+fZ9GjLLDY+cp8qv5eWFh4b2fvHVu+5gdqdgLFdvDNz65618/uetfIyMVeyXm5750pFa8klgVWA5unXDWYDbrB9lxifvrlodlS/tTM5ilOFxlLplUvWsVyVnMgkGy/JC3aMvMzt1S1/bSG9NZSRXVtcObZUSutpMEp8nU6udHJjt5sKZsWEzzKpcxGvxK+27bgNcLAAAAAM0a1RCVfOSRStmvMjNIaqzkSuWp+uyLk94RK+8k45/fc+Tze46YNYACkYozFciJWiReiZwcJLbf/uWv3rbdTAhy1mm285TjW1aSF7OBGa7irB9kV4qpzFPs6ipm9WW7om2u1Z8uT507tlel6Rv7npwZf2r29adnX3/alFwxKzEN+xtg8QYlrVarXVC2pm/ZkWv18yMjlUGGb8Q0r79nUetK+27bgNcLAAAAAM0yCycPUpW2P2uow2OPWMnzfG7Z2eePSy5wYWLs8wceu3nHN5wRKyZSsVfVmfmLqeIgEWdhIHvESnFy0NgXHtp++5dr9R7v2nK3DGN55I5Ju8CtXYTFLn/bW6glKk95JxmXeT0fJq3CiJhU0pabWx/9/IHHZFqQrMGslz+S1+cPPJYppVWqVZpp9T9/OC4vrfuswzqgwNLL8cpiiFr9/JhIJTDTJ01TiYGk3HLMqWtdS1itK+27bXX1cSEAAAAAEO/w1CFZi8epHTsEa7fDI5VWTKpyYWpcq1SylVypmZ27b97xjUCksjL/JXmyOBPHpCfmTYlg7MzFxCuyclD84kFFZrVmlShJW5zBLL6Ktv48Ra5L8pTe6iqpXX5lpUhtkmaJst+8nozrNL0wNf6ny1PmlWcqy5Q+PaFPT7z/7uNaq3fePjq0cStlqxfXUlZ/xLtxWUu884/sITBlQYmznnH8qb3b9Lf2cK0r7bttfTQMAAAAAFaPrJ08/Fk/+VqOVMSNGzdMsKK1nn396aURK1Pjkq18/sBjlx+cyFOll4ODLEk/Tvab6OGnt33dKTJiDwMxgcuV5FHzpneWkGz26t8clXWUB0lYkuVFhUxZFnu8iSzDXMxTzIV8mLQKhXJX1vqR16fJhE5SE8FIWRZ58zeTLWdaUKaV1irL1P/84bjkKVqr9999/P13H7/67pMzv/jhaj/lvm9jTG8/fsu8JNyxF3L2llAZJM1Zd+Vp13hRHgAAAACbiimk0uDayfHWeqSSWzOA5ubmsizTWmVanTu2dylV0erC1Ph//9tL//1vL2UlywOVRSren3WSvvo3R02AYuYBeSvO2sNY1JaHVZJ+9bbttaqxFH31tu1fvW27PbBFWdVSMqvG7XKl29TOTeaSyevJeLEsi5RZMdOC/rjvm0tzglR67eITf/7dUUlSPvv9czIJyBm0snrBSqfTGeR22bxVXb1beltSNgLFHjNSK2WIOXXZCJ3K+1Ysf1PrOH23rb+4BwAAAABWw+LiLSmkMsxIZXHx1vT06T27d62DSCXvTVXseOXyz7+bZyrTSiKVc9vHYiIV70eB95fX4lkpIjuTPCnDW4rDWOw3i1HLIGmLRC0mbVmqxrLl4cJyP6lpzPIleKYFXU/GL0yMZZn68++OXrv4hBumaCUfyTsyYmWVKq14S5OkVby3yB5OYsRkB6LssHZy0XikUpbjeK/FkAlKzmyj+CsdsG0x85KyLEvT1DsfCgAAAACa0u12h1mbVsIUGRdz+9at6yNSyfN8YWHBLANkpypv/vhlrdXzR76WZerKyUk7FjFTYOz5L/1FKoEhLfZ4lovJExK1mMK3TtpycOuEeXPsCw+pJJWXBC51q+EaErXIoczYFrtmrT0taClM0SrP1H/9+7+YKT+mQq0MWjFRi0lblqKWptdj9l5R5SrC8YM7Ko+fZZnWOjKmKVuZqHjeslWWi1uWnTpN0+Kt7nQ6ZvvVjlQCbQtkJYEWAgAAAECzhhapOGHKOotUDO+Ilbm5uStXLmutlEr//Luji+8+89FLB38z2frjvm/m6VKpEXnZ0YnUFimmKteTcYkhpHDJh0krcsaQXaXFLOpsUhUJXNSWh+2VhuwSuXbFWVnRWS2t+7P06iN2sdMWnaTfv/sBrdI8U3mmPpn5rraW+5HE5L/+/V/kUzNQxbwkYcm00irVDQUr3nKwgSDAiB9AUet2FTmXWRaUtFqtTqcjk3HKVnouu7TKBY/KxuYMIVIJty1NU6WULG6tlKpsIQAAAAA0awiRijdMWa+RSp7nCwsL8q93NtDML34owy7svECnK6nKue1jnz/wmBmQ4k1bnPfND5KYOMNeij9f8Uw4WpmJ41TAtdcqcqvSbnm4Z7miLQ+bDexBLunyS6reRiYvf3vPnWmaKpUqlcqCyiZPyaxsRX49d2zvJzPfXUlbtHr+yNc++NWVAR/lIMVZvfvaq/OIyvsQUEwEBl/v2XstZUlNrebFn67Wxv21zdtCAAAAAGjWatdSccKUPbt3yQJD6zhSsZWVWdFaz/zih/aklV/duXcpLklTyVkkLMiWE5PryfhHLx2UpXAypT5NJuaTR51Ixawl1JuYpGaxIfPmO8m4nbzIO/a6QjN/MWVWbjar+agkdRb6sQvT2rVppZBKcYSLtazy0sQfGe0iSxSZDOXBr9z7t/fc+eBX7i12gx/8yr0PfuVe2eztV/ZrlcosoU9mvqtV+vYr++3kZZBnVxZPRI5/KevqxxRtjVGW7EQu+Vw2UKXscvpYSXo4kUrgVtdtIQAAAAA0a/VW/Lk0O2unJ3t273rtmfs+/tnfffyzv3vtmfvkpOs+UjHm5+dL4hUtwUqWKalf+2kyceXkpBnAcmFq3AxOuTAxtvL+xJiZH2SvJWTyl+vJuPycJen1ZNxXDTe1tolab8ibqsjMIydVUYk6uHXCzmh0b5Jil6e1Q5Zj9z4k402uXXxCshIJR1SaymrKzx/5mlKpSlPJVv72njtND1mpVJ+e0PLv6QmtVZZVVyot4w0RisNMypQlMk4U0l8WEK7AWhl/SBu8H4WvKDBjqLKRtU632m3zthAAAAAAGifBx+GpQ00dsNvtHp465MzxefvMAclT5HX1zP3rZsWfeN7ZQHNzc3rZ2eePy3LCWqX2tCCTnrz9yn5587PfPzfzl//kFLs1ZVbMoBXzs4xqkfos3slEgdq38rM5mpOPlKyI3PPRh0mruJfJYj5O9mvnU5XK4J1MrxRMMYN63n/3cTPN55OZ78pEqnPH9kqMkqbpg1+5V2ulT08MsriyVN9w1OqEe48QE6nkee4tSSu7xwyTKatoa+/uXaso5sjeVZAqG1nrdP21rdPphNsmWq0WYQoAAACA4ZD4Y+eObY0craxsys4d2+xIRV4bLVIRZcFKMWeZnfne7Mz3tFZH/2G/jDS5noyfO7ZXUpVrF5+wh5/YqYp3tWYz/ccMTpFUxRzEGeoiSYf9vp3LOPmIswSyvaizXW1X9yYv5tTyqT3gRadplqmyVCWzytNKYVqJWsyQH63VuWN7By+nstrKIhUjs9Q9uBSjFc0uhCQH73Q6bYtUwG32LP0xhXht/d1DAAAAABjEpdlZST263e4gx+l2u85MH/tXGQizKSIV240bN2LilTlZM0jpN/Y9+YOxCa3V1XefzDJ17eITlx+c+PyBxz75+5bUtb15xzeuJ+Pal6osLU6sVabUx3+9r3dkStpHqmLijw+TlpOqZEkqs36cj5whLe9YTZVPzVyhLFG/unPvuWN7P/v9cyZJ+Z8/HNenJ2RYyvvvPm7Slpu/fdYsqCxjVd5/9/E3f/zyqB9vtcpIBQAAAACwfg1eoVbW9LEHpBTLpsjrt7P/vLkiFSHBSny8shKyLE8XujA1fmFqXKXphanxj146+NFLB79/9wMyM8geDPKrO/e+/cp+Gccxs3N377iSVBZ1NomJPX6kMlXJCmNVsuVRJx8mraz3CPbko+u9qYrzq9TrzTL1/ruPv//u45KqyGgUmf0kZVMyrW7+9tk//+6olK1988cvZ1k2Nzc36gdbjUgFAAAAADY2GU6yZ/euPvZ1BqeYMMV+mWBlz+5dmzFScSwsLERODiomLPLDlSuX55aXFtJKa6W0Uue2j0m0MbNz97lje7NMXZgaNwVZ5H2JKv78u6P/9e7/vfzghJ2eyM+SifxmsiVrD12YGDPvy2a5UrleeplP7elI1iQgN2eRY+ZanTu2126YJEEynUeCFRm6ok9PfPb75+TndruttZYkxRj1k6xGpAIAAAAAG5sZY1J37o89OOX2rVuvnrm/mKc4wYqdudC3XFG2ZlAtSyGL5c0fv6yUmhl/6tz2Mck1VJI+f+RrMrnmwsSYGeGSJemFiTFJPS4/OHFhanwpN5kan9m522w2s3P3hYkxk6p89NJBCUeuJ+My82jx3WfklWdKa6VV+sa+J7X8qNSbP355duZ7Mnnn6D/0TjtKU7286I/Wanbme2/++GW5Cu/Fzs/Pj/qhVSNSAQAAAICNzSylHL/uz+LircplfbwvO3ahbxkig1kaiVrKwpeZX/zw7PPHZXVneX3/7gekkouJNkyt3B+MTehUSTSj0lRSD1Ned3klo6WRJvLSWpUFIobMbDr7/HFnBErYushTciIVAAAAANgETD4SM1Cl2+16l/UpFqANv+hbxlookPfr1mcJ5Bpa6WKuYQ97qRV5NO7GjRv2ha8XRCoAAAAAsOF1u10Ti4S3tCf77Nm9yy5A65RKIVIZtoWFhaZCljVifn5+3cUottRn1I0CAAAAADQsZqCKPdnHropiKtSGy6kQqYySM85laJlIuFUmAzKNXP07AQAAAABAk8x0Hu/SP4uLt0xu4lSZLas+S6RSIes1wpaYXMNONCR5MR/Fly9ZjzN0AAAAAAAYhJnUc2l21n7fXil5545tZUNRrp6534lUrp65//DUobKytWsiUpFyIe1lUjRktc/YarWKJTaYEoLVlmXZyAu78LUHAAAAsCGZpX927ti2uHhL3rSL0e7ZvavW1J7XnrkvMCFolJFKWa5h9/SUUp1Op9nzaq0DZ5Rt2r1GO4BlnQo82c0cZq1qpBL5vd20Nx8AAADAhndpdtauU+vkKbWqz5oaKzt3bFtbo1TSNI3vbzebaMR07Fe1AZtE/PPdVL36VY1UIr+3m/bmAwAAANgMTA3aw1OHBslTTKRStu9oIpVaeUqziUZxiEqr1ZL/0ldKKaVks9VrwOZR6xFvnl49kQoAAAAArCq7Em1xcZ/419Uz90siU7b7CCIVb56SpqmZrVDcoMFEw5lqZDIUx+o1YPOIDFM2W69+LUQqAAAAALCxmek/fecpdiGVtRKpFPuTZX3pTqdjspVwz7DWkj1OXhP53/ij7ZoOeVmips7l3EOlVBY0hCYNro9mOLvUilTqPvpV+t42eP/XyHMEAAAAsIE5o1T6m/JTWZt2BJFKcd5NZV86TVPvNlmWKaWSAhnwUtw+TdPi+JfUIisNVW4m7TFb2m86Z5QRN4ENlFL2BnYhXvmoeHWmPZJQlN0xm33zW62W7FvcUWvtPWOr1eqvA+wcx/tQwqTB3svXWpftVflcnNvuHMr7qdxVpw3hwsmZr/qyUqrdbjtveptX69HHf29j7oB92Fp/Ys3eQAAAAADog52nmEIqh6cO9R2plNWmHUGkUuxP9tHTzvPc29NzON3Oyu1lhZTKzcyRnS5iMadwNih2XAMNjmmG95jeQRDObU97RwZ1Op3KE5XNkApwjlDrQRd74EXeuKR43uI2zpGdhhUfa2BdqrIwIub7aYTbH3PqWt/byjsQfwne+9/IDQQAAACA/pjatLJesolX+khVwrVp179C9l8AABi1SURBVMQoFel0dTqd+KEQlZ1tb5evcuO6kYrT53RyiuKhwhs4n8Y0w25M+LyBlgSWlHbUTVWc3WtFKvGXX7nvgJFKHw0o5oa1jhC/Y2AyUXj7ykilvz+xpm4gAAAAAPTHzlOcErO3b9369pkD6ztSCff90jRttVoyAafsCMX+qkyFaLfb3v8MNztWzoyoNfEn9w3uCLcz6e1/Ohs43VpzXgl6hHduTqvVir/D5rBlG5t4y3uuWjOAwvfQYe/ovf9lpYvTQi2eyjY3G6k44yy89998Rb2Terztr/Xo6078Cd+Bvv/EGrmBAAAAANCf6enTZr6PXf2k71RF9goMb1krK/4UpSUlHoqb2Z8Wx1yEO8xlQyecg5RFCYHNvJdpX5GzgXOKQK5U7Nban9aKVJyBNsUbXjm5KaCyGd5L8KY89mGLE1LCM7wGj1Qk2pBPvYtw27sXn05l5uI0r+9HH3PtMXfAOciAf2J1byAAAAAA9MEs8ePkKYFU5e0zBwKv387+81qMVCInKZjunN0tjKlu6/TowiMgBoxUnO69OVrZNdq9x0Aj697A8Kd2h9Zs473M4rmcG16rnd47UMbsVUxMKo/sZC7OpwNGKpWTYsIztop5Qa0Vf+ruW3ntldc4hD+x8O4AAAAAUFe32zWJSdnqPGb5HpnLY7avfO3csW3P7l2Hpw4dnjr02jP3mcBlNJFKHld81NtvjOlvF/uE9qfNRipliYP9vjONwtwB+83A6I8sy8yEkbKb5mxfeYu8W5rJNbaYG17G29QyZi/nGr1DGJzBGuFQo/FIJVBDp3jzi4va1HpAtR59zLVXXuMQ/sTCRYgAAAAAoJbFxVsmH3ntmfuKYcrVM/e/9sx99rLKg7927ti2c8e2UdaGLFuitcgkDjH/v13ssgbm4wwYqRS3lDftPr9zUuljO51S72qy8avGhC+/rOV1q6iGj1Z5Z7yRjVG2l/cBhdchdj5qPFIJLJ9UuUByHveA+nv0MddeeY1D+BMLrz8FAAAAALWYrKSYp1w9c//hqUPxA1LK0pPDU4e8A1vWxHIbUn3TW7nT6XStwUjFWxLFaaHdh5R4yBlnUXkJYeF9y1o+5EglcsWfmL02cKQyyKOPufbKayRSAQAAALCOFJf4sWf62CHInt27pqdPd7vdS7OztUKWw1OH5FyLi7cWF2/JEaanTx+eOrQmIhVblmWBVUXWYKTijDdpt9v2SkBSmtRukrTZ3qU4t6UYLSmlpGqp8N6csssva3mxZxsYRVIcTlLJaQaRigg/oEEefcy1V14jkQoAAACA9cKUpHXylKtn7ren+ezZvavb7do72rVXKl97du8qa8CwIxWlVMxCvGULza61Wiq5ryKJ3UjvsrVOC50VYYprMxeLywYuMD5SCS8CPTjn4JGRytqvpRJIBGJquwYe0ICPPubaK69xCH9iRCoAAAAABmdikcCSyXt277o0OxvePWbiz+LiLe9Bhh2pSHerMlgp+6/ytbbij/eY3lMHqmM4R6vscDYVqRS39K5a7ewS3sDmHDwyUml8xZ9i6d/Vi1S8yy05uwce0ICPvnjta3PFHyIVAAAAAANaXLzlLaFi5ymHpw6VRSGi2+1G1qx1BrkYo4lUhFIqsixroHyp0x8rdgjrdpi9ZwnHAWVxid2ZLw5AKOtPVnY4w2MEaq3RWwyDylIVrbWsOxM4mqPWPQy038lEinfb6fMXb7L5mnkrIjcYqYTPnpfMa4s8cl716ItnL7vn4Wt0DtL4nxiRCgAAAIABmRIqZXnK9PTpmOPY0UzgVXa0UUYqdp/K8H5qH6FYrkLm2rTb7UARlrIGRPY5ZcssyzqdTnGITVlJUScw8m5TjDCK4Uur1ep0Oubs4WusFal4W56maavVksopTs3gIUQque/mmzov3o+c3b1fg4BmE4Hi9zOxvuHeBph9B3z03lvn/d6Gr3G1/8SIVAAAAAAMoqyEislTyib7lDEBTWDuj3fHNRGphFXOOxhk37J+vrdjHDisdzNnG2+X2Ds1o+5dsvetFankvkEHAcOJVIr7Rl67KBsQVKbxQRaDPL5B9i22zREZqdRqRh9/YkQqAAAAAPpWVkLFDDaJHJ/imJ4+HU5VvDHNsCOVcJfPEehrBUqTBDp7eXSkUtwyfORie4p1VYtd/bILDKykm6ZpgxN/zC6RXeihRSoxTUrTtKxWSODrURzq0nikEn584VWBBnn03vbb4iOV8D0sHrDZGwgAAAAAZbwlVF575j5nweM+hBdX9hapHc0iylprZ0aJ08WKWRiobLll6bWW7SXnNcIFWct6ld5lXNJe3iPHbGMf0HtdxXOFWxK4QJvWumzKjDyRyuK1fV9soEneL0nM0YrJRavVkgcX/g5UfkNMWRlRLH9rjuM0IObx5QM8+sCpne9t5F/BKv2JRd5AAAAAAHCYsSR2nmKm/ASW5okULlhr5zVyotFEKras14BHaLx5eRMtbOTsIznp8K/Xq+/2jPwqGvliD3jqwe/AWvs+AAAAANiEut2ut4SKGaLS35Qfx+LirUBplcNTh/bs3rVzx7adO7bt2b1r9JEKAAAAAABAmBk/YpdQMVVU9uze1eC5pqdPByYBmReRCgAAAAAAWNPKpvxcPXN/g0NUbOFJQEQqAAAAAABgrTOr/DhTfj7+2d/JJJ3Bq6h4hScBrZtIRWvdR3HTNa7dbseU4K21UA6GYEN+G/uQZRn3AQAAAMAQlE35MYVpB1nop1JgJaD1EanUWrlGYohwWjHyqCLLMu/KQQ5Z8Xc4TUKkWt/GDYzFegAAAAAMwaXZWe+Un1Wd9ePodrvT06eLr40ZqVSmFbLCbhNN65MsNFu5WXi1WowEkUoenQkCAAAAwCAWF2+ZBZKdPMWOVC7Nzo6keesvUqlcyXU1IpXGl49NkqRy0sTm6bX2sUBv/PZ1D165ca1vY9/NGObR7GNGbsz4KQAAAABDUFaV1lk+udvtjqR56ylSUUoly8ryCIkhbMVeouQptsiTVk5zSJIkpp+ptY4JdJRSrVar7NM0Te1P7ebJTfDeIjm1uSdOSwJjZ/o7XQznWYRvsmyQpmnlNyFfvjojTdOYoM0oGx8U/20UnU7HbvCAk2WyLLOPFv6+SVPNLmVXZF9LeEv7yBRSAQAAALCqzBCVYlVaJ1JZjdq0MdZNpGJ381qtViCSkI601rrsf92zLJM+ZPi/+s1JZQNz2EA7IyOVyCIU4dPZ8Uen07FP7eQmNif+kGu0fy1rWH+ni6GUMvtKqNHpdMo2diIM8xy9G3c6HbOlxAqBpyOnNttrrctuRa1vo9xwcyi5V4NM5rKzITl44KJM+KKUarfb3q+Tc+HycMMtlG02w/gpAAAAACNkhqgUq9ISqdTgdIbDPbqmJv4Ue+CVRTRipk5ETuepHMliBxlm4Ib9a9mOJjcxHXIz/CQQ4vR9urrC/fnip/HjPsIPPf44tb6NrVbLuTmD3K7ityJ89piyL8ULr4xUwuOnAAAAAKARZp2dPbt3eV9mAyb+hDg9w3AqsXqRSiNFbeML04Z7+HKZMqAjTVOZXSK7hPc1DdBay45yUTF3tY/TVZJBQ/ZkllqRSjg10FpLqGEOXtaG8OiYwBnD901Cq7ZFGhNzospTm1OE5ygFDuhtfGWkEn+vAAAAAKBv3nWLvS/K04ZspEglpghF5EgWyTJk43w5IsmrZgyZkQ6tVks2k+0rC472d7owM1JGpqXIr01FKhJeyJwXM9sr0IzImSx9RCpFMSeqPLU5xTAjlchKQAAAAAAwoMNThyJfRCohayRSGXyGixkSEhZ5ItlMKWVP5Impc+FsJkdotVrhwSZ9ny6gOC+mj0jF2+xi0dzAQ69VYbdupDJgPVpb8XblwUgrMlJxdg8/ggEHJQEAAADAhrFhI5XwxIT+IpXK7nFZBVCjMrYwJ4rp3psyseZiIwdBOJuZ41SuXNPH6WT8S7gl9ju1IpVAFFL8kgRGqXhbErll+NsYPmlR+HYVKwGHawPHfxmcA5a1odZwHgAAAADY2DZgpJJbq6J0Op3AwjcyjSXwP/zJ8spBZh3cytEf4R5sTBGKyJEs5oD2xtIfrkxtpJ9vX7gcp7Kr3Mfp0mDpENOBlweRVq3ga6If2T58w00AZGb9BFoit73VasnjDq8nXTfgM20OHzmvul1579dSksHA/Y+JVMy643Lk8CNothQxAAAAAKxr6yNSMZNNhCyIG+j/mwQk0NeV7migTy7dUVki13S2w+0Mz4kwxUfCIkeyCCkUYn6VO1OZ2hRvYLvdjlnDpY/TVXbCTdghdzg8WMaUJpFdKiv4mphABhCFW2J/bQLXVffbaAc6cpmBOxaTWZijyXWFt4z5Lkk+1W63pWGBSCV+ehQAAAAAbHjrI1IZifiZIPEHDHeAcyZWVAmPYcHgAt9ACtMCAAAAgI0OUqlmI5XIrCRyJMumRaTSOBlEI9Oj5OtX9g2sNX4KAAAAADY8IpVSjUcqMWNPIjfbtIhUGmemR1XOpeLLCQAAAAA2IhUAAAAAAIDaiFQAAAAAAABqI1IBAAAAAACojUgFAAAAAACgNiIVAAAAAACA2ohUAAAAAAAAaiNSAQAAAAAAqI1IBQAAAAAAoDYiFQAAAAAAgNqIVAAAAAAAAGojUgEAAAAAAKiNSAUAAAAAAKA2IhUAAAAAAIDaiFQAAAAAAABqI1IBAAAAAACojUgFAAAAAACgttJI5QUAAAAAAACUYJQKAAAAAABAbUQqAAAAAAAAtRGpAAAAAAAA1EakAgAAAAAAUBuRCgAAAAAAQG1EKgAAAAAAALURqQAAAAAAANRGpAIAAAAAAFAbkQoAAAAAAEBtRCoAAAAAAAC1EakAAAAAAADURqQCAAAAAABQG5EKAAAAAABAbUQqAAAAAAAAtRGpAAAAAAAA1EakAgAAAAAAUBuRCgAAAAAAQG1EKgAAAAAAALURqQAAgNVx8/yBJDl5bdTNaMa1k0myca4GAAA0gUgFALBZSR+5zIHzN0fdwCG6ef7AyoVfW/klOXnNvk3RgYJ1vKZDiOX2DCfccL8kFWc1m6/Br8+aatvKfXVb03PHSbAAAGsckQoAYJNa6vWfvLbyc88v66s3d/P8gQH7yj2XLb8sH6+/ARqrcx9XetzDfUBL512DkUrso19TkUq+8kfX25yVMG59/QECADYpIhUAwObUExr0RCpLnc810vGM1ECTpcu9dIyeFOXayX56uKsSqfQMpxnmA4qLVEZhHX5b8zy3HqV9T1dxeBMAAKuASAUAsDn1xAROpLL+ioD0xCF96olA7AP2OQJmNSIVacoB3/CGVbZmI5UmHv1ImPTEbrs17Wft3WoAAAqIVAAAKEQq68xyP3TAfrXVOe+5If0NUlmNSGU53BlBvrFGI5WGHv0orAxIWWl8X4V7AAAYHSIVAABiIhW3TmnJf61bn9tVXgtHdnbx9og9h+09zE37DIXz1+5jWxmI3VMvG6RSVbnVHM5p5gC9/+Vwx/+8ekY4OK2ztozczH+1JRu4TyIUBwz70ddoW+hL3lvlpIFnevP8geUBRz2jw5YHIfW0s+KG1Gxb5e0tHHZpm7J6NMG/hd4PeyLLvm8eAGCtIFIBAKAqUnELaXqGBphukx1IJAfO3/T0xZ3dl37t7Vh51rUJdOqXGjho38wMU+npofoGqbht9l2D3W10atb02dCVlpResH3SpTb7Thq5WfGKK4ZOVGVzo3z0g3/JnSjArmTcZ62dk+cLRZGX31o5YOQNiWxb9O31FVjyBT4xfwvWBwdOnlx+Yut4iBEAYBmRCgAA4W5hqN/r9qN6enJWJZJgj8vTyfP278s71g1FKmZcib3E7bXiIBVf+Y5iE7y1MgaZYmUPlynrtwbHr6xsHblZ8bOqdgc3G/GjD7Ut6kteUlK2zzlRN88fMF81OcW1k/agJrfQUdUNiWtb9O0tfsm9VWvi/hbss/T79QcArElEKgAAhDr6ZR95/w+7dzCGJ1/xHa5q6EbVBJvCOfq3tM7P+fMHkuTkSfnlpDtIJdxhLMQWJdNQ+qzN4s+wCocvmWdl9o7crPjRAJHKyB99ZS5T9SUvOdtAkYp1xJvnD9hDpHzHC92Q+m2reTTPlyb2b6HndOQpALCREKkAABDq51cM4+8dNVEdqYQGQvhPsNKwVR+lsryy9IEDbi0Y38wJv6pIpc4d6OU/r3+2RlU2ELlZ8ewDRCojf/TlB4n8kq9GpNJbcsfU7gl858puSHzbom5vcfjJ0l+HZ3hLiYgBLQCA9Y5IBQCAQFc69pPISCV6jIavzMLqRypWF3G5iEqxbxgbDTQcqVw72buX///8126kMvpHX3qQ+K//KkQq5k/n/Ek5RqE1kTcksm3Rt9dpR+jwcV9mIhUA2IiIVAAA6GuUim/0SVORij8uGEKk0lP/pKdIbaEZQ45Ueqf9lB4oPKOnKlIJTM0YVqSyio++j1Eq7tFXI1LpzfHKysJW35CottW5vT31bv03iEgFADY9IhUAAEZbSyU3B1jubZWU2BhCpNLb5fSvSBI73KLRWiqyW89O3rvkz0rKaoJUbWZZlVoqK/sM49GvyVoq1lm8sWP8DYlpW43bu1RXKHxRtb7NRCoAsBERqQAAEO4ZhWYFONVSqyOVklP1jsEwfczYoQqF3to1t6ZsrJgxNWVFVZ2TevfutzqtO+2n7FjefnVxw8jN3AYMFKmM/NGH2hb1JV+lSMUZ6+GPVJoZpVLj9rpjVPyXF/m3YJ2FSAUANhYiFQAAqjr67mgNTz/KF6n05BKFsq1uP89b9tI9Y5Ikywvy+Dq/dhe1z65bz76lncDC+BXPsI+VNrvL9NQPe/wN8RzOulG9NTDK2hbcrHiuQSKVUT/6cNsivuTNRyo90+acJ7F8vNgbEte2+Nt78/yB5bcc3lME/xasDYlUAGBjIVIBAGxuxTU7/F1DdztPdUurW2a2OnDAu0voaOWbWG8VG9m7fT8jVPI8X+5I9vT4K/rgZdewNPziWtT/9le1qLC7M4jA6SEvrQBdetLIzQJLuvhzDVfcc43YZIBH31TbvHf8WtUNLGHtd2Bp3eST10qHhlTekFpti7m9ZfFHSXwUvHFl36G+/0YBAGsIkQoAANgwykYI9LcZNqmqxZH44gAAlhCpAACADYNIBU3wzwPrc7UqAMAGRqQCAAA2hIgpNTU2w2bnnTHFtwUA0INIBQAAAAAAoDYiFQAAAAAAgNqIVAAAAAAAAGojUgEAAAAAAKiNSAUAAAAAAKA2IhUAAAAAAIDaiFQAAAAAAABqI1IBAAAAAACojUgFAAAAAACgNiIVAAAAAACA2ohUAAAAAAAAaiNSAQAAAAAAqI1IBQAAAAAAoDYiFQAAAAAAgNqIVAAAAAAAAGojUgEAAAAAAKiNSAUAAAAAAKA2IhUAAAAAAIDaiFQAAAAAAABqI1IBAAAAAACojUgFAAAAAACgNiIVAAAAAACA2ohUAAAAAAAAaiNSAQAAAAAAqI1IBQAAAAAAoDYiFQAAAAAAgNpKI5UXAAAAAAAAUCIUqfwvAAAAAAAA+FREKoMOgsFawjMFAAAAAKApRCqbCM8UAAAAAICmEKlsIjxTAAAAAACaQqSyifBMAQAAAABoCpHKJsIzBQAAAACgKUQqmwjPFAAAAACAphCpbCI8UwAAAAAAmkKksol4n2mSJEmSOL/KO85HAAAAAADAIFLZRIrP1CQmTqpSfBMAAAAAANhiIxUzeGFiYiKxDKWRaEbxmdqfOkkKDxcAAAAAgIAao1SKkcrqNw9Nio9UeLgAAAAAAIQRqWwitSIVni8AAAAAAAHNRCplU4GSXrXer3sc7/axt2FzYOIPAAAAAABNqRepSJ5iUhXz/nB+9uYpxZ9zIpUStSKV4gYAAAAAAMBoLFIJjyJxz1oeeRSPE45UvOeFFyv+AAAAAADQlIZHqfjPEUxPvO/ERDPEKHV5F8YO3GruMAAAAAAAZdbTxB+36eXbMG7FyxupAAAAAACAPsRGKpJQOJGKk2iU5RqR7xc/ssdKVG7vfb+fW7JxEakAAAAAANCUGqNURiVmxApirJ1nCgAAAADAercOIpW8fDQKallTzxQAAAAAgHVtfUQqaATPFAAAAACAphCpbCI8UwAAAAAAmkKksonwTAEAAAAAaAqRyibCMwUAAAAAoCkVkcoL2Fh4pgAAAAAANKIiUgEAAAAAAEARaxIDAAAAAADURqQCAAAAAABQG5EKAAAAAABAbUQqAAAAAAAAtRGpAAAAAAAA1EakAgAAAAAAUBuRCgAAAAAAQG1EKgAAAAAAALURqQAAAAAAANRGpAIAAAAAAFAbkQoAAAAAAEBtRCoAAAAAAAC1EakAAAAAAADURqQCAAAAAABQG5EKAAAAAABAbUQqAAAAAAAAtRGpAAAAAAAA1EakAgAAAAAAUNv/B0p8j8deg6h4AAAAAElFTkSuQmCC" alt="" />

Relevant Link:

http://wiki.metawerx.net/wiki/Web.xml
http://fangyunfeng.iteye.com/blog/1862251

0x4: Make A Brustattack Blocking Filter Or Listener Within Tomcat：向tomcat注册一个用于阻断后台manager页面的暴力破解阻断模块

filter、listener是tomcat中对http数据流进行pre(前置劫持)、after(后置处理)的一直机制，简单来说，tomcat在整个http数据流的流程中给程序员暴露出了一些串行的hook点，允许程序员对http数据流进行修改

web.xml 的加载顺序是：context-param -> listener -> filter -> servlet ，而相同类型节点之间的程序调用的顺序是根据对应的mapping的顺序进行调用的

所以我们可以选择编写tomcat filter，实现暴力破解阻断的功能

1. Tomcat Filter

关于tomcat filter的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3725886.html
搜索：0x3: Filter介绍

2. Code Example

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
 * @author Administrator
 *
 */
public class LogFilter implements Filter {
    private FilterConfig filterConfig;

    public FilterConfig getFilterConfig() {
        System.err.println("...getFilterConfig...");
        return filterConfig;
    }

    public void setFilterConfig(FilterConfig filterConfig) {
        System.err.println("...setFilterConfig...");
        this.filterConfig = filterConfig;
    }

    /* (non-Javadoc)
     * @see javax.servlet.Filter#destroy()
     */
    @Override
    public void destroy() {
        System.err.println("...filter destroy...");
    }

    /* (non-Javadoc)
     * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain)
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        System.err.println("...doFilter...");
        //传递下一个Filter
        chain.doFilter(request, response);
    }

    /* (non-Javadoc)
     * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.err.println("...init Filter...");
        this.filterConfig = filterConfig;
    }

}

2. 配置web.xml，向web应用注册一个Filter

<filter>
    <filter-name>LogFilter</filter-name>
    <filter-class>com.ee.filter.LogFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>LogFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

0x5: 通过classloader反射动态修改容器内类的配置实现修复配置修复

0x6: 通过java attach api实现远程代码注入，修复应用内存配置漏洞

0x7: Use LockOutRealm To Prevents Brute Force Attacks(org.apache.catalina.realm.LockOutRealm)

LockOutRealm is an implementation of the Tomcat Realm interface that extends the CombinedRealm to provide lock out functionality to provide a user lock out mechanism if there are too many failed authentication attempts in a given period of time.
To ensure correct operation, there is a reasonable degree of synchronization in this Realm.
This Realm does not require modification to the underlying Realms or the associated user storage mechanisms. It achieves this by recording all failed logins, including those for users that do not exist. To prevent a DOS by deliberating making requests with invalid users (and hence causing this cache to grow) the size of the list of users that have failed authentication is limited.
Sub-realms are defined by nesting Realm elements inside the Realm element that defines the LockOutRealm. Authentication will be attempted against each Realm in the order they are listed. Authentication against any Realm will be sufficient to authenticate the user.
The LockOutRealm implementation supports the following additional attributes.

. allRolesMode
This attribute controls how the special role name * is handled when processing authorization constraints in web.xml. By default, the specification compliant value of strict is used which means that the user must be assigned one of the roles defined in web.xml. The alternative values are authOnly which means that the user must be authenticated but no check is made for assigned roles and strictAuthOnly which means that the user must be authenticated and no check will be made for assigned roles unless roles are defined in web.xml in which case the user must be assigned at least one of those roles.

. cacheRemovalWarningTime
If a failed user is removed from the cache because the cache is too big before it has been in the cache for at least this period of time (in seconds) a warning message will be logged. Defaults to  ( hour).

. cacheSize
Number of users that have failed authentication to keep in cache. Over time the cache will grow to this size and may not shrink. Defaults to .

. failureCount
The number of times in a row a user has to fail authentication to be locked out. Defaults to .

. lockOutTime
The time (in seconds) a user is locked out for after too many authentication failures. Defaults to  ( minutes).

为了配置 CombinedRealm，需要创建一个 <Realm> 元素，并将其内嵌在 <Engine> 或 <Host> 元素中的 $CATALINA_BASE/conf/server.xml 文件内。同样，你也可以将其内嵌到 context.xml 文件下的 <Context> 节点

<Engine name="Catalina" defaultHost="localhost">
    <Realm className="org.apache.catalina.realm.LockOutRealm">
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase"/>
    </Realm>

    <Host name="localhost"  appBase="webapps" unpackWARs="true" autoDeploy="true">
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log" suffix=".txt" pattern="%h %l %u %t &quot;%r&quot; %s %b" />
    </Host>
</Engine>

0x8: 修改\conf\tomcat-users.xml中的弱密码

缺点在于，需要重启Tomcat

Relevant Link:

http://docs.oracle.com/javase/7/docs/technotes/guides/attach/index.html
https://tomcat.apache.org/tomcat-7.0-doc/security-howto.html#Securing_Management_Applications
https://tomcat.apache.org/tomcat-7.0-doc/config/realm.html#LockOut_Realm_-_org.apache.catalina.realm.LockOutRealm
https://tomcat.apache.org/tomcat-7.0-doc/realm-howto.html
http://wiki.jikexueyuan.com/project/tomcat/realms-aaa.html

0x9: 调用attach api动态修复JVM内存中配置

. 列出当前主机上所有运行中JVM实例
. 通过枚举进程列表、及其参数，找到tomcat进程PID
. attach到目标JVM进程
. 执行指定agent，注入指令，修改JVM的内存配置，关闭redirect、debug开关

6. Tomcat远程war包部署攻防

在windows环境下，tomcat的启动参数如下

D:\Java\bin\java.exe -Djava.util.logging.config.file="D:\Apache_Tomcat\conf\logging.properties" -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager   -Djava.endorsed.dirs="D:\Apache_Tomcat\endorsed" -classpath "D:\Apache_Tomcat\bin\bootstrap.jar;D:\Apache_Tomcat\bin\tomcat-juli.jar" -Dcatalina.base="D:\Apache_Tomcat" -Dcatalina.home="D:\Apache_Tomcat" -Djava.io.tmpdir="D:\Apache_Tomcat\temp" org.apache.catalina.startup.Bootstrap  start

规则

proc:path:blurry:java:cmd:"Tomcat\conf" write file:path:blurry:/webapps/*.war deny
//tomcat manager远程部署只会像webapps目录下写后缀为war的文件

Relevant Link:

Copyright (c) 2014 LittleHann All rights reserved