PythonからGnuPGを操る！python-gnupgライブラリ徹底解説

pip install python-gnupg

import gnupg
import os
# 例: ホームディレクトリを指定してGPGオブジェクトを初期化
gpg_home = os.path.expanduser('~/.gnupg') # デフォルトの場所の例
# gpg_home = '/path/to/your/custom/gpghome' # 特定のディレクトリを指定する場合
gpg = gnupg.GPG(gnupghome=gpg_home)
# gpgオブジェクトを使って様々な操作を行う
# ...

import gnupg
# GnuPGホームディレクトリを指定して初期化 (推奨)
gpg = gnupg.GPG(gnupghome='/path/to/gpghome')
# デフォルトのホームディレクトリを使用する場合 (非推奨の場合あり)
# gpg = gnupg.GPG()
# GPG実行ファイルのパスを明示的に指定する場合
# gpg = gnupg.GPG(gpgbinary='/usr/local/bin/gpg')
# 詳細なログを出力する場合 (デバッグ用)
# gpg = gnupg.GPG(gnupghome='/path/to/gpghome', verbose=True)

# 公開鍵の一覧を取得
public_keys = gpg.list_keys()
print("--- Public Keys ---")
for key in public_keys: print(f"Fingerprint: {key['fingerprint']}") print(f" Key ID: {key['keyid']}") print(f" Type: {key['type']}") print(f" Length: {key['length']}") print(f" Usage: {key['usage']}") print(f" Algo: {key['algo']}") print(f" Ownertrust: {key['ownertrust']}") print(f" Uids: {key['uids']}") print(f" Subkeys: {key['subkeys']}") print("-" * 20)
# 秘密鍵の一覧を取得 (引数に True を指定)
private_keys = gpg.list_keys(True)
print("\n--- Private Keys ---")
for key in private_keys: # 秘密鍵の場合、表示される情報は限られることが多い print(f"Fingerprint: {key['fingerprint']}") print(f" Key ID: {key['keyid']}") print(f" Type: {key['type']}") print(f" Trust: {key['trust']}") # 秘密鍵の場合は trust が表示されることがある print(f" Uids: {key['uids']}") print("-" * 20)

# ファイルから公開鍵をインポート
with open('bob_public_key.asc', 'r') as f: key_data = f.read()
import_result = gpg.import_keys(key_data)
print(f"Imported keys count: {import_result.count}")
print(f"Fingerprints: {import_result.fingerprints}")
# 詳細な結果は import_result.results リスト (辞書) に格納される
for result in import_result.results: print(f" Action: {result.get('action')}, Fingerprint: {result.get('fingerprint')}")
# 文字列からインポートする場合も同様
# key_string = """-----BEGIN PGP PUBLIC KEY BLOCK-----
# ... (公開鍵データ) ...
# -----END PGP PUBLIC KEY BLOCK-----"""
# import_result = gpg.import_keys(key_string)

