=========================
 甚麼是 John the Ripper?
=========================

John the Ripper 是一個 UNIX 密碼破解工具程式, 可以使用的作業系統環境有 UNIX (在 Linux x86, FreeBSD x86, Solaris 2.x SPARC, OSF/1 Alpha 都測試過了), DOS, WinNT/Win95. 當然, 在你使用 John 之前, 最好已經使用過其它的 UNIX 密碼破解工具, 這樣你才可以很容易的瞭解 John 的運作方式與操作方法!

======
 概觀
======

作者把 John 儘量設計成強大, 而且快速的破解工具. 在同一個程式裡面包含了幾種的 破解方式, 而且你可以完全的依照你的需求來自訂 John 破解的方式(我覺得這點很強, 甚至可以用內建的 C Script 來自定不同個案的破解方式, 容後說明). 而且 John 也可以在不同的系統平台上使用, 讓你可以在不同的電腦上破解密碼, 在範例中的接續破解, 可以讓你在破解中斷之後, 在不同的作業平台上接下去破解.

John 的 crypt() 函式在快速作業的模式之下進行了最佳化, 這可以讓 John 在破解的時候跑得比其它的破解工具快, 這個函式同時套用了組合語言及可轉平台式 C 語言兩個語言所寫出來的程式碼.

John 支援了以下幾種的破解方式:
- 有規則及不規則的字典檔破解模式;
- "Single Crack", 用最簡單的資訊來進行破解的工作, 速度最快.
- 增強破解模式(我們稱暴力法), 嘗試所有可能的字元組合;
- 外部破解模式, 讓你可以定義你的破解模式.

==========
 如何安裝
==========

John 所提供的是壓縮過的程式, 你需要建一個目錄, 然後把這些檔案都拷貝到那個目 錄底下, 然後將你需要的檔案解壓縮(當然你必需要有解縮的程式).在你使用這個壓縮 檔以前你可能須要先下達一個 'chmod +x john' 指令.

如果你要 Compile 原始程式的話, 只要進入你解壓這些檔案的目錄, 然後在系統提示 符號下輸入 'make', 你就會在螢幕上看到一份系統支援的列表. 選擇你所使用的系即可. 如果你的系統沒有在該列表上, 就請你輸入 'make generic'. 請你確定你使用的 是 GCC 且 GNU make (也許你得輸入包含路徑的執行指令, 例如 '/bin/make',如果你 的系統沒有設定路徑的話).

==========
 如何使用
==========

作者已經儘量把 John 的操作方式設計得跟 Cracker Jack 相同, 所以如果你先前曾經 使用過 Crack Jack, 應該很快的就能夠使用 John. 總之, 有很多 Cracker Jack 的功能, 都可以在 John 上面延用, 操作方法也是相同的.

要使用 John the Ripper, 你必需要有一些密碼檔, 破解好的密碼將會顯示在螢幕上, 並且會儲存在一個叫作 ~/john.pot 的檔案中 ('~' 所代表的是 John 的相同目錄, 也就是你放置 John 的目錄).這個檔案還有另一個功能, 就是讓 John 不要重覆跑你已經 破解過的帳號, 如果你使用 John 再跑一次曾經跑過的密碼檔, 相同的帳號不會再跑過 一次, 如果你想要看你已經破解過的密碼, 你可以使用 '-show' 這個功能.

在破解的時候, 你可以按下 Enter 來觀看目前破解的狀態,或是按下 Ctrl+C 來中斷目前的破解工作, 這樣程式會自動將目前破解到的位置, 儲存在一個檔案之中 (~/restore 為內定的檔名), 另外, 如果你是按了兩下 Ctrl+C 來中斷的話, John 就會直接中斷而不會將目前破解進度儲存了. 這個破解進度檔每十分鐘也會自動的儲存, 以必免你的機器在破解中當機而功虧一潰. (這是個不錯的設計, 當然 Jack 裡也有這項功能)

 命令列的功能選項
------------------

你可以在執行 John 的命令列後加上下面這些選項 (所有的選項都不須區分大小寫):

       -pwfile:<檔名>[,..]     指定密碼檔檔名 (可以使用萬用字元)

這個選項用來指定你所要破解的密碼檔 (通常在命令列上要使用的檔案名稱, 不能夠使用以 '-'這個字作為開頭的檔案名稱, 因為 '-'已經被用來當作命令列的辨識字元了).

       -wordfile:<檔名> -stdin 字典檔破解模式, 由字典檔讀取來破解, 或是 stdin

這個選項用來開啟 John 為字典檔破解模式.

       -rules                  打開規則式字典檔破解模式

開啟規則式 (就像使用 Alec Muffett 的方式破解). 至於規則的定義就是使用放在 ~/john.ini 中 [List.Rules:Wordlist] 所定義的規則.

       -incremental[:<mode>]   增強模式 [使用 john.ini 中定義的模式]

開啟增強模式, 使用你在 ~/john.ini 中所定義的模式來破解 (在 [Incremental:<mode>] 段落中你可以自行定義, <mode> 就是在這裡你所要指定的 <mode> 名稱, [Incremental:All] 為內定).
這一段可以讓你指定很多不同的方式, 我們會在後面再說明.

       -single                 Single Crack模式

開啟 "Single Crack" 模式, 使用你在 [List.Rules:Single] 中所定義的規則.

       -external:<mode>        外部破解模式, 使用你在 john.ini 定義的 <mode>

