摘要：嘛，既然開始學密碼了，就還是記錄一下自己的學習歷程，這樣也會有意思一些，希望自己能夠做到一周寫兩次自己的學習進度吧，今天先來第一步什么叫密碼學哦。

嘛，既然開始學密碼了，就還是記錄一下自己的學習歷程，這樣也會有意思一些，希望自己能夠做到一周寫兩次自己的學習進度吧，今天先來第一步：什么叫密碼學哦。

最近和教授討論研究的方向，很煩，因為我才剛剛入學，信息安全方面的論文要說完整讀下來的基本還沒有，所以慢慢積累吧，最近在讀的[1]基本也是卡在了經典的homomorphic Encrytion--Paillier加密上。沒辦法，數學基礎比較堪憂，老師和我商量后也是基本定在做同態密碼了，所以，慢慢啃吧。

啊，扯遠了，首先開始寫寫什么叫密碼學吧，然后在舉個栗子。

Cryptography or cryptology (from Greek κρυπτ?? kryptós, "hidden, secret"; and γρ?φειν graphein, "writing", or -λογ?α -logia, "study", respectively[1]) is the practice and study of techniques for secure communication in the presence of third parties called adversaries.[2] More generally, cryptography is about constructing and analyzing protocols that prevent third parties or the public from reading private messages;[3] various aspects in information security such as data confidentiality, data integrity, authentication, and non-repudiation[4] are central to modern cryptography. Modern cryptography exists at the intersection of the disciplines of mathematics, computer science, and electrical engineering. Applications of cryptography include ATM cards, computer passwords, and electronic commerce.[2]

意思基本就是兩層：1，密碼學的基本目標就是：保護兩個人的通訊不會被第三方所攻擊，即使被第三方截獲通訊消息（密文）他也無法獲取原始消息（明文）。2.現代密碼學用處很大什么地方都在用。

上面說的現代密碼學，既然有現代密碼學自然有古典密碼學咯~ 事實上古典密碼學基本是不需要數學基礎的是一些很簡單很純粹的想法，但是可以非常直觀的展現什么是密碼，作為啟發。

那么要說最經典的當然是凱撒密碼啦，具體名字咋來的我懶得去找了，大概就是這么個意思，見下圖：

出處：http://invpy.com/cipherwheel
選定一個秘鑰k∈[0,25]且為Z，然后去轉動這個羅盤，將外層的A轉到你選定的K值上，將原文（M）的每一個字母由外層字母映射到內層字母。
栗子如下：
if key = 8：

[3]
上面是原文M，下面是譯文（E），于是我們把密文發送出去：BPM AMKZMB XIAAEWZL QA ZWAMJCL 并附上Key = 8。 收到的人只要再拿出這個羅盤，對準A，將內存字母映射到外層字母即可解密了。

當然，非常簡單，當然，也很愚蠢。 因為秘鑰只有26個，窮舉也能破解，更不用說更高端的手段了。

嘛，順手附上一個python讀文件加解密的代碼：

# -*- coding: utf-8 -*-
# __author__ = "summer"

dictionary = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]


def ceaserCipher(i_str, key, mode="encrypt"):
    o_str = ""
    if mode == "decrypt":
        key = 0 - key
    for i in xrange(len(i_str)):
        if i_str[i] in dictionary:
            index = (dictionary.index(i_str[i]) + key) % 26
            o_str += dictionary[index]
        else:
            if i_str[i].isupper():
                index = (dictionary.index(i_str[i].lower()) + key) % 26
                o_str += dictionary[index].upper()
            else:
                o_str += i_str[i]
    return o_str

def encryptFromText(filepath, filename, key=0):
    bufferstr = b""
    with open(filepath + filename, "rb") as f:
        for line in f.readlines():
            bufferstr += line
    o_str = ceaserCipher(bufferstr, key)
    with open(filepath + "encrypted " + filename, "w") as f_out:
        f_out.writelines(o_str)

