RSA演算法原理

1976年，兩位美國計算機學家 $W h i t f i e l d D i f f i e$ 和 $M a r t i n H e l l m a n$ ，提出了一種嶄新構思，可以在不直接傳遞金鑰的情況下，完成解密。這被稱為"Diffie-Hellman金鑰交換演算法"。這個演算法的產生，預示著非對稱加密誕生了。

非對稱加密的場景是：A給B傳送資訊。

B要先生成兩把金鑰（公鑰和私鑰）。公鑰是公開的，任何人都可以獲得，私鑰則是保密的。
A獲取B的公鑰，然後用它對資訊加密。
B得到加密後的資訊，用私鑰解密。

1977年，三位數學家 $R i v e s t$ 、 $S h a m i r$ 和 $A d l e m a n$ 設計了一種演算法，可以實現非對稱加密。這種演算法用他們三個人的名字命名，叫RSA演算法。從那時直到現在，RSA演算法一直是最廣為使用的"非對稱加密演算法"。毫不誇張地說，只要有計算機網路的地方，就有RSA演算法。這種演算法非常可靠，金鑰越長，它就越難破解。根據已經披露的文獻，目前被破解的最長RSA金鑰是232個十進位制位，也就是768個二進位制位，因此可以認為，1024位的RSA金鑰基本安全，2048位的金鑰極其安全，當然量子計算機除外。

RSA基本原理

首先我們需要明白幾個基本概念

素數：又稱質數，指在一個大於1的自然數中，除了1和此整數本身外，不能被其他自然數整除的數。
互質，又稱互素。若N個整數的最大公因子是1，則稱這N個整數互質。
模運算即求餘運算。”模“是“ $m o d$ ”的音譯。和模運算緊密相關的一個概念是“同餘”。數學上，當兩個整數除以同一個正整數，若得相同餘數，則二整數同餘。

尤拉函式

任意給定正整數n，請問在小於等於n的正整數之中，有多少個與n構成互質關係？（比如，在1到8之中，有多少個數與8構成互質關係？）計算這個值的方法就叫做尤拉函式，以 $\phi (n)$ 表示。

比如，計算8的尤拉函式，和8互質的 1、2、3、4、5、6、7、8，所以 $\phi(8) = 4$

尤拉函式的幾個特性

如果n是質數的某一個次方，即 $n = p^k$ (p為質數，k為大於等於1的整數)，則 $\phi(n)=\phi(p^k)=p^k-p^(k-1)$ 。

比如： $\phi(8)=\phi(2^3)=2^3-2^2=8-4=4$
如果n是質數，則 $\phi(n)=n-1$ 。因為質數與小於它的每一個數，都構成互質關係。

比如：計算7的尤拉函式，7是質數， $\phi(7) = 6$
如果n可以分解成兩個互質的整數之積，即$ n = p * k$ ，則 $\phi(n) = \phi(p * k) = \phi(p1)*\phi(p2)$ ，

比如： $\phi(56) = \phi(8) * \phi(7) = 4 * 6 = 24$

尤拉定理

如果兩個正整數m和n互質，那麼m的 $\phi(n)$ 次方減去1，可以被n整除。
$m^{\Phi (n)} \mod n \equiv 1$

小費馬定理

尤拉定理的特殊情況，如果兩個正整數m和n互質，而且n為質數！那麼φ(n)結果就是n-1
$m^{(n-1)} \mod n \equiv 1$

模反元素

如果兩個正整數e和x互質，那麼一定可以找到整數d，使得$ed-1 $被 x 整除，或者說$ ed$被x除的餘數是1。那麼d就是e相對於x的模反元素。
$\mod x \equiv 1$

以上基本原理都很淺顯，接下來稍微轉化一下
$m^{\Phi (n)} \mod n \equiv 1 \tag{1}$

$m^{k*\Phi (n)}\mod n \equiv 1 \tag{2}$

$m^{k*\Phi (n)+1}\mod n \equiv m \tag{3}$

$\equiv k*x+1 \tag{4}$

$m^{e*d} \mod n \equiv m \tag{5}$

