『壹』 有狀態的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伺服器。