# 特定の公開鍵をASCII形式でエクスポート (フィンガープリントで指定)
key_fingerprint = 'YOUR_FINGERPRINT_HERE' # エクスポートしたい鍵のフィンガープリント
ascii_armored_public_key = gpg.export_keys(key_fingerprint)
# ファイルに保存
with open('my_public_key_exported.asc', 'w') as f: f.write(ascii_armored_public_key)
print("Public key exported to my_public_key_exported.asc")
# 秘密鍵をエクスポート (パスフレーズが必要な場合が多い)
# GnuPG 2.1以降では、秘密鍵のエクスポートにパスフレーズが必須
try: ascii_armored_private_key = gpg.export_keys( keyids=key_fingerprint, secret=True, passphrase='your_secret_passphrase' # 秘密鍵のパスフレーズ ) with open('my_private_key_exported.asc', 'w') as f: f.write(ascii_armored_private_key) print("Private key exported to my_private_key_exported.asc")
except Exception as e: print(f"Error exporting private key: {e}")
# 複数の鍵をエクスポートする場合は keyids にリストを渡す
# public_keys_ascii = gpg.export_keys(['FP1', 'FP2'])

# 鍵生成のためのパラメータを設定
input_data = gpg.gen_key_input( key_type="RSA", # 鍵の種類 (RSA, DSA, ECCなど) key_length=2048, # 鍵長 (ビット単位) name_real="Alice Example", # 氏名 name_comment="Test key", # コメント name_email="alice@example.com", # メールアドレス expire_date="2y", # 有効期限 (例: 2年、0は無期限) passphrase="supers3cr3t" # 秘密鍵のパスフレーズ (GnuPG 2.1以降は必須に近い) # no_protection=True # パスフレーズなしで生成する場合 (非推奨)
)
# 鍵を生成
key = gpg.gen_key(input_data)
if key: print(f"Key generated successfully!") print(f"Fingerprint: {key.fingerprint}") print(f"Key ID: {key.keyid}") # key オブジェクトには生成された鍵の情報が含まれる
else: print("Key generation failed.") # エラー詳細は gpg オブジェクトのログなどで確認

fingerprint_to_delete = 'FINGERPRINT_OF_KEY_TO_DELETE'
# まず公開鍵を削除
delete_result_pub = gpg.delete_keys(fingerprint_to_delete)
print(f"Delete public key result: Status={delete_result_pub.status}, Stderr={delete_result_pub.stderr}")
# 次に秘密鍵を削除 (パスフレーズが必要な場合あり)
try: delete_result_sec = gpg.delete_keys(fingerprint_to_delete, secret=True, passphrase='your_secret_passphrase') print(f"Delete secret key result: Status={delete_result_sec.status}, Stderr={delete_result_sec.stderr}")
except Exception as e: print(f"Error deleting secret key: {e}")
# 存在しない鍵を削除しようとするとエラーにはならないが、statusに変化がない場合がある
# delete_result = gpg.delete_keys('NON_EXISTENT_FINGERPRINT')

# 暗号化するデータ
plain_text = "これは秘密のメッセージです。"
# 受信者のキーIDまたはフィンガープリント (リストで複数指定可)
recipient_keyid = 'RECIPIENT_KEYID_OR_FINGERPRINT'
# recipients = ['KEYID1', 'KEYID2'] # 複数の受信者
# 文字列データを暗号化
encrypted_data = gpg.encrypt( plain_text, recipients=recipient_keyid, always_trust=True, # キーの信頼性をチェックしない (テスト用など) # sign='YOUR_SIGNING_KEYID', # 署名を同時に行う場合 # passphrase='your_signing_passphrase' # 署名用パスフレーズ
)
if encrypted_data.ok: print("Encryption successful!") encrypted_string = str(encrypted_data) # ASCII Armor形式の暗号文 print("Encrypted data (ASCII Armor):") print(encrypted_string) # バイナリ形式で取得したい場合: encrypted_binary = encrypted_data.data
else: print("Encryption failed.") print(f"Status: {encrypted_data.status}") print(f"Stderr: {encrypted_data.stderr}")
# ファイルを暗号化
input_filename = 'plain_document.txt'
output_filename = 'encrypted_document.txt.gpg'
with open(input_filename, 'rb') as f: # バイナリモードで開く encrypt_status = gpg.encrypt_file( file=f, recipients=recipient_keyid, always_trust=True, output=output_filename # armor=False # バイナリ形式で出力する場合 )
if encrypt_status.ok: print(f"File '{input_filename}' encrypted successfully to '{output_filename}'.")
else: print(f"File encryption failed.") print(f"Status: {encrypt_status.status}") print(f"Stderr: {encrypt_status.stderr}")

# 暗号化されたASCII Armor形式の文字列
encrypted_string = """-----BEGIN PGP MESSAGE-----
... (暗号化されたデータ) ...
-----END PGP MESSAGE-----"""
# 文字列データを復号
decrypted_data = gpg.decrypt( encrypted_string, passphrase='your_secret_passphrase' # 秘密鍵のパスフレーズ
)
if decrypted_data.ok: print("Decryption successful!") print(f"Decrypted text: {decrypted_data.data.decode('utf-8')}") # バイト列なのでデコードが必要 print(f"Fingerprint of the key used: {decrypted_data.fingerprint}") print(f"Key ID used: {decrypted_data.key_id}") # 署名も含まれている場合 if decrypted_data.signature_id: print(f"Signature ID: {decrypted_data.signature_id}") print(f"Signer Fingerprint: {decrypted_data.signer_fingerprint}") print(f"Signature Valid: {decrypted_data.valid}")
else: print("Decryption failed.") print(f"Status: {decrypted_data.status}") # 例: 'decryption failed', 'bad passphrase' print(f"Stderr: {decrypted_data.stderr}")
# 暗号化されたファイルを復号
encrypted_filename = 'encrypted_document.txt.gpg'
decrypted_filename = 'decrypted_document.txt'
with open(encrypted_filename, 'rb') as f: # バイナリモードで開く decrypt_status = gpg.decrypt_file( file=f, passphrase='your_secret_passphrase', output=decrypted_filename )
if decrypt_status.ok: print(f"File '{encrypted_filename}' decrypted successfully to '{decrypted_filename}'.")
else: print(f"File decryption failed.") print(f"Status: {decrypt_status.status}") print(f"Stderr: {decrypt_status.stderr}")

# 署名するデータ
message_to_sign = "このドキュメントは私が作成しました。"
# 署名に使用する秘密鍵のキーID (省略するとデフォルトの鍵が使われる)
signing_keyid = 'YOUR_SIGNING_KEYID'
# 文字列データに署名 (クリア署名: 元のテキストが見える形式)
signed_data_clear = gpg.sign( message_to_sign, keyid=signing_keyid, passphrase='your_signing_passphrase', clearsign=True # デフォルトで True
)
if signed_data_clear: # 成功時は署名データ、失敗時は False など print("Clear signing successful!") signed_string_clear = str(signed_data_clear) print("Signed data (Clear sign):") print(signed_string_clear)
else: print(f"Signing failed. Status: {getattr(signed_data_clear, 'status', 'Unknown')}") print(f"Stderr: {getattr(signed_data_clear, 'stderr', 'Unknown')}")
# 文字列データに署名 (分離署名: 署名データが別になる形式)
signed_data_detached = gpg.sign( message_to_sign, keyid=signing_keyid, passphrase='your_signing_passphrase', detach=True, clearsign=False # 分離署名の場合、通常 False にする # armor=False # バイナリ形式の分離署名にする場合
)
if signed_data_detached: print("\nDetached signing successful!") detached_signature = signed_data_detached.data # バイト列の署名データ print(f"Detached signature (binary, length {len(detached_signature)})") # 必要であればファイルに保存 # with open('message.sig', 'wb') as sig_file: # sig_file.write(detached_signature)
else: print(f"Detached signing failed.")
# ファイルに署名 (ファイルにクリア署名)
input_filename = 'document_to_sign.txt'
output_filename_signed = 'signed_document.txt.asc'
with open(input_filename, 'rb') as f: sign_status = gpg.sign_file( file=f, keyid=signing_keyid, passphrase='your_signing_passphrase', output=output_filename_signed, clearsign=True )
if sign_status: print(f"\nFile '{input_filename}' clear signed successfully to '{output_filename_signed}'.")
else: print(f"File signing failed. Status: {getattr(sign_status, 'status', 'Unknown')}")

# 検証するクリア署名データ
signed_string_clear = """-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256
このドキュメントは私が作成しました。
-----BEGIN PGP SIGNATURE-----
... (署名データ) ...
-----END PGP SIGNATURE-----"""
# クリア署名を検証
verified_clear = gpg.verify(signed_string_clear)
if verified_clear: # 検証成功時は Verify オブジェクト、失敗時は False など print("Clear signature verification successful!") print(f"Signer User ID: {verified_clear.username}") print(f"Signer Key ID: {verified_clear.key_id}") print(f"Signer Fingerprint: {verified_clear.fingerprint}") print(f"Signature ID: {verified_clear.signature_id}") print(f"Signature Status: {verified_clear.status}") # 例: 'signature valid' print(f"Timestamp: {verified_clear.sig_timestamp}") print(f"Trust level: {verified_clear.trust_text} ({verified_clear.trust_level})") # verified_clear.data には署名部分を除いた元のデータが含まれる (バイト列) print(f"Original data: {verified_clear.data.decode('utf-8')}")
else: print("Clear signature verification failed.") if verified_clear is not None: # Verify オブジェクトだが検証失敗の場合 print(f"Status: {verified_clear.status}") # 例: 'signature bad', 'no public key' print(f"Stderr: {verified_clear.stderr}")
# 分離署名の検証
original_data_filename = 'original_message.txt'
signature_filename = 'message.sig' # 分離署名ファイル
# ファイルから分離署名を検証
with open(original_data_filename, 'rb') as data_file, open(signature_filename, 'rb') as sig_file: verified_detached_file = gpg.verify_file(sig_file, data_filename=original_data_filename)
if verified_detached_file: print("\nDetached signature (file) verification successful!") print(f"Signer User ID: {verified_detached_file.username}") # ... (他の情報も同様に表示)
else: print("\nDetached signature (file) verification failed.") if verified_detached_file is not None: print(f"Status: {verified_detached_file.status}")
# メモリ上のデータと分離署名で検証
original_data_bytes = b"This is the original content."
detached_signature_bytes = b"..." # 分離署名データのバイト列
verified_detached_mem = gpg.verify_data(detached_signature_bytes, original_data_bytes)
if verified_detached_mem: print("\nDetached signature (memory) verification successful!") print(f"Signer User ID: {verified_detached_mem.username}") # ...
else: print("\nDetached signature (memory) verification failed.") if verified_detached_mem is not None: print(f"Status: {verified_detached_mem.status}")

import gnupg
import sys
import io
import queue
import threading
gpg = gnupg.GPG(gnupghome='/path/to/gpghome')
# 例1: 復号結果を標準出力にストリーミング
class DataPrinter: def __call__(self, chunk): sys.stdout.buffer.write(chunk) # バイト列を標準出力へ return True # Trueを返すとライブラリ内部でもバッファリングされる
gpg.on_data = DataPrinter()
encrypted_filename = 'large_encrypted_file.gpg'
with open(encrypted_filename, 'rb') as f: # outputを指定せず、on_dataコールバックで処理 decrypt_status = gpg.decrypt_file(f, passphrase='your_secret_passphrase')
if not decrypt_status.ok: print(f"\nDecryption failed: {decrypt_status.status}", file=sys.stderr)
# on_data をリセット
gpg.on_data = None
# 例2: データを別スレッドで処理するためにキューに送る
class ChunkForwarder: def __init__(self, q): self.queue = q def __call__(self, chunk): self.queue.put(chunk) return False # Falseを返すとライブラリはバッファリングしない
data_queue = queue.Queue()
gpg.on_data = ChunkForwarder(data_queue)
def process_chunks(q): print("Worker thread started.") while True: chunk = q.get() if chunk is None: # 終了シグナル q.task_done() break # ここでチャンクを処理 (例: ファイルに書き込む、DBに保存するなど) print(f"Worker received chunk of size {len(chunk)}") # process_chunk(chunk) q.task_done() print("Worker thread finished.")
worker_thread = threading.Thread(target=process_chunks, args=(data_queue,))
worker_thread.start()
# 復号処理を開始 (メインスレッド)
print("Main thread starting decryption...")
with open(encrypted_filename, 'rb') as f: decrypt_status = gpg.decrypt_file(f, passphrase='your_secret_passphrase')
print(f"Main thread decryption status: ok={decrypt_status.ok}, status='{decrypt_status.status}'")
# 処理終了をワーカーに通知
data_queue.put(None)
# ワーカーの終了を待つ
worker_thread.join()
print("Main thread finished.")

plain_text = "これはパスフレーズだけで暗号化されたメッセージです。"
password = "very_strong_password"
# 対称暗号で暗号化 (デフォルトは CAST5)
encrypted_data_sym = gpg.encrypt( plain_text, recipients=None, # 受信者は指定しない symmetric=True, passphrase=password
)
if encrypted_data_sym.ok: encrypted_string_sym = str(encrypted_data_sym) print("Symmetric encryption successful (CAST5):") print(encrypted_string_sym)
else: print(f"Symmetric encryption failed: {encrypted_data_sym.status}")
# AES256アルゴリズムを指定して対称暗号化
encrypted_data_aes = gpg.encrypt( plain_text, recipients=None, symmetric='AES256', # アルゴリズム名を指定 passphrase=password
)
if encrypted_data_aes.ok: encrypted_string_aes = str(encrypted_data_aes) print("\nSymmetric encryption successful (AES256):") print(encrypted_string_aes) # 対称暗号化されたデータを復号 decrypted_data_aes = gpg.decrypt(encrypted_string_aes, passphrase=password) if decrypted_data_aes.ok: print("\nSymmetric decryption successful (AES256):") print(f"Decrypted text: {decrypted_data_aes.data.decode('utf-8')}") else: print(f"\nSymmetric decryption failed: {decrypted_data_aes.status}")
else: print(f"\nSymmetric encryption (AES256) failed: {encrypted_data_aes.status}")

keyserver = 'keys.openpgp.org' # 使用する鍵サーバー
# 鍵サーバーから公開鍵を検索 (メールアドレスなどで)
search_results = gpg.search_keys('user@example.com', keyserver=keyserver)
if search_results: print(f"Found keys on {keyserver}:") for key in search_results: print(f" Key ID: {key['keyid']}, Fingerprint: {key.get('fingerprint')}, Uids: {key['uids']}")
else: print(f"No keys found for 'user@example.com' on {keyserver}")
# 鍵サーバーから公開鍵を受信 (キーIDで指定)
if search_results: keyid_to_receive = search_results[0]['keyid'] # 最初の結果のキーIDを使用 receive_result = gpg.recv_keys(keyserver, keyid_to_receive) if receive_result: print(f"\nReceived key {keyid_to_receive} from {keyserver}.") print(f"Imported count: {receive_result.count}") print(f"Fingerprints: {receive_result.fingerprints}") else: print(f"\nFailed to receive key {keyid_to_receive} from {keyserver}. Status: {getattr(receive_result, 'status', 'Unknown')}")
# 自分の公開鍵を鍵サーバーに送信 (キーIDで指定)
my_keyid = 'YOUR_PUBLIC_KEYID'
try: send_result = gpg.send_keys(keyserver, my_keyid) if send_result: print(f"\nSent key {my_keyid} to {keyserver}. Status: {send_result.status}") else: print(f"\nFailed to send key {my_keyid} to {keyserver}. Status: {getattr(send_result, 'status', 'Unknown')}")
except Exception as e: print(f"\nError sending key {my_keyid}: {e}")

try: # GPG操作を実行 result = gpg.decrypt(encrypted_data, passphrase=password) if result.ok: print("Successfully decrypted.") # ... 成功時の処理 ... else: print(f"Decryption failed. Status: {result.status}") print(f"Stderr: {result.stderr}") # ... 失敗時の処理 (パスフレーズ間違いなど) ...
except gnupg.GPGError as e: print(f"GPGError occurred: {e}") # ... GPGプロセスとの通信エラーなどの処理 ...
except FileNotFoundError: print("Input file not found.") # ... ファイル関連のエラー処理 ...
except Exception as e: print(f"An unexpected error occurred: {e}") # ... その他の予期せぬエラー処理 ...