Python密碼學與隱寫術技術實踐

$ pip3 install cryptography

from cryptography.fernet import Fernet

key = Fernet.generate_key()
cipher_suite = Fernet(key)
print("Key " + str(cipher_suite))

message = "Secret message".encode("utf8")
cipher_text = cipher_suite.encrypt(message)
plain_text = cipher_suite.decrypt(cipher_text)

print("Cipher text: " + str(cipher_text.decode()))
print("Plain text: " + str(plain_text.decode()))

from cryptography.fernet import Fernet

def generate_key():
    key = Fernet.generate_key()
    with open("secret.key", "wb") as key_file:
        key_file.write(key)

def load_key():
    return open("secret.key", "rb").read()

def encrypt_message(message):
    key = load_key()
    encoded_message = message.encode()
    fernet = Fernet(key)
    encrypted_message = fernet.encrypt(encoded_message)
    return encrypted_message

def decrypt_message(encrypted_message):
    key = load_key()
    fernet = Fernet(key)
    decrypted_message = fernet.decrypt(encrypted_message)
    return decrypted_message.decode()

if __name__ == "__main__":
    generate_key()
    message_encrypted = encrypt_message("encrypt this message")
    print('Message encrypted:', message_encrypted)
    print('Message decrypted:', decrypt_message(message_encrypted))

from cryptography.fernet import Fernet
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import base64
import os

password = "password".encode("utf8")
salt = os.urandom(16)

pbkdf = PBKDF2HMAC(
    algorithm=hashes.SHA256(),
    length=32,
    salt=salt,
    iterations=100000,
    backend=default_backend()
)

key = pbkdf.derive(password)
pbkdf.verify(password, key)

key = base64.urlsafe_b64encode(key)
fernet = Fernet(key)

token = fernet.encrypt("Secret message".encode("utf8"))
print("Token: " + str(token))
print("Message: " + str(fernet.decrypt(token).decode()))

import os
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC

# 產生隨機鹽值
salt = os.urandom(16)

# 定義金鑰派生函式
kdf = PBKDF2HMAC(
    algorithm=hashes.SHA256(),
    length=32,
    salt=salt,
    iterations=100000,
)

# 從密碼中產生金鑰
password = "mysecretpassword".encode("utf-8")
key = kdf.derive(password)

#### 內容解密：
1. `os.urandom(16)`用於產生隨機鹽值，增加金鑰的安全性。
2. `PBKDF2HMAC`類別用於定義金鑰派生函式，採用SHA256演算法，產生的金鑰長度為32位元組。
3. `derive`方法根據輸入的密碼產生金鑰。

#### 使用AES進行對稱加密
AES（Advanced Encryption Standard）是一種廣泛使用的對稱加密演算法。以下是一個使用`cryptography`模組實作AES加密與解密的範例：
```python
import os
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

# 產生隨機金鑰與初始向量
key = os.urandom(32)
iv = os.urandom(16)

# 建立AES加密器
cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
encryptor = cipher.encryptor()

# 加密訊息
message = "a secret message".encode("utf-8")
cipher_text = encryptor.update(message) + encryptor.finalize()

#### 內容解密：
1. `os.urandom(32)`與`os.urandom(16)`分別用於產生隨機金鑰與初始向量。
2. `Cipher`類別用於建立AES加密器，採用CBC模式。
3. `encryptor.update(message)`方法用於加密輸入的訊息。

### 隱寫術技術
隱寫術是一種將秘密訊息隱藏在公開資訊中的技術，例如影像、音訊或影片。

#### LSB隱寫術
LSB（Least Significant Bit）隱寫術是一種常見的影像隱寫術技術，透過修改畫素值的最低位來隱藏訊息。以下是一個使用Python實作LSB隱寫術的範例：
```python
from PIL import Image

def set_LSB(value, bit):
    if bit == '0':
        value = value & 254
    else:
        value = value | 1
    return value

def get_LSB(value):
    if value & 1 == 0:
        return '0'
    else:
        return '1'