def decryptFromText(filepath, filename, key=0):
    bufferstr = b""
    with open(filepath + filename, "rb") as f:
        for line in f.readlines():
            bufferstr += line
    o_str = ceaserCipher(bufferstr, key, "decrypt")
    with open(filepath + "decrypted " + filename, "w") as f_out:
        f_out.writelines(o_str)

所以呢，通過這個例子，我們可以數學上的來定義一個cipher system：

Def：a cipher defined over(K,M,C)(all sets of Keys/Messages/Ciphertext) is a pair of "efficient" algorithm (E,D) where:E => Encrypt algo. :K M -> C ,D => Decrypt algo. :K C -> M
s.t. for all m∈M，k∈K：D(k,E(k,m)) = m

且一般情況下E是一個隨機算法（Randomized algo.），D是一個確定算法（Deterministic algo.）

當然，密碼體系是否安全，這些概念以及具體的數學定義以后再寫。原諒我懶得去弄TeX寫數學符號了，很累的！

上面說了，凱撒加密有個大問題在于秘鑰數量太少即|K|=26... 專業的說就是秘鑰空間太小，那么古典密碼學上有一種叫做transposition Encrypt，他擴大了秘鑰空間。
具體的方案：
我們選定一個信息比如：“Common sense is not so common.”
選定一個任意整數的秘鑰k，比如k = 8
然后我們確定出k個格子

這個樣子，然后往里面依照信息的字母往格子里填字母：

依次往后推如圖的感覺。注：（s）表示空格space
然后，我們豎著來輸出密文C：
“Cenoonommstmme oo snnio. s s c”

就這樣，加密成功了！那么解密呢，一樣是建立這樣的格子，然后豎著往里面填密文，橫向輸出就OK了唄。實現起來也很簡單，無非就是個數組的嵌套罷了數組里面扔數組。

代碼湊合看吧沒仔細斟酌：

# -*- coding: utf-8 -*-
# __author__ = "summer"
def main():
    myMessage = "We shade in the two boxes in the last row to remind us to ignore them."
    myKey = 8
    ciphertext = encryptMessage(myKey, myMessage)
    print ciphertext
    print decryptMessage(myKey, ciphertext)

def encryptMessage(key, message):
    o_arr = []
    for i in xrange(key):
        index = 0 + i
        while index < len(message):
            o_arr.append(message[index])
            index += key
    return "".join(o_arr)

def decryptMessage(key, message):
    o_arr = []
    row = len(message) / key + 1
    last_row = len(message) % key
    if last_row == 0:
        last_row = key
    for i in xrange(row):
        index = 0 + i
        flag = 0
        isLastRow = False
        if index == row - 1:
            isLastRow = True
        while index < len(message):
            flag += 1
            if isLastRow and flag > last_row:
                break
            o_arr.append(message[index])
            if flag <= last_row:
                index += row
            else:
                index += (row - 1)
    return "".join(o_arr)

if __name__ == "__main__":
    main()

明顯解密比較麻煩主要就是難在最后的空格的問題，怎么去豎著填格子。有興趣的可以去leetcode看看zigzag的那道題，意思差不多。

嘛，這種加密方法看上去把秘鑰空間擴充為了無窮！乍一看好厲害，但是你計算能力有極限，我當然窮舉也能破解啦。當然這個算法有很多改良比如打亂密碼輸出順序之類的，不過攻擊方法大同小異，經不起窮解攻擊。

當然還有一些比較有意思的比如字母頻率攻擊Monoalphabetic Encryption啊之類的有興趣的可以去查查（雖然基本也就是科普作用可以當故事來看啦嗯哼）

OK今天就寫到這里，有遺漏錯誤之處也希望有大牛能夠一擊斃命點醒我啊我也還是個剛入門的孩子hohoho，下次準備寫一寫信息論與密碼安全。

[1]Atallah M J, Frikken K B, Blanton M, et al. Private combinatorial group testing[C]//Proceedings of the 2008 ACM symposium on Information, computer and communications security. ACM, 2008: 312-320.
[2]Wikipedia,keyword:Cryptography
[3]Al Sweigart, Hacking Secret Ciphers with Python