開啟外部破解模式, 將會自動啟用你在 ~/john.ini 的 [List.External:<mode>] 段中所定義的自訂破解功能.

       -restore[:<檔名>]       回復上一次的破解工作 [經由 <檔名>]

繼續上次中斷的破解工作, 由特定的檔案 (通常是 ~/resotre) 讀取上一次破解的時候 中斷的位置, 然後接下去破解. 這可用在中斷破解之後的接續破解.

       -makechars:<檔名>       製作字元表, 你所指定的檔名若存在會被覆寫

產生一個內含字元表的檔案, 他會以 ~/john.pot (找到的密碼) 為基礎來產生. 這個產生出來的檔案你可以用在增強破解模式上. 除非你指定了其它的密碼檔, 不然系統將會自動抓 ~/john.pot 內容來產生字元表. 你也可以同時使用 filter() 函式來進行過濾.

       -show                   顯示已破解的密碼

顯示已經破解完成的密碼. 你必需同時指令你要顯示的密碼檔是哪一個才行.

       -test                   執行速度測試

這個功能可以用來測試你所使用的電腦的破解速度, 它會顯示一個速度的比較表來告訴 你你的電腦在不同的環境 (要破解的帳號多寡) 所產生的不同效率, 讓你可以作好最佳的調整.

在你不熟悉的密碼檔破解的時候 :xform1() 跟 xform2() 是真實的編碼函式, 它呼叫了每一個 key/salt (一對一對的呼叫), 當你每個字呼叫 setkey(), 表示說 xform1() 或 xform2() (要看你是用哪一種破解模式才能決定是哪一個) 在足夠的 salts 載入之後, 是唯一會被影響到破解速度的函式,總而言之, setkey() 可以決定你在使用這個程式的 時候的速度, 當你使用的是以 MD5 編碼的密碼檔, md5crypt() 就會取代所有的其它函式.

       -users:<login|uid>[,..] 只破解這一個使用者(或群組)

讓你能夠過濾只破解某些特定的人, 你也可以用在 '-show' 這個功能. (通常你會只找 root, 但是我建議你能夠找 uid =0 的人, 因為 uid=0 也就表示他具有 root 同等的權限)

       -shells:[!]<shell>[,..] 只針對某些使用你指定的 shell(s) 的使用者破解

這個選項可以用在 破解/顯示 使用的是你所指定的 shell 的帳號, 或者是不要顯示/ 破解這些帳號(也就是說可以用來過濾) 在 Shell 名稱前加上 '!' 就表示 Not 了. 你可以在的 Shell 名稱之前指定絕對路徑, 或者也可以不指定, 當然 '-shells:csh' 就會包含 '/bin/csh' 跟 '/usr/bin/csh' ,如果你指定的是 '-shells:/bin/csh' 將只會包含 '/bin/csh' 這個 Shell 名稱.

       -salts:[!]<count>       只破解 salts 大於 <count> 的帳號

這個功能通常使用在讓你得到最高的系統效能來破解密碼上. 如同範例, 你可以只破解 某些的 salts 使用'-salts:2'這個選項, 會使你的系統運作快一點, 然後再破解 rest 使用 '-salts:!2' 這個選項 (配合著使用). 總共需要的破解時間大約是相同的, 不過你得到已破解帳號的速度會快一些, 而且系統不需要休息.

       -lamesalts              設定 salts 中密碼所使用的 cleartext

當你不知道你在作甚麼的時候, 不要使用這個選項.

       -timeout:<time>         設定最長的破解時間 <time> 分鐘

當你設定的時間到達時, John 將會自動中斷目前的破解工作.

       -list                   列出每一個字

在標準輸出設備上 (通常是螢幕) 列出已經破解出的每一個字(密碼). 這個功能可以用 在檢查你的自訂破解模式是否正確的完成.

       -beep -quiet            當發現密碼 是/否 要發出聲響

你可以在 ~/john.ini 中指定你所要的預設值.

       -noname -nohash         不要使用記憶體來儲存 login name 跟其它的資料

在你沒有足夠的記憶體來跑 John 的時候, 你可能需要這個選項. '-noname' 不能使用在 "Single Crack" 模式之下. 因為 Login name 必須在此模式下使用!

       -des -md5               強制使用 DES 或 MD5 模式

這個選項讓你自行決定密碼加密的方式(不用自動判斷). 你要注意的是 John 並不能在同一個破解工作中同時跑兩種不同的密碼加密方式, 如果你的密碼檔是兩種的, 你就要分開來跑!

 附加的工具程式
----------------

你也許會使用到 John 所附的一些工具程式:

       xtract [source] [> <target>]

由文字檔中取出字典檔, 讓你可以把字典檔使用在破解上. 重覆的字不會自動的移除, 你須要再使用 'sort -u' 來作輸出 (這裡的指令是用在 UNIX 上的).

       unshadow <passwd> <shadow> [> <target>]

組合 passwd 跟 shadow 檔案 (當你已經得到這兩個檔的時候) 讓真正的密碼檔得以還原, 這樣你就可以在 John 上面使用了. 你也許會需要這個功能, 如果你只有 shadow 過的密碼檔案, GECOS 資訊不能在 "Single Crack" 模式下使用, 而且也不能夠使用 '-shells' 這個選項的功能.

============
 破解的模式
============

這裡的破解模式的敘述通常都很簡短, 而且只函括了一些基本的東西, 你可以看一下 "使用者自訂" 這一個小節, 來穫得更多的資訊.

 字典檔模式
