‘壹’ 有状态的Web应用程序都有漏洞吗求答案
在没有足够协作的情况下，许多 Web 应用程序对可变数据（比如 JavaBeans 类）使用了 HttpSession 这个机制，从而使自身面临大量潜在的并发性危险。虽然Java? 生态系统中存在许多 Web 框架，但它们都直接或间接地基于 Servlets 基础设施。Servlets API 提供大量有用特性，包括通过 HttpSession 和ServletContext 机制提供的状态管理，它允许应用程序在跨多个用户请求时保持状态。然而，在 Web 应用程序中使用共享状态受一些微妙的（并且大部分没有进行说明）的规则控制着，因此导致许多应用程序无意中触犯了规则。结果是许多有状态 Web 应用程序存在难以发觉的严重缺陷。 范围容器在Servlet 规范中，ServletContext、HttpSession 和HttpRequest 对象被称为 范围容器（Scoped container）。它们都有 getAttribute() 和setAttribute() 方法，为应用程序存储数据。这些范围容器的区别在于它们的生命周期不同。对于 HttpRequest，数据只在请求期间有效；对于 HttpSession，数据在用户和应用程序的会话期间有效；而对于 ServletContext，数据在应用程序的整个生命周期中都有效。 由于HTTP 协议是没有状态的，所以范围容器在构造有状态 Web 应用程序时十分有用；servlet 容器负责管理应用程序的状态和数据的生命周期。尽管这个规范没有强调，但需要保证嵌套在会话或应用程序中的容器在某种程度上是线程安全的，因为 getAttribute() 和setAttribute() 方法随时都可能被不同的线程调用（这个规范没有直接要求这些实现必须是线程安全的，但它们提供的服务实际上提出了这一点）。范围容器还为 Web 应用程序提供一个潜在的好处：容器可以透明地管理应用程序状态的复制和故障转移。 会话session 是特定用户和 Web 应用程序之间的一系列请求-响应交换。用户希望 Web 站点记住他的身份验证凭证、购物车的物品，以及在前面的请求中输入到 Web 表单的信息。但核心 HTTP 协议是没有状态的，这意味着必须将所有请求信息存储到请求本身。因此，如果要创建比一个请求-响应周期更长的有用交互，就必须存储会话状态。servlet 框架允许将每个请求与一个会话关联起来，并提供充当值存储库的 HttpSession 接口，用于存储与该会话相关的（键，值）数据项。清单 1 是一段典型的 servlet 代码，它用于在 HttpSession 中存储购物车数据：清单1. 使用 HttpSession 存储购物车数据 HttpSession session = request.getSession(true); ShoppingCart cart = (ShoppingCart)session.getAttribute("shoppingCart"); if (cart == null) { cart = new ShoppingCart(...); session.setAttribute("shoppingCart"); } doSomethingWith(cart); 清单1 提供的是 servlet 的典型用途；这个应用程序查看是否已将一个对象放到会话中，如果还没有，它将创建一个该会话的后续请求可以使用的对象。构建在 servlet 之上的 Web 框架（比如 JSP、JSF 和 SpringMVC 等）隐藏了细节情况，但对于标记为嵌入到会话中的数据，它们替您执行了实际操作。不幸的是，清单 1 中的用法很可能是不正确的。 与线程相关的问题当HTTP 请求到达 servlet 容器之后，会在 servlet 容器管理的线程上下文中创建 HttpRequest 和HttpResponse 对象，并传递给 servlet 的 service() 方法。servlet 负责生成响应；在响应完成之前 servlet 一直控制这个线程，响应完成时该线程返回到可用的线程池。Servlet 容器没有保持线程与会话之间的联系；某个会话的下一个请求很可能由另一个不同的线程来处理。事实上，可能有多个请求同时进入同一个会话（当用户与页面交互时，使用框架或 AJAX 技术从服务器获取数据的 Web 应用程序可能发生这种现象）。在这种情况，同一用户可能发出多个请求，这些请求在不同的线程上并行执行。 大多数情况下，这类线程问题与 Web 应用程序开发人员无关。由于自身没有状态，HTTP 鼓励只有存储在请求中的数据（不与其他并发请求共享）和存储在存储库（比如数据库）中的、已进行并发性控制的数据，才具有响应功能。然而，一旦 Web 应用程序将数据存储在 HttpSession 或ServletContext 等共享容器之后，该 Web 应用程序就具有了并发性，因此必须考虑应用程序内部的线程安全问题。 尽管我们常用线程安全描述代码，但实际上它是描述数据的。具体来说，线程安全是指适当地协调对被多个线程访问的可变数据的访问。Servlet 应用程序通常是线程安全的，因为它们没有共享任何可变数据，因此就不需要额外的同步。但可以通过很多种办法将共享状态引入到 Web 应用程序 — 除了 HttpSession 和ServletContext 等范围容器外，还可以使用 HttpServlet 对象的静态字段和实例字段。如果要让 Web 应用程序跨请求共享数据，开发人员就必须注意共享数据的位置，并保证访问共享数据时线程之间有足够的协作（同步），以避免与线程相关的危险。 Web 应用程序的线程风险如果Web 应用程序将购物车等可变会话数据存储在 HttpSession 中，就有可能出现两个请求试图同时访问该购物车。这可能导致以下几种故障： 原子性故障。在数据不一致的状态下，一个线程正在更新多个数据项，而另一个线程正在读取这些数据 读线程和写线程之间的可见性故障。一个线程修改购物车，但另一个线程看到的购物车内容的状态是过时的或不一致的 原子性故障清单2 展示了一个用于在游戏应用程序中设置和获取最高分的不恰当的方法实现。它使用一个 PlayerScore 对象来表示最高分，这实际上是一个具有 name 和score 属性的普通 JavaBean 类，存储在内嵌于应用程序的 ServletContext 中（假设在应用程序启动时，初始最高分在 ServletContext 中被设置为 highScore 属性，因此 getAttribute() 调用不会失败）。 清单2. 在范围容器中存储相关项的不恰当模式 public PlayerScore getHighScore() { ServletContext ctx = getServletConfig().getServletContext(); PlayerScore hs = (PlayerScore) ctx.getAttribute("highScore"); PlayerScore result = new PlayerScore(); result.setName(hs.getName()); result.setScore(hs.getScore()); return result; } public void updateHighScore(PlayerScore newScore) { ServletContext ctx = getServletConfig().getServletContext(); PlayerScore hs = (PlayerScore) ctx.getAttribute("highScore"); if (newScore.getScore() > hs.getScore()) { hs.setName(newScore.getName()); hs.setScore(newScore.getScore()); } } 清单2 中的代码不够好。这里采用的方法是在 ServletContext 中存储一个包含最高分玩家的名字和分数的可变容器。当打破记录时，必须更新名字和分数。 假如当前的最高分玩家是 Bob，他的分数为 1000，但是 Joe 以 1100 分打破了这个记录。在正要设置 Joe 的分数时，另一个玩家又发出获得最高分的请求。getHighScore() 将从servlet 上下文获取 PlayerScore 对象，然后从该对象获取名字和分数。如果不慎出现计时失误，就有可能获取 Bob 的名字和 Joe 的分数，显示 Bob 取得了 1100 分，而实际上 Bob 并没有获得这个分数（这种故障在免费游戏站点上是可以接受的，因为 “分数” 并不是 “银行存款”）。这是一种原子性故障，因为彼此之间本应该是原子关系的两个操作 — 获取名字/分数对和更新名字/分数对 — 实际上并没有按照原子关系执行，而且其中一个线程可以在不一致状态下查看共享数据。另外，由于分数更新逻辑遵循 check-then-act 模式，因此可能出现两个线程 “争夺” 更新最高分，从而导致难以预料的结果。假设当前的最高分是 1000，有两个玩家同时注册更高的分数 1100 和 1200。如果出现计时失误，这两个分数都能够通过 “高于现有分数的最高分” 检查，并且都进入到更新最高分的代码块中。和前面一样，根据计时的实际情况，最后的结果可能不一致（采用一个玩家的名字和另一个玩家的分数），或者出现错误（分数为 1100 的玩家可能覆盖分数为 1200 的玩家）。 可见性故障 比原子性故障更复杂的是可见性 故障。没有同步时，如果一个线程读取另外一个线程正在写的变量，读的线程将看到过时的 数据。更糟糕的是，读线程还可能会看到 x 变量的最新数据和 y 变量的过时数据，即使先写 y 变量也是这样。可见性故障非常复杂，因为它的发生是随机的，甚至是频繁的，这会导致罕见的难以调试的间发性故障。可见性故障是由数据争夺引起的 — 访问共享变量时不能正确同步。争夺数据的程序，不管它是什么样的，都属于有漏洞的程序，因为它们的行为不能可靠预测。 Java Memory Model（JMM）定义一些条件，它们保证读变量的线程能够看到另一个线程的写入结果（详细讲解 JMM 超出了本文的范围；参见 参考资料）。JMM 在一个称为 happens-before 的程序的操作上定义一个排序。只有在通用锁上执行同步或访问一个通用的可变变量时，才能创建跨线程的 Happens-before 排序。在没有 happens-before 排序的情况下， Java 平台可以延迟或更改顺序，按照这个顺序，一个线程的写操作对于另一个读取同一变量的线程是可见的。 清单2 中的代码不仅有原子性故障，还有可见性故障。updateHighScore() 方法从 ServletContext 获取HighScore 对象，然后修改它的状态。这样做的目的是让其他调用 getHighScore() 的线程看见这些修改，但是如果 updateHighScore() 的name 和 score 属性的写操作和其他调用 getHighScore() 的线程的 name 和 score 属性的读操作之间没有 happens-before 排序，我们只能期盼运气好些，让读线程能够看到正确的值。 可能的解决方案尽管servlet 规范没有充分地描述 servlet 容器必须提供的 happens-before 保证，但可以得出结论：将一个属性放置在共享范围容器（HttpSession 或ServletContext）应该在另一个线程获取该属性之前发生。（参见 JCiP 4.5.1 了解这个结论的推理过程。该规范中这样描述：“执行请求线程的多个 servlets 可能同时积极地访问单个会话对象。开发人员负责恰当地同步对会话资源的访问）。 set-after-write 技巧更新存储在其他会话容器中的可变数据时，必须在修改该数据后再次调用 setAttribute()。这是一种常用的最佳实践。清单 3 展示了重写 updateHighScore() 以使用这个技巧的示例（这个技巧的目的之一是提示容器值已经更改，因此可以在分布式 Web 应用程序的各个实例之间重新同步会话和应用程序状态）。 清单3. 使用 set-after-write 技巧提示 servlet 容器值已经更新 public void updateHighScore(PlayerScore newScore) { ServletContext ctx = getServletConfig().getServletContext(); PlayerScore hs = (PlayerScore) ctx.getAttribute("highScore"); if (newScore.getScore() > hs.getScore()) { hs.setName(newScore.getName()); hs.setScore(newScore.getScore()); ctx.setAttribute("highScore", hs); } } 不幸的是，尽管这个技巧能够在集群应用程序中高效地复制会话和应用程序状态，但它不能解决本例中的基本线程安全问题。它可以减轻可见性问题（即另一个玩家可能永远看不到在 updateHighScore() 中更新的值），但还不能解决许多潜在的原子性问题。 利用同步set-after-write 技巧可以消除可见性问题，因为 happens-before 排序是可传递的，因而调用 updateHighScore() 中的setAttribute() 和调用 getHighScore() 中的getAttribute() 之间有一个边缘地带。因为 HighScore 状态的更新在 setAttribute() 之前发生，setAttribute() 状态的更新在从 getAttribute() 返回之前发生，getAttribute() 状态的更新在 getHighScore() 的调用方使用状态之前发生，所以通过这种传递可以得出结论：调用方 getHighScore() 看到的值至少和 setAttribute() 的最近一次调用一样新。这个技巧称为利用同步（piggybacking on synchronization），因为 getHighScore() 和updateHighScore() 方法能够在 getAttribute() 和setAttribute() 中使用同步信息来提供一些可见性保证。然而，在上面这个例子中，这还不能完全解决问题。set-after-write 技巧可能对状态复制非常有用，但还不能提供线程安全。 了解不可修改性要创建线程安全的应用程序，一个有用的技巧便是尽可能多地使用不可修改的数据。清单 4 展示了重写后的最高分示例，它使用了 HighScore 的不可修改的 实现，从而避免了原子性故障（允许调用方看见不存在的玩家/分数对）和可见性故障（阻止 getHighScore() 的调用方看见在调用 updateHighScore() 时写的最新值）： 清单4. 使用不可修改的 HighScore 对象修复原子性和可见性漏洞 Public class HighScore { public final String name; public final int score; public HighScore(String name, int score) { this.name = name; this.score = score; } } public PlayerScore getHighScore() { ServletContext ctx = getServletConfig().getServletContext(); return (PlayerScore) ctx.getAttribute("highScore"); } public void updateHighScore(PlayerScore newScore) { ServletContext ctx = getServletConfig().getServletContext(); PlayerScore hs = (PlayerScore) ctx.getAttribute("highScore"); if (newScore.score > hs.score) ctx.setAttribute("highScore", newScore); } 清单4 中的代码的潜在故障很少。在 setAttribute() 和getAttribute() 中使用同步保证了可见性。实际上，仅存储单个不可修改数据项消除了潜在的原子性故障，即 getHighScore() 的调用方可以看见名字/分数对的不一致更新。 将不可修改对象放置在范围容器避免了许多原子性和可见性故障；将有效不可修改性 对象放置在范围容器中也是安全的。有效不可修改性对象是指那些虽然理论上是可修改的，但实际上在发布之后再没有被更改过的对象，比如 JavaBean，将一个对象放置到 HttpSession 中之后，它的 setter 方法就不再被调用。 放置在 HttpSession 中的数据不仅被该会话的请求访问；它还可能被容器本身访问（如果容器进行状态复制的话）。所有放置在 HttpSession 或ServletContext 中的数据应该是线程安全的或有效不可修改的。 影响原子状态转换但是清单4 中的代码仍然有一个问题 — updateHighScore() 中的check-then-act 仍然使两个试图更新最高分数的线程之间存在潜在 “争夺”。如果计时失误，有一个更新可能会丢失。两个线程可能同时通过了 “高于现有分数的新最高分” 检查，造成它们同时调用 setAttribute()。不能确保两个分数中最高者获得调用，这取决于计时。要修复这个最后的漏洞，我们需要一种原子性地更新分数引用的方法，同时又要保证不受干扰。有几种方法可以实现这个目的。 清单5 为 updateHighScore() 添加了同步，确保更新进程中固有的 check-then-act 不和另一个更新并发执行。如果所有条件修改逻辑获得 updateHighScore() 使用的同一个锁，用这种方法就可以了。 清单5. 使用同步修复最后一个原子性漏洞 public void updateHighScore(PlayerScore newScore) { ServletContext ctx = getServletConfig().getServletContext(); PlayerScore hs = (PlayerScore) ctx.getAttribute("highScore"); synchronized (lock) { if (newScore.score > hs.score) ctx.setAttribute("highScore", newScore); } } 虽然清单 5 中的技术是可行的，但还有一个更好的技术：使用 java.util.concurrent 包中的 AtomicReference 类。这个类的用途就是通过 compareAndSet() 调用提供原子条件更新。清单 6 展示了如何使用 AtomicReference 来修复本示例的最后一个原子性问题。这个方法比清单 5 中的代码好，因为很难违背更新最高分数的规则。 清单6. 使用 AtomicReference 来修复最后一个原子性漏洞 public PlayerScore getHighScore() { ServletContext ctx = getServletConfig().getServletContext(); AtomicReference<PlayerScore> holder = (AtomicReference<PlayerScore>) ctx.getAttribute("highScore"); return holder.get(); } public void updateHighScore(PlayerScore newScore) { ServletContext ctx = getServletConfig().getServletContext(); AtomicReference<PlayerScore> holder = (AtomicReference<PlayerScore>) ctx.getAttribute("highScore"); while (true) { HighScore old = holder.get(); if (old.score >= newScore.score) break; else if (holder.compareAndSet(old, newScore)) break; } } 对于放置在范围容器中的可修改数据，应该将它们的状态转换变成原子性的，这可以通过同步或 java.util.concurrent 中的原子变量类来实现。 序列化对 HttpSession 的访问在我已给出的示例中，我试图避免与访问整个应用程序中的 ServletContext 相关的各种危险。很明显，访问 ServletContext 时需要细心的协作，因为任何请求都可以访问 ServletContext。然而，大多数有状态 Web 应用程序严重依赖于内嵌于会话的容器 HttpSession。同一个会话中发生多个同步请求的原因不是很直观；毕竟，每个会话都是绑定到一个特定用户或浏览器会话的，并且用户不一定一次请求多个页面。但是在编程式地生成请求的应用程序中（比如 AJAX 应用程序），一个会话中的请求是可以重叠的。 单个会话中的请求当然可以是重叠的，但这不是一件好事。如果可以轻松地序列化会话中的请求，当访问 HttpSession 中的共享对象时，这里提到的所有问题几乎都可以解决；序列化可以阻止原子性故障，并且利用 HttpSession 中的同步可以阻止可见性故障。序列化特定会话的请求不会对吞吐量造成很大的影响，因为一个会话中的请求很少重叠，在一个会话中出现很多请求重叠就更罕见了。 不幸的是，servlet 规范并没有提到 “序列化同一会话中的请求”。不过 SpringMVC 框架提供了一种方法，并且这种方法可以在其他框架中轻松实现。SpringMVC 控制器的基类 AbstractController 提供了一个布尔变量 synchronizeOnSession；设置这里之后，它将使用一个锁，确保一个会话中只同时执行一个请求。 序列化 HttpSession 上的请求消除了很多并发性危险。同样，将对象限制在 Event Dispatch Thread（EDT）中减少了 Swing 应用程序中的同步需求。结束语许多有状态 Web 应用程序有很严重的并发性漏洞。在没有足够协调的情况下，访问存储在 HttpSession 和ServletContext 等范围容器中的可变数据就会产生这些漏洞。开发人员通常会误认为 getAttribute() 和setAttribute() 方法中的同步已经足够 但这只能应付特定情况，比如当属性是不可修改、有效不可修改或线程安全的对象时，或当可能访问容器的请求被序列化时。通常，放置在范围容器中的所有内容都应该是高度不可修改的或线程安全的。servlet 规范提供的范围容器机制并不管理没有提供它们自己的同步的可变对象。将普通的 JavaBean 类存储在 HttpSession 中是很大的隐患。
‘贰’ 开放式web认证的wifi和wep，wpa的加密方式那个安全
简单的来说：加密程度不同，也就是安全性不同。
WEP使用一个静态的密钥来加密所有的通信。WPA不断的转换密钥。WPA采用有效的密钥分发机制，可以跨越不同厂商的无线网卡实现应用。另外WPA的另一个优势是，它使公共场所和学术环境安全地部署无线网络成为可能。而在此之前，这些场所一直不能使用WEP。WEP的缺陷在于其加密密钥为静态密钥而非动态密钥。这意味着，为了更新密钥，IT人员必须亲自访问每台机器，而这在学术环境和公共场所是不可能的。另一种办法是让密钥保持不变，而这会使用户容易受到攻击。由于互操作问题，学术环境和公共场所一直不能使用专有的安全机制。
WPA工作原理
WPA包括暂时密钥完整性协议(Temporal Key Integrity Protocol，TKIP)和802.1x机制。TKIP与802.1x一起为移动客户机提供了动态密钥加密和相互认证功能。WPA通过定期为每台客户机生成惟一的加密密钥来阻止黑客入侵。TKIP为WEP引入了新的算法，这些新算法包括扩展的48位初始向量与相关的序列规则、数据包密钥构建、密钥生成与分发功能和信息完整性码（也被称为“Michael”码）。在应用中，WPA可以与利用802.1x和EAP（一种验证机制）的认证服务器(如远程认证拨入用户服务)连接。这台认证服务器用于保存用户证书。这种功能可以实现有效的认证控制以及与已有信息系统的集成。由于WPA具有运行“预先共享的密钥模式”的能力，SOHO环境中的WPA部署并不需要认证服务器。与WEP类似，一部客户机的预先共享的密钥(常常被称为“通行字”)必须与接入点中保存的预先共享的密钥相匹配，接入点使用通行字进行认证，如果通行字相符合，客户机被允许访问接入点。
WPA弥补了WEP的安全问题
除了无法解决拒绝服务(DoS)攻击外，WPA弥补了WEP其他的安全问题。黑客通过每秒发送至少两个使用错误密钥的数据包，就可以造成受WPA保护的网络瘫痪。当这种情况发生时，接入点就会假设黑客试图进入网络，这台接入点会将所有的连接关闭一分钟，以避免给网络资源造成危害，连接的非法数据串会无限期阻止网络运行，这意味着用户应该为关键应用准备好备份进程。
总结：WPA比WEP的安全更高。
小常识：目前已经有WPA2的加密通信，是WPA的增强型版本，与WPA相比，WPA2新增了支持AES的加密方式。
三个安全性的排序为：WEP<WPA<WPA2。
‘叁’ web安全设计--输入验证--标准化问题
比如提交表单后向user.asp提交两个值
id
psw
就会形成如同
user.asp?id=wo&&psw=psw
的地址请求（一般使用post，就看不到?后面的）
这样的话如果我们直接在浏览器中输入
usre.asp?id=*&&psw=*
的话在服务器端肯定能得到一条记录
如果服务器端依据有没有返回记录来判断用户的输入是否正确
那么这个链接就是正确的
就会认为用户已经通过了验证
不是很清楚
大意是这样的
至于我写的链接等只是表明一个意思
并不是代表实际是这样的
‘肆’ 个人WEB服务器会遇到什么样的安全技术问题
服务器安全这问题，很重要，之前服务器被黑，在网上搜索了一些服务器安全设置以及防黑的文章，对着文章，我一个一个的设置起来，费了好几天的时间才设置完，原以为会防止服务器再次被黑，没想到服务器竟然瘫痪了，网站都打不开了，无奈对服务器安全也是一窍不通，损失真的很大，数据库都损坏了，我哪个后悔啊。娘个咪的。最后还是让机房把系统重装了。找了几个做网站服务器方面的朋友，咨询了关于服务器被黑的解决办法，他们都建议我找专业做服务器安全的安全公司来给做安全维护，也一致的推荐了sinesafe，服务器被黑的问题，才得以解决。
一路的走来，才知道，服务器安全问题可不能小看了。经历了才知道，服务器安全了给自己带来的也是长远的利益。 希望我的经历能帮到楼主，帮助别人也是在帮助我自己。
下面是一些关于安全方面的建议！
建站一段时间后总能听得到什么什么网站被挂马，什么网站被黑。好像入侵挂马似乎是件很简单的事情。其实，入侵不简单，简单的是你的网站的必要安全措施并未做好。
一：挂马预防措施：
1、建议用户通过ftp来上传、维护网页，尽量不安装asp的上传程序。
2、定期对网站进行安全的检测，具体可以利用网上一些工具，如sinesafe网站挂马检测工具！
序，只要可以上传文件的asp都要进行身份认证!
3、asp程序管理员的用户名和密码要有一定复杂性，不能过于简单，还要注意定期更换。
4、到正规网站下载asp程序，下载后要对其数据库名称和存放路径进行修改，数据库文件名称也要有一定复杂性。
5、要尽量保持程序是最新版本。
6、不要在网页上加注后台管理程序登陆页面的链接。
7、为防止程序有未知漏洞，可以在维护后删除后台管理程序的登陆页面，下次维护时再通过ftp上传即可。
8、要时常备份数据库等重要文件。
9、日常要多维护，并注意空间中是否有来历不明的asp文件。记住：一分汗水，换一分安全!
10、一旦发现被入侵，除非自己能识别出所有木马文件，否则要删除所有文件。
11、对asp上传程序的调用一定要进行身份认证，并只允许信任的人使用上传程序。这其中包括各种新闻发布、商城及论坛程
二：挂马恢复措施：
1.修改帐号密码
不管是商业或不是，初始密码多半都是admin。因此你接到网站程序第一件事情就是“修改帐号密码”。帐号
密码就不要在使用以前你习惯的，换点特别的。尽量将字母数字及符号一起。此外密码最好超过15位。尚若你使用
SQL的话应该使用特别点的帐号密码，不要在使用什么什么admin之类，否则很容易被入侵。
2.创建一个robots.txt
Robots能够有效的防范利用搜索引擎窃取信息的骇客。
3.修改后台文件
第一步：修改后台里的验证文件的名称。
第二步：修改conn.asp，防止非法下载，也可对数据库加密后在修改conn.asp。
第三步：修改ACESS数据库名称，越复杂越好，可以的话将数据所在目录的换一下。
4.限制登陆后台IP
此方法是最有效的，每位虚拟主机用户应该都有个功能。你的IP不固定的话就麻烦点每次改一下咯，安全第一嘛。
5.自定义404页面及自定义传送ASP错误信息
404能够让骇客批量查找你的后台一些重要文件及检查网页是否存在注入漏洞。
ASP错误嘛，可能会向不明来意者传送对方想要的信息。
6.慎重选择网站程序
注意一下网站程序是否本身存在漏洞，好坏你我心里该有把秤。
7.谨慎上传漏洞
据悉，上传漏洞往往是最简单也是最严重的，能够让黑客或骇客们轻松控制你的网站。
可以禁止上传或着限制上传的文件类型。不懂的话可以找专业做网站安全的sinesafe公司。
8. cookie 保护
登陆时尽量不要去访问其他站点，以防止 cookie 泄密。切记退出时要点退出在关闭所有浏览器。
9.目录权限
请管理员设置好一些重要的目录权限，防止非正常的访问。如不要给上传目录执行脚本权限及不要给非上传目录给于写入权。
10.自我测试
如今在网上黑客工具一箩筐，不防找一些来测试下你的网站是否OK。
11.例行维护
a.定期备份数据。最好每日备份一次，下载了备份文件后应该及时删除主机上的备份文件。
b.定期更改数据库的名字及管理员帐密。
c.借WEB或FTP管理，查看所有目录体积，最后修改时间以及文件数，检查是文件是否有异常，以及查看是否有异常的账号。
‘伍’ 常用的Web前端框架优缺点分析
今天小编要跟大家分享的文章是关于常用的web前端框架优缺点分析。正在从事web前端工作的小伙伴们一定不会对web前端框架陌生，那么这么多的框架各有什么优缺点呢?为了帮助小伙伴们提高工作效率，今天小编为大家整理了不同框架的优缺点分别是什么，下面来和小编一起看一看吧！
一、web前端框架之Angular2+
Angular2+优点解析：
Angular2+的最大优势在于它的流行程度。也有人认为它和Google密切相关的名字，会影响团队使用它。Angular1
的迅速流行是因为那些来自其他交互式应用程序开发环境的人会发现对于开发单页面web应用程序具有相似的模型-视图模式。通过对Angular1
进行现代化演变和重新构建框架的某些部分，Angular2+
已经真正的爆发了，大量的正式的和非正式培训机构数量都让人印象深刻，开发者有很强的市场竞争力。对于用户来说它有一套用于构建用户界面的丰富组件，这也是本系列中少有的几个框架能够做到这点。
缺点解析:
我们觉得Angular框架着重于在单个页面应用程序中创建用户界面并没有处理构建完整的web
应用这个更大的关注点，如果不及早确定下来，这将会导致整个项目难以维护，在实际项目中，运行时提供不属于核心框架的技术往往让人觉得不可思议，这大大降低了
TypeScript对最终开发者的价值。
发展方向：
Angular5刚刚发布，这看来是Angular已经成功的印证了快速发布版本的承诺，在Google的持续支持下，Angular
会越来越成熟。
像许多的大型组织一样，Google具有多重(分裂)的人格，从外表上看，Angular
团队和那些专注于浏览器标准的团队之间显得很和谐。但我们的观点是，和谐只是一层薄薄的窗户纸。Angular团队对于web组件和渐进式web
应用没有一个真正解决方案。我们认为，业界普遍认可的标准将会在Angular框架中会逐步实现，这将会影响到如何更好的构建Angular
应用将成为一个中/长期的风险。
使用环境:
如果你需要在一个大型的框架内获取技术资源，框架内的技术通常很容易移植;或者你需要在框架中训练开发人员，并且还要有一定的信心，他们会在短期内获得一定的开发能力，这样的话你可以考虑
Angular2+。需要注意的是Angular1(angular.js)与Angular2+是截然不同的，其中的应用、技术和经验不能直接移植到
Angular2+的开发中去。
如果你的web应用能够很好的转化为标准的模型-视图模式，那么你也可以忽略其他直接考虑使用Angular2+。
如果你对GoogleMaterialUX设计模式满意，那么MaterialAngular
是遵循该模式的一种快速、简单且可靠的方式。
二、web前端框架之React+Rex
React+Rex优势解析：
React和Rex
的最大优势在于它们相对简单和专注。做一件事情并把它做好是非常困难的，但这两个库都很有效地完成了它们的目标。虽然对于某些状态容器方法可能是外部的，但大多数开发人员还是可以轻松掌握概念，并了解单向数据体系结构的好处，简化大量的用户界面应用程序。
缺点解析:
React和Rex最大的弱点不是它们是什么，而是它们不是什么。要构建一个功能丰富的Web应用程序，你需要许多功能，一旦脱离React
和Rex和其他一些库的核心，你将发现一个非常分散的社区，拥有无数的解决方案和模式，不容易整合在一起。
因此，虽然React和Rex
都是非常专注的库，但缺乏经验的团队还是会很容易地生成不可维护的解决方案，而不是意识到他们所做的选择会导致性能不佳或错误。即使有经验的开发人员也可能意识到，一个松散的架构或惯例可能会在未来困扰他们。
假省钱是一种对自己的欺骗，组织范围内采用React和Rex将轻松降低无效率问题。没有其他库和模式的广泛约定和标准化，标准化React+
Rex比较于我们正在采用的JavaScript来编写我们的应用程序效率要高。
发展方向:
Facebook和React最近从繁琐的附加专利纠纷中抽离，他们认识到，就像其他项目一样，更广泛的社区能够提高自己的声音。我觉得这有助于
Facebook意识到他们还不能更好地了解我们，相信我们来引导项目。希望这将继续贯穿项目的特点和技术方向。
很难预测React和Rex的未来。但是，将库集中在一起，确实会显着提高适应性，大多数React+Rex
模式都会促进一个分离的体系结构，从而可以轻松地进行重构和迭代。两年前，大家喜欢的还是React+
Flux，但整个社区很快就拥抱了Rex。思维或模式的其他重大转变可能很容易被采纳。这种关键能力可能会持续到未来。
使用环境：
如果你很少需要手把手指导，并且正在寻找更好的库而不是全面的框架，那么React+Rex
可能是正确的。在这一过程中，你不仅需要对你的团队和组织的能力保持诚实，还要在你的初始开发过程中，以及在整个应用程序的长期维护过程中保持诚实。
三、web前端框架之Vue.js
vue.js优势介绍：
渐进式构建能力是vue.js最大的优势，vue有一个简洁而且合理的架构，使得它易于理解和构建。
vue有一个强大的充满激情人群的社区，这为vue.js增加了巨大的价值，使得为一个空白项目创建一个综合的解决方案变得十分容易。
缺点介绍：
在模型-视图应用程序和状态容器类型的应用程序之间的互相转换可能会令人感到困惑，即使没有完美包含一个模式到另一个模式的完美转换，但让人感觉希望能维持两个模式的相关性。对于那些期待
vue.js完美解决方案，并可能导致难以维护不一致的应用程序的人来说，这至少是令人困惑的。
一个更大的挑战是vue.js
依赖于一个单独的人，很明显，其他的项目基本是由一个组织提供支持，但这让人感觉更加有意义，虽然它有一个强大文件的社区和许多有创新的新增项目，但是vue
核心的开发基本落在一个人身上。
我们很高兴看到vue更加容易接受新兴的标准方法，但是它的类似于web组件的模式，而不是真正的web组件，这可能是vue
所得不偿失的地方。
发展前景：
虽然vue.js
有相当广泛的应用，但也很难预测在中期发展中这个势头能持续多久，它不是由一个商业组织直接支持并维护，因此，这很大程度上依赖于维护者的生存能力和继续维护下去的愿望来决定。
它也表现出了一定程度的语言适应能力，并且随着某些模式的落伍和失宠而继续保持自身语言的现代化和时代性，目前没有迹象表明vue.js
架构将来无法适应进一步发展。
使用场景：
如果你有一个传统的web应用程序，并需要一个强壮稳健的应用程序层，那么vue.js
可能是一个很好的选择，它有清晰的模式，即使没有经验的团队也能正确或者错误的使用它。尽管vueUX框架没有开箱即用的功能，但在vue.js
上也能大量持续性构建应用，这将有利于你的项目。
以上就是小编今天为大家分享的关于常用的web前端框架优缺点分析的文章，希望本篇文章能够对正在从事web前端工作的小伙伴们有所帮助，想要了解更多web前端知识记得关注北大青鸟web培训官网，最后祝愿小伙伴们工作顺利，成为一名优秀的web前端工程师。
‘陆’ 针对web应用存在哪些安全威胁提出相应的安全防护措施
应用安全防护解决思路：应用安全问题本质上源于软件质量问题。但应用相较传统的软件，具有其独特性。应用往往是某个机构所独有的应用，对其存在的漏洞，已知的通用漏洞签名缺乏有效性；需要频繁地变更以满足业务目标，从而使得很难维持有序的开发周期；需要全面考虑客户端与服务端的复杂交互场景，而往往很多开发者没有很好地理解业务流程；人们通常认为开发比较简单，缺乏经验的开发者也可以胜任。针对应用安全，理想情况下应该在软件开发生命周期遵循安全编码原则，并在各阶段采取相应的安全措施。然而，多数网站的实际情况是：大量早期开发的应用，由于历史原因，都存在不同程度的安全问题。对于这些已上线、正提供生产的应用，由于其定制化特点决定了没有通用补丁可用，而整改代码因代价过大变得较难施行或者需要较长的整改周期。针对这种现状，专业的安全防护工具是一种合理的选择。应用防火墙（以下简称）正是这类专业工具，提供了一种安全运维控制手段：基于对流量的双向分析，为应用提供实时的防护。与传统防火墙设备相比较，最显着的技术差异性体现在：对有本质的理解：能完整地解析，包括报文头部、参数及载荷。支持各种编码（如、压缩）；提供严格的协议验证；提供限制；支持各类字符集编码；具备过滤能力。提供应用层规则：应用通常是定制化的，传统的针对已知漏洞的规则往往不够有效。提供专用的应用层规则，且具备检测变形攻击的能力，如检测加密流量中混杂的攻击。提供正向安全模型（白名单）：仅允许已知有效的输入通过，为应用提供了一个外部的输入验证机制，安全性更为可靠。提供会话防护机制：协议最大的弊端在于缺乏一个可靠的会话管理机制。为此进行有效补充，防护基于会话的攻击类型，如篡改及会话劫持攻击。如何正确选择并非对服务器提供保护的“盒子”都是。事实上，一个真正满足需求的应该具有二维的防护体系：纵向提供纵深防御：通过建立协议层次、信息流向等纵向结构层次，构筑多种有效防御措施阻止攻击并发出告警。横向：满足合规要求；缓解各类安全威胁（包括网络层面、基础架构及应用层面）；降低服务响应时间、显着改善终端用户体验，优化业务资源和提高应用系统敏捷性。在选择产品时，建议参考以下步骤：结合业务需求明确安全策略目标，从而定义清楚产品必须具备的控制能力评估每一家厂商产品可以覆盖的风险类型测试产品功能、性能及可伸缩性评估厂商的技术支持能力评估内部维护团队是否具备维护、管理产品的必需技能权衡安全、产出以及总成本。“成本”不仅仅意味着购买安全产品服务产生的直接支出，还需要考虑是否影响组织的正常业务、是否给维护人员带来较大的管理开销
‘柒’ 如何使用HttpClient认证机制
本文出自 “子 孑” 博客，请务必保留此出处http://zhangjunhd.blog.51cto.com/113473/51919
英文版(无代码示例): http://hc.apache.org/httpclient-3.x/authentication.html
<!--[if !vml]--><!--[endif]--> HttpClient三种不同的认证方案: Basic, Digest and NTLM. 这些方案可用于服务器或代理对客户端的认证，简称服务器认证或代理认证。
1．服务器认证(Server Authentication)
HttpClient处理服务器认证几乎是透明的，仅需要开发人员提供登录信息(login credentials)。登录信息保存在HttpState类的实例中，可以通过 setCredentials(String realm, Credentials cred)和getCredentials(String realm)来获取或设置。
HttpClient内建的自动认证，可以通过HttpMethod类的setDoAuthentication(boolean doAuthentication)方法关闭，而且这次关闭只影响HttpMethod当前的实例。
1.1抢先认证(Preemptive Authentication)
在这种模式时，HttpClient会主动将basic认证应答信息传给服务器，即使在某种情况下服务器可能返回认证失败的应答，这样做主要是为了减少连接的建立。使用该机制如下所示：
client.getParams().setAuthenticationPreemptive(true);
抢先认证模式也提供对于特定目标或代理的缺省认证。如果没有提供缺省的认证信息，则该模式会失效。
Credentials defaultcreds = new UsernamePasswordCredentials("username", "password");
client.getState().setCredentials(new AuthScope("myhost", 80, AuthScope.ANY_REALM), defaultcreds);
Httpclient实现的抢先认证遵循rfc2617.
A client SHOULD assume that all paths at or deeper than the depth of the last symbolic element in the path field of the Request-URI also are within the protection space specified by the Basic realm value of the current challenge. A client MAY preemptively send the corresponding Authorization header with requests for resources in that space without receipt of another challenge from the server. Similarly, when a client sends a request to a proxy, it may reuse a userid and password in the Proxy-Authorization header field without receiving another challenge from the proxy server.
1.2服务器认证的安全方面考虑
当需要与不被信任的站点或web应用通信时，应该谨慎使用缺省的认证机制。当启动(activate)抢先认证模式，或者认证中没有明确给出认证域，主机的HttpClient将使用缺省的认证机制去试图获得目标站点的授权。
如果你提供的认证信息是敏感的，你应该指定认证域。不推荐将认证域指定为AuthScope.ANY。（只有在debugging情况下，才使用）
// To be avoided unless in debug mode
Credentials defaultcreds = new UsernamePasswordCredentials("username", "password");
client.getState().setCredentials(AuthScope.ANY, defaultcreds);
2.代理认证(proxy authentication)
除了登录信息需单独存放以外，代理认证与服务器认证几乎一致。用 setProxyCredentials(String realm, Credentials cred)和 getProxyCredentials(String realm)设、取登录信息。
3.认证方案(authentication schemes)
3.1Basic
是HTTP中规定最早的也是最兼容的方案，遗憾的是也是最不安全的一个方案，因为它以明码传送用户名和密码。它要求一个UsernamePasswordCredentials实例，可以指定服务器端的访问空间或采用默认的登录信息。
3.2 Digest
是在HTTP1.1 中增加的一个方案，虽然不如Basic得到的软件支持多，但还是有广泛的使用。Digest方案比Basic方案安全得多，因它根本就不通过网络传送实际的密码，传送的是利用这个密码对从服务器传来的一个随机数(nonce)的加密串。
它要求一个UsernamePasswordCredentials实例，可以指定服务器端的访问空间或采用默认的登录信息。
3.3 NTLM
这是HttpClient支持的最复杂的认证协议。它Microsoft设计的一个私有协议，没有公开的规范说明。一开始由于设计的缺陷，NTLM的安全性比 Digest差，后来经过一个ServicePack补丁后，安全性则比较Digest高。
NTLM需要一个NTCredentials实例。 注意，由于NTLM不使用访问空间(realms)的概念，HttpClient利用服务器的域名作访问空间的名字。还需要注意，提供给 NTCredentials的用户名，不要用域名的前缀 - 如: "adrian" 是正确的，而 "DOMAIN\adrian" 则是错的。
NTLM认证的工作机制与basic和digest有很大的差别。这些差别一般由HttpClient处理，但理解这些差别有助避免在使用NTLM认证时出现错误。
[1] 从HttpClientAPI的角度来看，NTLM与其它认证方式一样的工作，差别是需要提供'NTCredentials'实例而不是'UsernamePasswordCredentials'(其实，前者只是扩展了后者)
[2] 对NTLM认证，访问空间是连接到的机器的域名，这对多域名主机会有一些麻烦。只有HttpClient连接中指定的域名才是认证用的域名。建议将realm设为null以使用默认的设置。
[3] NTLM只是认证了一个连接而不是一请求，所以每当一个新的连接建立就要进行一次认证，且在认证的过程中保持连接是非常重要的。 因此，NTLM不能同时用于代理认证和服务器认证，也不能用于HTTP1.0连接或服务器不支持持久连接(keep-alives)的情况。
关于NTLM认证机制更详细的研究，可参考http://davenport.sourceforge.net/ntlm.html 。
3.4选择认证
一些服务器支持多种认证方案。假设一次只能使用一种认证方案，HttpClient必须选择使用哪种。HttpClient选择是基于NTLM, Digest, Basic顺序的。
在具体情况下，可以更改该顺序。可通过参数'http.auth.scheme-priority'来实现，该参数值应该被存放在一个String类型的List中。选择优先级是按插入顺序确定的。
HttpClient client = new HttpClient();
List authPrefs = new ArrayList(2);
authPrefs.add(AuthPolicy.DIGEST);
authPrefs.add(AuthPolicy.BASIC);
// This will exclude the NTLM authentication scheme
client.getParams().setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, authPrefs);
3.5定制认证方案
HttpClient本身支持basic, digest, and NTLM这三种认证方案。同时，它也提供了加载额外定制的认证方案的功能（通过AuthScheme接口实现）。需要使用定制的认证方案，必须实现下面的步骤：
[1]实现AuthScheme接口。
[2]通过AuthPolicy.registerAuthScheme() 注册定制的AuthScheme。
[3]将定制的AuthScheme加入到AuthPolicy.AUTH_SCHEME_PRIORITY中。
4．示例
4.1Basic authentication
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.httpclient.methods.GetMethod;
/**
* A simple example that uses HttpClient to perform a GET using Basic
* Authentication. Can be run standalone without parameters.
*
* You need to have JSSE on your classpath for JDK prior to 1.4
*
* @author Michael Becke
*/
public class BasicAuthenticationExample {
/**
* Constructor for BasicAuthenticatonExample.
*/
public BasicAuthenticationExample() {
super();
}
public static void main(String[] args) throws Exception {
HttpClient client = new HttpClient();
// pass our credentials to HttpClient, they will only be used for
// authenticating to servers with realm "realm" on the host
// "www.verisign.com", to authenticate against
// an arbitrary realm or host change the appropriate argument to null.
client.getState().setCredentials(
new AuthScope("www.verisign.com", 443, "realm"),
new UsernamePasswordCredentials("username", "password")
);
// create a GET method that reads a file over HTTPS, we're assuming
// that this file requires basic authentication using the realm above.
GetMethod get = new GetMethod("https://www.verisign.com/procts/index.html");
// Tell the GET method to automatically handle authentication. The
// method will use any appropriate credentials to handle basic
// authentication requests. Setting this value to false will cause
// any request for authentication to return with a status of 401.
// It will then be up to the client to handle the authentication.
get.setDoAuthentication( true );
try {
// execute the GET
int status = client.executeMethod( get );
// print the status and response
System.out.println(status + "\n" + get.getResponseBodyAsString());
} finally {
// release any connection resources used by the method
get.releaseConnection();
}
}
}
4.2 Alternate authentication
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthPolicy;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.httpclient.methods.GetMethod;
/**
* <p>A simple example that uses alternate authentication scheme selection
* if several authentication challenges are returned.
* </p>
*
* <p>Per default HttpClient picks the authentication challenge in the following
* order of preference: NTLM, Digest, Basic. In certain cases it may be desirable to
* force the use of a weaker authentication scheme.
* </p>
*
* @author Oleg Kalnichevski
*/
public class {
/**
* Constructor for BasicAuthenticatonExample.
*/
public () {
super();
}
public static void main(String[] args) throws Exception {
HttpClient client = new HttpClient();
client.getState().setCredentials(
new AuthScope("myhost", 80, "myrealm"),
new UsernamePasswordCredentials("username", "password"));
// Suppose the site supports several authetication schemes: NTLM and Basic
// Basic authetication is considered inherently insecure. Hence, NTLM authentication
// is used per default
// This is to make HttpClient pick the Basic authentication scheme over NTLM & Digest
List<String> authPrefs = new ArrayList<String>(3);
authPrefs.add(AuthPolicy.BASIC);
authPrefs.add(AuthPolicy.NTLM);
authPrefs.add(AuthPolicy.DIGEST);
client.getParams().setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, authPrefs);
GetMethod httpget = new GetMethod("http://myhost/protected/auth-required.html");
try {
int status = client.executeMethod(httpget);
// print the status and response
System.out.println(status);
System.out.println(httpget.getStatusLine());
System.out.println(httpget.getResponseBodyAsString());
} finally {
// release any connection resources used by the method
httpget.releaseConnection();
}
}
}
4.3 Custom authentication
import java.util.ArrayList;
import java.util.Collection;
import org.apache.commons.httpclient.Credentials;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.auth.AuthPolicy;
import org.apache.commons.httpclient.auth.AuthScheme;
import org.apache.commons.httpclient.auth.AuthenticationException;
import org.apache.commons.httpclient.auth.MalformedChallengeException;
import org.apache.commons.httpclient.params.DefaultHttpParams;
import org.apache.commons.httpclient.params.HttpParams;
/**
* A simple custom AuthScheme example. The included auth scheme is meant
* for demonstration purposes only. It does not actually implement a usable
* authentication method.
*/
public class CustomAuthenticationExample {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
// register the auth scheme
AuthPolicy.registerAuthScheme(SecretAuthScheme.NAME, SecretAuthScheme.class);
// include the scheme in the AuthPolicy.AUTH_SCHEME_PRIORITY preference,
// this can be done on a per-client or per-method basis but we'll do it
// globally for this example
HttpParams params = DefaultHttpParams.getDefaultParams();
ArrayList<String> schemes = new ArrayList<String>();
schemes.add(SecretAuthScheme.NAME);
schemes.addAll( (Collection) params.getParameter(AuthPolicy.AUTH_SCHEME_PRIORITY));
params.setParameter(AuthPolicy.AUTH_SCHEME_PRIORITY, schemes);
// now that our scheme has been registered we can execute methods against
// servers that require "Secret" authentication...
}
/**
* A custom auth scheme that just uses "Open Sesame" as the authentication
* string.
*/
private class SecretAuthScheme implements AuthScheme {
public static final String NAME = "Secret";
public SecretAuthScheme() {
// All auth schemes must have a no arg constructor.
}
public String authenticate(Credentials credentials, HttpMethod method)
throws AuthenticationException {
return "Open Sesame";
}
public String authenticate(Credentials credentials, String method,
String uri) throws AuthenticationException {
return "Open Sesame";
}
public String getID() {
return NAME;
}
public String getParameter(String name) {
// this scheme does not use parameters, see RFC2617Scheme for an example
return null;
}
public String getRealm() {
// this scheme does not use realms
return null;
}
public String getSchemeName() {
return NAME;
}
public boolean isConnectionBased() {
return false;
}
public void processChallenge(String challenge)
throws MalformedChallengeException {
// Nothing to do here, this is not a challenge based
// auth scheme. See NTLMScheme for a good example.
}
public boolean isComplete() {
// again we're not a challenge based scheme so this is always true
return true;
}
}
}
4.4 Interactive authentication
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import org.apache.commons.httpclient.Credentials;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NTCredentials;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScheme;
import org.apache.commons.httpclient.auth.;
import org.apache.commons.httpclient.auth.CredentialsProvider;
import org.apache.commons.httpclient.auth.NTLMScheme;
import org.apache.commons.httpclient.auth.RFC2617Scheme;
import org.apache.commons.httpclient.methods.GetMethod;
/**
* A simple example that uses HttpClient to perform interactive
* authentication.
*
* @author Oleg Kalnichevski
*/
public class {
/**
* Constructor for .
*/
public () {
super();
}
public static void main(String[] args) throws Exception {
demo = new ();
demo.doDemo();
}
private void doDemo() throws IOException {
HttpClient client = new HttpClient();
client.getParams().setParameter(
CredentialsProvider.PROVIDER, new ConsoleAuthPrompter());
GetMethod httpget = new GetMethod("http://target-host/requires-auth.html");
httpget.setDoAuthentication(true);
try {
// execute the GET
int status = client.executeMethod(httpget);
// print the status and response
System.out.println(status);
System.out.println(httpget.getStatusLine().toString());
System.out.println(httpget.getResponseBodyAsString());
} finally {
// release any connection resources used by the method
httpget.releaseConnection();
}
}
public class ConsoleAuthPrompter implements CredentialsProvider {
private BufferedReader in = null;
public ConsoleAuthPrompter() {
super();
this.in = new BufferedReader(new InputStreamReader(System.in));
}
private String readConsole() throws IOException {
return this.in.readLine();
}
public Credentials getCredentials(
final AuthScheme authscheme,
final String host,
int port,
boolean proxy)
throws
{
if (authscheme == null) {
return null;
}
try{
if (authscheme instanceof NTLMScheme) {
System.out.println(host + ":" + port + " requires Windows authentication");
System.out.print("Enter domain: ");
String domain = readConsole();
System.out.print("Enter username: ");
String user = readConsole();
System.out.print("Enter password: ");
String password = readConsole();
return new NTCredentials(user, password, host, domain);
} else
if (authscheme instanceof RFC2617Scheme) {
System.out.println(host + ":" + port + " requires authentication with the realm '"
+ authscheme.getRealm() + "'");
System.out.print("Enter username: ");
String user = readConsole();
System.out.print("Enter password: ");
String password = readConsole();
return new UsernamePasswordCredentials(user, password);
} else {
throw new ("Unsupported authentication scheme: " +
authscheme.getSchemeName());
}
} catch (IOException e) {
throw new (e.getMessage(), e);
}
}
}
}
‘捌’ java/Web工程登录以及验证设计问题
其实这个问题吗。你考虑了效率问题。安全问题又来了。这个可以再数据库上面提下速。索引啥的。或者 减少 注册表的字段。都可以的。如果项目已经做好。尽量少改吧。越 改越乱。如果还是前期的话。可以试试。
‘玖’ Web应用常见的安全漏洞有哪些
Web应用常见的安全漏洞：
1、SQL注入
注入是一个安全漏洞，允许攻击者通过操纵用户提供的数据来更改后端SQL语句。当用户输入作为命令或查询的一部分被发送到解释器并且欺骗解释器执行非预期的命令并且允许访问未授权的数据时，发生注入。
2、跨站脚本攻击 （XSS）
XSS漏洞针对嵌入在客户端（即用户浏览器而不是服务器端）的页面中嵌入的脚本。当应用程序获取不受信任的数据并将其发送到Web浏览器而未经适当验证时，可能会出现这些缺陷。
3、跨站点请求伪造
CSRF攻击是指恶意网站，电子邮件或程序导致用户的浏览器在用户当前已对其进行身份验证的受信任站点上执行不需要的操作时发生的攻击。
4、无法限制URL访问
Web应用程序在呈现受保护的链接和按钮之前检查URL访问权限 每次访问这些页面时，应用程序都需要执行类似的访问控制检查。通过智能猜测，攻击者可以访问权限页面。攻击者可以访问敏感页面，调用函数和查看机密信息。
5、不安全的加密存储
不安全的加密存储是一种常见的漏洞，在敏感数据未安全存储时存在。用户凭据，配置文件信息，健康详细信息，信用卡信息等属于网站上的敏感数据信息。
(9)web验证机制设计缺陷扩展阅读
web应用漏洞发生的市场背景：
由于Web服务器提供了几种不同的方式将请求转发给应用服务器，并将修改过的或新的网页发回给最终用户，这使得非法闯入网络变得更加容易。
许多程序员不知道如何开发安全的应用程序。他们的经验也许是开发独立应用程序或Intranet Web应用程序，这些应用程序没有考虑到在安全缺陷被利用时可能会出现灾难性后果。
许多Web应用程序容易受到通过服务器、应用程序和内部已开发的代码进行的攻击。这些攻击行动直接通过了周边防火墙安全措施，因为端口80或443（SSL，安全套接字协议层）必须开放，以便让应用程序正常运行。
‘拾’ web服务器的缺陷是什么java是怎么样解决这个缺陷的
Web服务器的缺陷是什么？Java是怎么样解决这个缺陷的？因为web服务器是被设计用来向客户端提供HTTP服务的，它只能向客户端提供静态的网页内容，不能创建动态服务器端内容。java解决方案servlet和web容器对请求和响应的处理如下：1.客户端向web服务器发起一个HTTP请求；2.HTTP请求被WEB服务器接受，如果请求是静态页面，则由web服务器负责处理，如果请求是javaweb主件，则交给Web容器。Web容器可以在主机的同一个进程、不同的行程或其他的web服务器主机的进程中启动。3.web容器根据Servlet的配置文件确定调用具体的Servlet类，并把request对象、response对象传给它。4.Servlet通过request对象知道客户端的使用者是谁，客户的请求信息是什么和其他的一些信息。Servlet处理完请求后吧要返回的信息放入response对象返回到客户端。5.一旦Servlet完成请求的处理，web容器就会刷新response。并把控制权返回给web服务器。