公式3與公式4轉化為公式5，需要一個前提： $e$ 與 $\phi (n)$ 互質

我們可以將公式5變換一下：
$m^{e*d} \mod n ==> (m^e)^d \mod n \tag{6}$

$m^e \mod n \equiv c \\ c^d \mod n \equiv m$

第一個用於加密，第二個用於解密。假設 $m = 12$ （隨便取值，只要比n小就可以）， $n = 15$ （還是隨機取一個值，不一定非要互質）， $\phi(n) = 8$ ， $e = 3$ ( $e$ 必須和 $\phi(n)$ 互質），這裡取 $d = 19$ （ $3 d - 1 = 8$ ，d也可以為3，11等等，也就是 $d = (8 k + 1) / 3$ ）

演算法過程

隨意選擇兩個大的質數p和q，p不等於q，計算 $N = p * q$ 。
根據尤拉函式，不大於N且與N互質的整數的個數為 $(p - 1) (q - 1)$ 。
選擇一個整數e與 $(p - 1) (q - 1)$ 互質，並且e小於 $(p - 1) (q - 1)$ 。
用以下這個公式計算d： $\mod (p-1)(q-1) \equiv 1$ 。
將p和q的記錄銷燬。

這裡得到的(N, e)是公鑰，(N, d)是私鑰。

下面展示RSA的實現細節

import time


def range_prime(start, end):
    l = list()
    for i in range(start, end+1):
        flag = True
        for j in range(2, int(i**0.5)+1):
            if i % j == 0:
                flag = False
                break
        if flag:
            l.append(i)
    return l


def generate_keys(p, q):
    numbers = range_prime(10, 100)
    N = p * q
    C = (p-1) * (q-1)
    e = 0
    for n in numbers:
        if n < C and C % n > 0:
            e = n
            break
    if e == 0:
        raise BaseException("e not found")
    d = 0
    for n in range(2, C):
        if(e * n) % C == 1:
            d = n
            break
    if d == 0:
        raise BaseException("d not found")
    return (N, e), (N, d)


def quick_algorithm(a, b, c):
    a = a % c
    ans = 1
    while b != 0:
        if b & 1:
            ans = (ans * a) % c
        b >>= 1
        a = (a * a) % c
    return ans


def encrypt(m, key):
    C, x = key
    # return quick_algorithm(m, x, C)
    return (m ** x) % C


def decrypt(m, key):
    return encrypt(m, key)


def ord2hex(num):
    return hex(num)


if __name__ == '__main__':
    start = int(1e3)
    end = int(1e5)
    prime_list = []
    count = 0
    while len(prime_list) < 2:
        if count > 5:
            raise RecursionError("達到最大次數")
        prime_list = range_prime(start, end)
    a = prime_list[0]
    b = prime_list[-1]
    print(a, b)
    time1 = time.time()
    print("開始產生金鑰對")
    public_key, private_key = generate_keys(a, b)
    print("私鑰：", private_key)
    print("公鑰：", public_key)
    time2 = time.time()
    print("金鑰對生成結束，耗時：{}s".format(time2-time1))
    ord_list = []
    encode_list = []
    s_input = input("請輸入要加密的字串：")
    time3 = time.time()
    print("開始加密")
    for s in s_input:
        s_ord = ord(s)
        s_encode = encrypt(s_ord, public_key)
        ord_list.append(s_ord)
        encode_list.append(s_encode)
    time4 = time.time()
    print("加密完成，耗時：{}s".format(time4-time3))
    # print(ord_list)
    print(encode_list)
    print("原資料：", [ord2hex(num) for num in ord_list])
    print("加密後的資料：", ":".join([ord2hex(num) for num in encode_list]))
    print("開始解密")
    time5 = time.time()
    decode_list = []
    for num_encode in encode_list:
        ord_decode = decrypt(num_encode, private_key)
        decode_list.append(ord_decode)
    time6 = time.time()
    print("解密完成，耗時：{}s".format(time6-time5))
    print("解密後的資料：", [ord2hex(num) for num in decode_list])
    print("轉化為字串：", [chr(num) for num in decode_list])