------------

這是 John 所支援的破解模式中最簡單的一種, 你須要的只是指定一個字典檔 (文字檔案, 每行一個英文單字)及一個或一些密碼檔, 你可以使用規則化的方式(用來修正每個 讀入的單字) 來讓這些規則自動的套用在每個讀入的單字中.

字典檔中的字不能夠有所重覆, 因為 John 並不會刪除重覆及將字典檔排序, 所以如果有重覆的化會占用過多的記憶體, 最好能將一些常用的字典放在你字典檔的開頭, 當然你最好能夠按字母的排列方式來排序你的字典檔,(如果每一個字跟先前的那個字的差別 小一點的話, John 會跑得稍微快一點點, 這也是為甚麼要排序的原因了, 這個狀況在你 破解的密碼檔小的時候特別明顯). 譯者按:沒想到連這個都測試, 真是想得週到呀!!

另外, 你不須要擔心每一個字元的長度超過了八個字元, John 會自動比對這些字, 如果前八個字元一樣, John 會自動的處理這種情況, 而且只試同一個密碼一次, 前提是這個字必須是接在前一個字後面, 這也就是為甚麼要排序字典檔的原因了. 你最好是不要擅作主張的把超過八字元的字切成八個字元, 因為在規則化的破解模式之下, 後面的字可能還會有其它的用處.
譯者按: 因為 DES編碼方法在以前的系統上有八字元的限制, 所以超過八字元的密碼亦 視同八字元來編碼, 超過的部分則會被系統自動切除.

 "Single Crack" 模式
---------------------