# 定義函式以讀取影像並提取隱藏訊息
def extract_message(image_path):
    image = Image.open(image_path)
    pixel_list = list(image.getdata())
    message = ""
    for pix1, pix2 in get_pixel_pairs(pixel_list):
        message_byte = "0b"
        for p in pix1:
            message_byte += get_LSB(p)

#### 內容解密：
1. `set_LSB`函式用於設定畫素值的最低位。
2. `get_LSB`函式用於取得畫素值的最低位。
3. `extract_message`函式用於讀取影像並提取隱藏訊息。

## 使用最低有效位（LSB）技術進行隱寫術

隱寫術是一種將秘密資訊隱藏在非秘密資訊中的技術。在本章節中，我們將探討如何使用Python實作LSB隱寫術，以將文字資訊隱藏在影像中。

### LSB隱寫術原理

LSB隱寫術的基本原理是利用影像畫素值的最低有效位來隱藏資訊。由於人眼對影像的細微變化不敏感，因此可以透過修改畫素值的最低有效位來隱藏資訊，而不會對影像的視覺效果產生明顯影響。

### 使用Python實作LSB隱寫術

首先，我們需要匯入必要的模組，包括`PIL`（Python Imaging Library）用於影像處理。

#### 隱藏資訊

要將資訊隱藏在影像中，我們需要將資訊轉換為二進位制格式，然後將每個二進位制位替換到影像畫素值的最低有效位中。

```python
from PIL import Image

def hide_message(image, message, outfile):
    message += chr(0)
    c_image = Image.open(image)
    c_image = c_image.convert('RGBA')
    out = Image.new(c_image.mode, c_image.size)
    width, height = c_image.size
    pixList = list(c_image.getdata())
    newArray = []
    
    for i in range(len(message)):
        charInt = ord(message[i])
        cb = str(bin(charInt))[2:].zfill(8)
        pix1 = pixList[i*2]
        pix2 = pixList[(i*2)+1]
        newpix1 = []
        newpix2 = []
        
        for j in range(0,4):
            newpix1.append(set_LSB(pix1[j], cb[j]))
            newpix2.append(set_LSB(pix2[j], cb[j+4]))
        
        newArray.append(tuple(newpix1))
        newArray.append(tuple(newpix2))
    
    newArray.extend(pixList[len(message)*2:])
    out.putdata(newArray)
    out.save(outfile)
    return outfile

#### 內容解密：
此函式首先開啟輸入影像並將其轉換為RGBA模式。然後，它建立一個新的影像，並將原始影像的畫素資料複製到新的影像中。接下來，它遍歷要隱藏的資訊的每個字元，將其轉換為二進位制格式，並將每個二進位制位替換到影像畫素值的最低有效位中。最後，它儲存新的影像。

### 提取隱藏資訊

要提取隱藏的資訊，我們需要讀取影像的畫素值，並從最低有效位中還原二進位制資訊。

```python
def extract_message(image_path):
    c_image = Image.open(image_path)
    pix = c_image.getdata()
    message = ""
    message_byte = "0b"
    for p in pix:
        message_byte += get_LSB(p)
        if len(message_byte) == 9:
            if message_byte == "0b000000000":
                break
            message += chr(int(message_byte,2))
            message_byte = "0b"
    return message

#### 內容解密：
此函式開啟影像並讀取其畫素值。然後，它遍歷每個畫素值，提取最低有效位，並將其組合成二進位制位元組。當遇到一個全零位元組時，它停止讀取，並傳回提取的資訊。

### 使用Stegano和Stepic進行隱寫術

除了手動實作LSB隱寫術外，還可以使用現有的工具，如Stegano和Stepic。

#### Stegano

Stegano是一個用於在PNG影像中隱藏文字資訊的工具。可以使用以下命令安裝：
```bash
$ sudo pip3 install stegano

$ pip3 install stepic

import secrets

# 生成一個安全的隨機令牌
token = secrets.token_urlsafe(32)
print(token)

#### 內容解密：
此程式碼使用`secrets.token_urlsafe()`函式生成一個安全的隨機URL安全令牌，該令牌可以用作金鑰或密碼。