這是你剛才使破解密碼時需使用的, 它將會試著使用 login/GECOS資訊來當做密碼, 這些資訊通常適用於該資訊來源的帳號(在帳號上是相同的 salt, 所以幾乎不需要額外的 破解時間 (很快的意思), "Single Crack" 婆式比字典檔模式還要快很多, 它也讓你可 以使用許多種規則 (這些規則通常在使用此一模式時都會開啟) 在合理的時間之內. 當然, 這個模式只會得到使用基本資料來當作密碼的使用者資料.

值得注意的是, 當你用這個模式在同一個時間跑很多的密碼檔時, 通常會比你將這些檔 案分開來跑, 還要能夠更快的得到已經破解的密碼.

不要跑盡所有的規則也許是一個好方法, 但是節省時間, 然後用其它的破解模式來跑, 這樣的話規則型態會以號碼來排列破解的密碼.

CJack 的使用者必需要注意到 John 的 "Single Crack" 模式是完全不一樣(更好)的. 它不需要指定一個密碼檔, 因為密碼檔製造的規則型態與程式碼已經內建在 John 裡頭了.

 增強模式
----------

這是功能最強大的破解模式, 它可是試所有可能的字元組合來當作密碼, 但是這個模式 是假設在破解中不會被中斷, 所以當你在使用長字串組合時, 最好不要直中斷執行 (事實上你還是可以在執行時中斷, 如果你設定了密碼字串長度的限制, 或者是讓這個模式 跑一些字元數少一點的字元集), 然後你將可以早一點中斷它的執行.

這就是為甚麼這個麼式須要指定字元頻率表(character frequency tables, 字元集)-- 在有限的時間內去得到所有可能的密碼.

要使用這個破解模式, 你須要指定及定義破解模式的參數,(包含密碼長度的限制還有字 元集). 這些參數必須寫入到 ~/john.ini 中的[Incremental:<mode>] 這一段內,<mode> 可以任意命名 (就是你必須要在執行 John 時在命令列指定的名稱).你可以使用一個重 新定義的增強模式, 或是定義一個自訂的.

若你曾經定義過了一次, 日後當你要再使用同一種增強模式的時候只要指定增強模式要 套用的選項, 相同的選項及密碼檔的套用就會自動的回復.

 擴充模式
----------

在使用John的時候你可以定義一些擴充的破解模式.只要在~/john.ini 的[List.External:<mode>] 一節中指定就可以了,<mode>就是你所指定的模式名稱. 這一段中必須要包含一些 John 嘗試要產生的字典的功能. 這些功能的撰寫方式就是 C 語言的子集,它會自動的在 John 執行前編譯 (只有在你開啟 John 時使用這個模式才會被編譯).

==========
 如何自訂
==========

John the Ripper 的破解行為及方式可以編輯 ~/john.ini 來自訂, 你可以在執行 John 的時候在命令列指定破解方式, 其它 John 的選項不會受到命令列的影響, 為增強模式 定義一些參數, 為 Single Crack 模式定義一些規則, 或者你也可以定義一個新的破解方式.

這個設定檔 (~/john.ini) 是由許多小段組合而成的. 每一個小段的起始是由括弧括起 來, 裡面所寫的是這一段的名稱. 每一個段中內含了指定的一些變數來組成可變動的變 數, 或由一些特別的項目來指定段的型態(像這樣的段啟始字元為 'list.'). 段跟可動變數的大小寫對程式來講是無所謂的. 如果在行前加上了 '#' 或是 ';' 字元, 就表示這一行將會被程式所略過不予執行, 你可以用來加入一些註解.

 一般選項
----------

預設一些命令列選項可以放在 [Defaults] 這一段中. 你可以定義下面這些值:

Wordfile   設定你的字典檔檔名, 這會自動虛擬成你正使用的破解模式是字典檔模式,
           你不需要再加上 '-wordfile' 這個選項.

Timeout    設定中斷的時間, 單位為分鐘.如果使用這個選項的話, 所有的破解模式都
           會接受時間到就自動停止 (建議不要指定這項, 在命令列指定就好了).

Beep       當系統找到密碼時會發出 '嗶'聲, 或是在一些要問你 (Yes/No) 的時候也
           會令你的電腦發出聲響來提醒你. 另一組相反的選項為 '-quiet', 它不會
           令你的電腦發出聲響, 所以最好先指定 Beep, 當你需要讓電腦安靜時在命
           令列使用 -quiet 即可.

一些其它的選項可以先定義在 [Options] 這一段中:

Realtime   設定已經經過的時間為 D:HH:MM:SS 來取代原先用秒數來計算的方式 (跟
           CJack 相同).

Percent    設定顯示百分比指示器.

 增強破解模式的參數
--------------------

要定義一個增強模式的參數, 你需要先建立一個叫作 [Incremental:<mode>] 的段, 這裡的 <mode> 你可以自訂這一段的名稱. 在 John 裡面有一些已經設定好的預設增強模 式的參數定義, 你可以用這些定義來當作你自訂參數的範本. 下面這些是支援的參數:

CharCount  讓你限制不同字元使用時的字數限制, 讓 John啟始時可以早一點試跑長字
           串的密碼,也可以用來設定字元集的特別長度當使用一個外部的字元集檔案
           其字元數量小於你在 CharCount 所設的字元數時.內定值(當此值未定義時
           的預設值) 所有定義的字元都會被使用.

MinLen     最小的密碼字串長度, 字元數 (1 為內定值).

MaxLen     最大的密碼字串長度, 字元數 (8 為內定值).

Wordlike   設定為 'Y' 可以開啟一個簡單的字典過濾器 (一排字有多於一個的母音,
           或多於兩個個沒有母音的一排字, 都會被過濾掉).

File       外部字元集檔名 (檔案是由你所設定的路徑讀入, 內定為 ~ 目錄) 設定這
           個參數會取消你在設定檔中內定的字元集.

CharsetNM  (N 與 M 為數字格式, 1 <= N <= 8, 1 <= M <= N)為一個密碼檔定義一個
           字元集長度為 N, 字元指標為 M.字元的順序是很重要的, 比較頻繁的字元
           將會較先被取代, 字元集不需要是相同的大小.

 字典檔的規則
--------------

定義給字典檔及 "single crack" 模式的節段是放在一個叫做 [List.Rules:Wordlist] 跟 [List.Rules:Single] 之中. 作者使用一種叫作擴充破解 (by Alec Muffett) 的語法, 或許有許多人對於這種破解模式已經很熟悉了. 作者加入了更多重要的的規則來使 它更為優秀, 讓它能夠使用同一個原始來源產生更多更複雜的方式.

當在定義規則的時候, 在每一行中只需要安排一種規則 (之前可能需要下達一些指令). 每一種規則是由一個或多個指令組成. 下面這些指令是 John 所支援的 (大部分的說明 是由 Crack 程式的 dicts.rules 所轉錄下來的, 但是程式碼是作者自己重寫的, 而且比 Crack 還要快):

一般常用指令:
:       no-op - 不要在輸入的字之後作任何動作
<n      拒絕輸入的字長度是 < n 的字元, n = 0-9
>n      拒絕輸入的字長度是 > n 的字元, n = 0-9
^x      將 'x' 由每個輸入的字移出
$y      在每個輸入的字後加上 'y' 這個字元
l       強制小寫字
u       強制大寫字
c       強制第一個字大寫(其餘小寫)
r       把字元排列次序巔倒: "Fred" -> "derF"
d       重覆每個字: "Fred" -> "FredFred"
f       鏡射形態字: "Fred" -> "FredderF"
p       嘗試每個字元的大小寫變化 (abc, Abc, aBc, abC....)
onx     如果字元不滿幾個字, 就把它加到幾個字, n (由 0 開始) 每個未足字元都以 'x' 字取代.
inx     在指定字元數插入 'x' 的字元, 字元數 n (由 0 開始) 後面的字將會依插入的字元多寡
        而向右邊作位移
        nb: 如果指定的 > 字串總長度(input), 字元 'x' 將會用增加的方式加上
xnm     由字串中抽離某些字, 字元數 n (由 0 開始) 而且會抽離 m 個字元.

會使用在字元層級的指令:
sxy     取代 (交換), 將字串中所有的字元 'x' 取代為 'y'
s?cy    用 'y' 來取代所有字元為 'c' 者
@x      由字串中清除所有字元為 'x' 者
@?c     由字串中清除所有字元為 'c' 者
!y      拒絕執行字串中包含有 'y' 者
!?c     拒絕執行字串中包含在 class 'c' 中有定義的
/x      拒絕所有字串中未包含字元 'x' 者
/?c     拒絕除了字中包含 class 'c' 以外的所有字
=nx     拒絕除了 class 等於 'x' 以外的所有
=n?c    拒絕除了 class 'c' 以外的所有字
        nb: 所有的字串都由位置(Position) 0 開始計算

用在上面所敘述的字元 class 的指令:
??      相同於 '?'
?v      相同於 母音: "aeiouAEIOU"
?c      相同於 子音: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
?w      相同於 空白符號: " \t"
?p      相同於 標點符號: ".,:;'\"?!`"
?s      相同於 一般符號: "$%^&*()-_+=|\\<>[]{}#@/~"
?l      相同於 小寫字母 ('a' to 'z')
?u      相同於 大寫字母 ('A' to 'Z')
?d      相同於 數字 ('0' to '9')
?a      相同於 字母 ('a' to 'z' and 'A' to 'Z')
?x      相同於 字母及符號 ('a' to 'z', 'A' to 'Z' and '0' to '9')
用來表示相反 class 的字元就用大寫的字母來表示,
例如: 用 ?d 來表示 '數字(DIGITS)', ?D 就表示 '非數字(NON-DIGITS)' 依此類推.
 

上面所敘述的只令是跟 Crack v4.1 相同的, 下面的則是 John 中所新增的 (作者說明
這些指令也許不是很有用處, 且大部分的東西在 Crack v4.1 也可以作得出來):

{       字串左移: "jsmith" -> "smithj", etc
}       字串右移: "smithj" -> "jsmith", etc
Dn      刪除位置 n 的字元 (由 0 開始) 及把該字元後的字左移
P       "crack" -> "cracked", etc (過去式, 只針對小寫)
G       "crack" -> "cracking", etc (現在進行式, 只針對小寫)
~i      由鍵盤方式轉換大小寫(加 Shift 鍵): "Crack96" -> "cRACK(^", etc
~I      轉換大小寫: "Crack96" -> "cRACK96", etc
~v      將母音轉小寫: "Crack96" -> "CRaCK96", etc
~>      由鍵盤方式將所有字元右移: "Crack96" -> "Vtsvl07", etc
~<      由鍵盤方式將所有字元左移: "Crack96" -> "Xeaxj85", etc

特別針對 "single crack" 模式的指令有雙字串支援, 控制這些指令要套用指令時需要
用到下列的命令:

1       只有第一個字
2       只有第二個字
+       包含兩個字 (必需只用在 '1' 或 '2' 之後, 也就是 1+2 或 2+1)

如果你在規則設定中使用了上述的指令, 將只會執行雙字串(全名, 由GECOS資料得來), 而放棄只有單一字串的字.
'+' 會假定在規則結尾使用這些命令的時候, 除非你用手動指定. 例如, '1l2u'會轉換 第一個字為小寫, 第二個字為大寫, 而且會把兩個字相連. 在使用 '+'時可能要應用一 些其它的指令: 在你分別應用一些指令來執行的時候 '1l2u+r' 會用相反順序來相連這 兩個字, .

[Crack v5.0 在作者更新 John 的時候還沒有發行, 所以作者使用一些自己的方法來擴 充規則語法. 事實上, 新版 Crack v5.0 的規則看起來像是多餘的, 或是跟作者已加在
 John 裡的功能是相同的([ == D0, ] == rD0r, C == c~I, t == ~I, (x == =0x, )x == r=0xr, 'n == x0n). 不一樣的規則為 %nx, or %n?c (拒絕執行, 除非該字串最少包含了有 n 個 'x' 字元, 或是 n 個 class 'c' 裡定義的字元).無論如何, 作者已經把所有的功能都加在 John 裡面了, 基於相容性的理由. 請確定字首 '[' 及 ']' 加上了 '\'如果你有使用到的話, 因為他們已經用來控制其它的功能了. ]

如果一個規則 (命令列的一行) 沒有改變字, 那一個字將會被排除而不執行, 除非整個規則包含了冒號 ':', 假設你加入了冒號 ':' 在你的規則定義中.

前置處理是用在組合類似的規則進入同一個來源. 如同範例, 如果你希望讓 John 嘗試小寫密碼並加上數字, 你可以為每個數字定義一個規則, 總共有十個. 現在想像一下加 入兩位數字(號碼)--這樣設定檔會便得很大且會很難看.

用前置處理, 你可以很簡單的就作到這些事情: 很簡單的寫一個來源行, 包含這些規則 的共用部分, 在括號中寫出你要放進不同規則中的字元 (你必需要使用正規的表示法). 然後前置處理器就會在 John 啟始的時候產生你所要的規則, 像上面的範例一樣,

來源行會是 'l$[0-9]' (小寫字串, 並且加上數字) 及 'l$[0-9]$[0-9]' (小寫字串並 加上兩位數字). 這些來源行會分別的加到 10 及 100 規則. 總之, 前置處理的命令處 理順序是由又至左, 字元的處理順序則是由左至右, 在加入兩位數字這樣的例子中, 會得到正常的順序. 注意我在這些範例中只用到字元範圍的形態 (由 A到Z 等的為範圍形 態), 但是你可以用字元列表來組合他們, 像 '[aeiou]' 會使用母音, 還有 '[aeiou0-9]' 會使用母音跟數字.

有一些控制字元在規則裡 ('[' 括號用來啟始一個字元列表, '-' 表示一個包含在內的 範圍, 這一類的). 如果你希望把某一行放在設定檔裡面, 但是又不想使用他們的話,你 可以在前面加上 '\' 符號, 那會使 John 忽略這一行不去執行. 還有, 如果你需要開始 一個前置處理表列在開始的一行中, 你將會用到 ':' 符號, 不然的話 John會認為它是 一個新節段的開始.

 定義擴充模式
---------------

要定義一種擴充模式, 你需要建立一個節段叫作 [List.External:<mode>], <mode> 就是你自己對這個模式定義的名稱. 這一個節段中必需要包含一些使用 C 語言子集所寫的 函數, 當你在命令列使用這個模式的時候, John 會編譯及使用這些程式, 編譯程式會產 生虛擬機械碼, 比任何直譯器或轉換程機器可執行碼來得好用 (現在只完成了 x86 硬體可使用的部分).

下面這些功能是一般會在 John 中使用到的:

init()     在啟始時呼叫, 會初始全域變數
filter()   在試每一個字串時呼叫, 可以將一些字串過濾掉
generate() 產生字串時呼叫, 當沒有使用其它的破解模式時
restore()  回復一個中斷的工作時呼叫

這些函數的型別都是 'void', 不需要引數(參數), 使用到了全域變數 'word' (已定義為 'int word[16]'), 除了 init() 之外, 它在 'word'初始之前已經被呼叫了. 'word' 變數包含了要試的字串(ASCII),filter()可以改變它, 或是0以外的, 可以用'word[0]' 來保留它. generate() 不能假設任何特殊值的 'word'當它被呼叫的時候, 但是可以將它放在下一個將要試的字串, 或是0以外 'word[0]' 當破解工作結束的時候 (這將會引起 John 結束執行). restore() 必需設定全域變數來繼續執行由支援的 'word' 字串.

你可以單獨使用任意一個擴充模式, 或跟其它某些模式一起使用, 在這個情況之下只有 init() 以及 filter() 會被使用到 (而且只有 filter() 是必需要的). 使用擴充模式 的過濾器跟其它的破解模式及 '-makechars' 這個命令是相容的.

我們建議你不要使用 filter(), 最少在使用擴充模式於你自己的 generate() 時不要過濾太多的字, 最好的方法是改一下 generate() 使它不要產生會被過濾掉的字串.

就像作者在上面所提到過的, 編譯器支援了 C 語言的子集. John 是一個 cracker, 不是一個編譯器, 所以我不認為它需要其它的東西. 這裡有一個列表, 列舉出 John 跟 C 編譯器功能上的差別:

- 只支援標準的功能, 你不能自行定義一個自己的;
- 只支援 'while' 的迴圈;
- 只支援 'int' 與 'void' 資料型別;
- 只支援單一十進位的陣列;
- 不支援結構化
- 不支援指標 (沒錯, 你有更多的陣列了呀);
- 大概還有些別的吧...

一些支援的功能與 C 語言不同的地方:

- 陣列名稱單獨參考到它的第一個基本元件而非這個陣列的位址(以 0 作啟始);
- '++' 跟 '--'運算元在表示式計算的時候執行, 而不是 pre/post-calculated; 這會  在 C 的很多例子中傳回相同的結果 (像在 C 語言跟 John 的編譯器中 'i = j++;'  都等於 'i = j; j = j + 1;' 但是假如這些變數被應用不只一次的話, 傳回的結果會  跟 C 不同 (如 'i = j++ - j++;' 在 John 中就等於 'i = j - (j + 1); j = j + 2;'  但是在 C 語言裡卻變成是 'i = j - j; j = j + 2;');
- 我希望沒有別的地方是不同的了...

無論如何, 強力的 C 語言語法結構 (所有整數運算元),'if'/'else' 跟 'while' 仍然可以使用. 這對所有的小程式來講應該是足夠的了. 你可以看看在設定檔支援的範例檔 中的擴充模式範例.

==========
 使用範例
==========

這些範例可以讓你瞭解使用 John 可以幫你作哪些事, 也許不夠明白的來表示該如何來 使用, 我只能試著來回答一些問題:

 命令列
--------

1. 假設你剛得到一個密碼檔,'passwd.1', 且你想要試著破解它, 你可以使用 Singel
   Crack" 模式:

   john -single passwd.1

或者,你也可以使用簡寫(John在很多選項都有提供簡寫的方式,讓你很快的能夠完成輸入)

   john -si passwd.1

如果你有很多的檔案要破解, 最好的方式就是一次讀進來:

   john -single passwd.1 passwd.2

或者你也可以這樣:

   john -single passwd.*

2. 現在, 當你已經破解了一些密碼, 這些已破的密碼將會存在 ~/john.pot 這個檔案裡
   你可以瀏覽一下你所破解的密碼:

   john -show passwd.1

如果這個列表超出了螢幕(解出了很多密碼??), 你可以使用下面這個輸出方式:

   john -show passwd.1 | more

現在, 你可能會得到一些錯誤訊息告訴你有許多的帳號的 shell已經被取消掉了, 你可以讓 John 修改這些字串 (假設 shell 名稱為 '/etc/expired'):

   john -show -shells:!/etc/expired passwd.1

或是簡寫, 但是會跟 '/any/path/expired'有相同的效果:

   john -show -shells:!expired passwd.1

或者, 你也想要修改其它的 shell 字串, 如 '/etc/newuser':

   john -show -shells:!expired,!newuser passwd.1

檢查看看有沒有 root (uid 0) 帳號已經破解成功了:

   john -show -users:0 passwd.1

或者, 檢查所有密碼檔中, 已破解的 root (uid 0) 帳號:

   john -show -users:0 passwd.*

只顯示 root (login 'root') 帳號:

   john -show -users:root passwd.1

3. 當你使用 "Single Crack"模式, 破解出來的帳號數目不是很多的時候, 你可以使用    較具威力的破解模式, 例如字典檔模式. 假設你的字典檔名為 'words.lst':

   john -w:words.lst passwd.1

或者, 把規則破解模式也打開 (會更慢, 但是更具威力):

   john -w:words.lst -rules passwd.1

要只破解擁有完整 shell 使用權的帳號 (一般來說, '-shells' 跟 '-users' 這兩個過濾就可以完成你想要作的工作了, 在其它的破解模式也是一樣.

   john -w:words.lst -rules -shells:sh,csh,tcsh,bash passwd.1

就跟其它的破解模式一樣, 你可以更快的破解一些檔案, 一次下達指令:

   john -w:words.lst -rules passwd.*

可以只破解某些帳號. 像下面這個命令會試著破解具有 root (uid 0) 權限的帳號:

   john -w:words.lst -rules -users:0 passwd.*

然而, 我不建議你只破解 root 的密碼, 因為那通常會比用系統安全漏洞來獲取 root 的權限花費更長的時間(通常不是在合理的時間內可以作到的), 如果你是用來試著破解 你自己主機上的密碼, 想要確定這些密碼不會被破解的話, 最好是選一個好一點的root 密碼, 然後只破解其它的.

有時把你的密碼檔分開兩部分並且分別進行破解是有用的, 就像:

   john -w:words.lst -rules -salts:2 passwd.*
   john -w:words.lst -rules -salts:!2 passwd.*

這會使 John 在試兩個或更多的帳號時動作快一點, 然後再試其它的總共需要的破解時 間將會差不多, 但是你會更容易的得到一些破解的帳號, 而且可能也不需要其它的. 還有, 你可能想要用一個小一點的字典檔來試所有的帳號, 只有用這個方法你可以試得快 一點 (用 '-salts:2') 在一個大型的密碼檔上. 通常這是在使用 '-salts'大於 2 (有時甚至高於 1000 都還可以執行), 為你的個別狀況進行調整吧.

注意你定義的字典檔規則第一行中包含了 ':' (表示 '試所有包含在列表中的字'), 如果你已經執行了一個字典檔破解模式而沒有使用規則的話, 也確定你用相同的字典檔加 上規則來跑, 這一點要特別注意!!

4. John 裡最強的破解模式是增強模式, 你可以試著用這個指令跑跑看:

   john -i passwd.1

這個指令會使用內定的增強模式的參數, 定義在 ~/john.ini's [Incremental:All] 這一個節段中. 在設定檔中支援了這些參數使用所有 95 個字元集, 而且試所有長度的密 碼, 從 1 到 8 個字元. 不要預期這個模式的破解會在合理的時間內結束 (除非所有的 密碼都設得很容易破, 而且很快的被破解掉了).

在很多的情況之下, 當你破解一些簡單的密碼時, 使用其它定義好的增強模式會比較快 一些, 由限制字元集來著手. 下面的指令只會試 26 個字元組合排列方式, 由 1 到 8 個字元來算, 它將會嘗試由 'a' 到 'zzzzzzzz'的所有字:

   john -i:alpha passwd.1

相同的, 你可以配合著增強模式只破解 root 帳號 及使用一些其它 John的功能, 這個指令會試著破解所有的 root (uid 0) 帳號在所有的密碼檔中, 而且只有在這些產生的 相同 salts, 所以你得到最少兩倍的效率 -- 如果你有很多個密碼檔的話 (像 1000 個密碼檔, 命名為 '*.pwd'), 否則就是沒有 root 在相同的 salts:

   john -i -users:0 -salts:2 *.pwd

5. 如果你得到了一個密碼檔, 而且已經有很多個帳號已經破解了 (但你需要更多), 而   且這個密碼檔的密碼設定是相當罕見的,你可能會想要產生一個新的字元集檔案, 以   該密碼檔為基礎的字元集:

   john -makechars:custom.chr passwd.1

然後把這個新的檔案用在增強模式中.

如果你由同一個國家得到很多個密碼檔的話, 也許可以把他們一起用來產生字元集檔案 這樣你可以用它來幫你破解出更多的密碼, 當然這個自元集日後也可以用在同一個國家 所得到的密碼檔上:

   john -makechars:custom.chr passwd.1 passwd.2
   <把你的 custom 增強模式定義在 ~/john.ini 中>
   john -i:custom passwd.3

上面這個範例中, 我門假設 'passwd.1' 跟 'passwd.2' 這兩個密碼檔是來自同一個國 家, 而且你已經擁有很多破解過的密碼了, 而 'passwd.3' 也是從相同的國家來的, 你現在正打算要破解它.

當你在產生一個新的字元集檔案的時候, 你可以使用一些已經定義好的, 或自行定義的 過濾器, 來產生一些簡單的字串:

   john -makechars:my_alpha.chr -external:filter_alpha passwd.1

如果你的 ~/john.pot 設定檔已經很肥大的話 (或是你沒有的字元集檔案), 也許你會想要使用它來產生新的字元集檔案:

   john -makechars:all.chr
   john -makechars:alpha.chr -external:filter_alpha
   john -makechars:digits.chr -external:filter_digits

在上面的範例中, John 會覆寫已經存在的字元集檔(如果它們原先已經在你的目錄中的 話), 寫入的內容就是你在 ~/john.pot (John 使用整個檔案, 如果你沒有指定任何密碼 檔的話), 為了你的方便使用, 注意字串過濾的使用也定義在 ~/john.ini 之中.

 設定檔
--------

1. 假設你認為你要破解的某些密碼檔中有很多的使用者他們所設定的密碼都是以帳號
   名稱再加上 '?!' 的話. 你只要新增一個 "Single Crack" 模式的規則, 把這一行   放在你的設定檔中:

   [List.Rules:Single]
   $?$!

提示: 如果你要將 John 原先所設定的預設值保留下來的話, 你可以簡單的修改這個節
      段的名稱, 把它改成 John 沒有使用的名稱, 然後再建立一個跟舊節段一樣名稱
      的節段, 但請注意新節段必需要把 'list.' 這個關鍵字移除 (不使用), 這樣在
      執行的時候才不會出現錯誤.

   相同的指令也能夠套用在字典檔破解規則上.

2. 如果你產生了一個自訂的字元集檔案(如上所述) 你也需要使用增強模式的參數定義
   一個~/john.ini 的節段. 最簡單的情況之下看起來會像下面這樣 ('Custom'所指的   可以是其它的檔案, 用你所喜歡的名稱來命名):

   [Incremental:Custom]
   File = custom.chr

這會讓 John 只使用你用該密碼所製作出來的字元集, 如果你想要用所有 95 個字元的話, 你也需要加入這一行:

   CharCount = 95

加入這一行會告訴 John 擴充你的字元集檔, 如果 95個字元(ASCII codes 32 to 126) 中的某些字元沒有出現在你的字元集檔中, 字元加入的次序為: a-z, A-Z, 1-9, 0, 及其它.

你也可以使用 CharCount 來限制 John 使用不同的字元數:

   CharCount = 25

如果你在產生字元集檔時沒有使用任何的過濾器, 設定較低的 CharCount會剃除一些罕 見的字元, 能夠讓 John 更容易嘗試較複雜, 較長的密碼

要讓 John 只嘗試某些長度的密碼, 可以加入下面這幾行:

   MinLen = 6
   MaxLen = 8

把 'MinLen' 設定的長一點, 就像上面的範例一樣, 在機器有限制使用者密碼長度的時 候是很合理的 (然而, 注意 root 通常可以為使用者設定任何長度的密碼而不受此限). 相反的, 如果你覺得密碼應該不會是很長的, 你可能會想要把 'MaxLen'設定得小一點.

當只使用字母字元(alphabetical)的時候, 也許開啟簡單的內見過濾器會很有用, 如果很多密碼設定得很簡單:

   [Incremental:Wordlike]
   CharCount = 26
   MinLen = 3
   Wordlike = Yeah
   File = alpha.chr

3. 當使用 John 在安裝小於 4Mb 的機器上時, 你可能須要使用小一點的字元集, 在使   用 '-makechars' 來產生的字元集, 需要很大的記憶體來擴充 (要快一點執行的話)   在你同時讀進很多個密碼檔的時候也需要這樣子作, 在沒有足夠的記憶體時, 或讓   John 在破解很少的 salts 時稍微跑得快一點. 這都有可能會發生, 因為 John 在每   個字讀入像上一次讀入的字, 或只有某些部分的字有改變時速度會快一些. 當使用了   大的擴充字元集檔的時候, 字串通常每一次的測試都是比在 ~/john.ini 中的小字元    集大很多, 字串的差別會相差很大. 而且, 大的字元集在擴充的時候花花費較多的時   間. 然而, 你需要注意的就是利益/時間是呈正比的, 要得到更多的密碼就要花更多   的時間, 用最好的順序來跑大的擴充字集也是很重要的. 所以聰明的人會使用小一點   的字元集, 如果他們沒有別的選擇的話, 或是你原本就是想要嘗試所有可能的組合.

   我故意把比較小的字元集由~/john.ini中拿掉, 這樣你才能夠在 'File=' 這一行中   寫上你會用到的字元集

4. 在其它特殊的情況之下, 你也許會使用自訂的較小字元集, 如果你知道使用者常把    他們的密碼加上'1', 你可以用這樣的範例:

   [Incremental:Suffix1]
   MinLen = 6
   MaxLen = 6
   Charset61 = abcdefghijklmnopqrstuvwxyz
   Charset62 = abcdefghijklmnopqrstuvwxyz
   Charset63 = abcdefghijklmnopqrstuvwxyz
   Charset64 = abcdefghijklmnopqrstuvwxyz
   Charset65 = abcdefghijklmnopqrstuvwxyz
   Charset66 = 1

5. 你也可以用寫一個額外的字串過濾器來達到跟上例相同的結果:

   [List.External:Filter1]
   void filter() {
     int i;

     i = 0;
     while (word[i] && word[i] >= 'a' && word[i] <= 'z') i++;
     if (word[i] != '1' || word[i + 1]) word = 0;
   }

這個過濾器只會把有相同字元且結尾是 '1' 的濾除. 你可以把它用在其它不同的破解模 式中, 但是都會變得很慢, 因為大部分的字都會被濾掉. 最好是使用它來產生字元集然 後再來使用, (如果你已經有很多密碼已經破解了, 會跳過過濾器).

如果你在某些情況下無法使用頻率表(沒有找到規則), 你可以在額外破解模式中用相同 的程式:

   [List.External:Suffix1]
   int len, current[9];

   void init() {
     int i;

     current[len = 6] = 0; current[i = len - 1] = '1';
     while (i--) current[i] = 'a';
   }

   void generate() {
     int i;

     i = len + 1;
     while (i--) word[i] = current[i];

     i = len - 2;
     while (++current[i] > 'z')
     if (i) current[i--] = 'a'; else current = -1;
   }

   void restore() {
     int i;

     i = len + 1;
     while (i--) current[i] = word[i];
   }

小恐龍工作坊 提供