Python을 사용한 암호화-빠른 가이드
암호화는 코딩 된 메시지를 통해 두 사용자 간의 커뮤니케이션 기술입니다. 암호화 기술은 한 당사자에서 다른 당사자로 전송되는 기밀 메시지에 보안을 제공한다는 기본 동기로 등장했습니다.
암호화는 정보 보안에서 인정되는 프라이버시와 비밀을 도입하기 위해 메시지를 숨기는 기술과 과학으로 정의됩니다.
암호화 용어
암호화에서 자주 사용되는 용어가 여기에 설명되어 있습니다.
일반 텍스트
일반 텍스트 메시지는 모든 사용자가 읽을 수 있고 이해할 수있는 텍스트입니다. 일반 텍스트는 암호화를 거치는 메시지입니다.
암호 텍스트
암호화 텍스트는 일반 텍스트에 암호화를 적용한 후 얻은 메시지입니다.
암호화
일반 텍스트를 암호 텍스트로 변환하는 프로세스를 암호화라고합니다. 인코딩이라고도합니다.
복호화
암호 텍스트를 일반 텍스트로 변환하는 프로세스를 암호 해독이라고합니다. 디코딩이라고도합니다.
아래에 주어진 다이어그램은 암호화의 전체 과정을 보여줍니다-
현대 암호화의 특성
현대 암호화의 기본 특성은 다음과 같습니다.
비트 시퀀스에서 작동합니다.
정보 보안을 위해 수학적 알고리즘을 사용합니다.
프라이버시를 확보하려면 보안 통신 채널에 관심이있는 당사자가 필요합니다.
다중 암호화라고도하는 이중 강도 암호화는 이미 암호화 된 텍스트를 동일하거나 다른 알고리즘 / 패턴으로 한 번 이상 암호화하는 프로세스입니다.
이중 강도 암호화의 다른 이름에는 계단식 암호화 또는 계단식 암호화가 포함됩니다.
이중 강도 암호화 수준
이중 강도 암호화에는 아래에서 설명하는 다양한 수준의 암호화가 포함됩니다.
첫 번째 암호화 계층
암호 텍스트는 해시 알고리즘 및 대칭 키를 사용하여 읽을 수있는 원본 메시지에서 생성됩니다. 나중에 대칭 키는 비대칭 키의 도움으로 암호화됩니다. 이 패턴에 대한 가장 좋은 예시는 암호 텍스트의 해시 다이제스트를 캡슐로 결합하는 것입니다. 수신자는 다이제스트를 먼저 계산하고 나중에 텍스트가 변경되지 않았는지 확인하기 위해 텍스트를 해독합니다.
두 번째 암호화 계층
두 번째 암호화 계층은 알고리즘이 같거나 다른 암호화 텍스트에 하나 이상의 계층을 추가하는 프로세스입니다. 일반적으로 32 비트 문자의 긴 대칭 암호가 동일하게 사용됩니다.
세 번째 암호화 계층
이 과정에서 암호화 된 캡슐은 SSL / TLS 연결을 통해 통신 파트너로 전송됩니다.
다음 다이어그램은 이중 암호화 프로세스를 그림으로 보여줍니다.
하이브리드 암호화
하이브리드 암호화는 각 암호의 이점을 포함하여 서로 다른 유형의 여러 암호를 함께 사용하는 프로세스입니다. 일반적으로 대칭 암호에 대한 임의의 비밀 키를 생성 한 다음 비대칭 키 암호화를 통해이 키를 암호화하기 위해 따르는 한 가지 일반적인 접근 방식이 있습니다.
이 패턴으로 인해 원본 메시지 자체는 대칭 암호와 비밀 키를 사용하여 암호화됩니다. 메시지를 수신 한 수신자는 먼저 자신의 개인 키를 사용하여 비밀 키를 사용하여 메시지를 해독 한 다음 지정된 키를 사용하여 메시지를 해독합니다.
Python은 고급, 해석, 대화 형 및 객체 지향적 인 오픈 소스 스크립팅 언어입니다. 읽기 쉽게 설계되었습니다. Python 언어의 구문은 이해하기 쉽고 영어 키워드를 자주 사용합니다.
Python 언어의 특징
Python은 다음과 같은 주요 기능을 제공합니다.
해석 됨
Python은 인터프리터를 사용하여 런타임에 처리됩니다. 실행하기 전에 프로그램을 컴파일 할 필요가 없습니다. PERL 및 PHP와 유사합니다.
객체 지향
파이썬은 객체 지향 스타일과 디자인 패턴을 따릅니다. 여기에는 캡슐화 및 다형성과 같은 다양한 기능이있는 클래스 정의가 포함됩니다.
파이썬 언어의 요점
Python 프로그래밍 언어의 핵심은 다음과 같습니다.
여기에는 기능적이고 구조화 된 프로그래밍과 방법은 물론 객체 지향 프로그래밍 방법이 포함됩니다.
스크립팅 언어 또는 프로그래밍 언어로 사용할 수 있습니다.
자동 가비지 수집이 포함됩니다.
높은 수준의 동적 데이터 유형을 포함하고 다양한 동적 유형 검사를 지원합니다.
Python에는 C, C ++ 및 Java와 같은 언어와의 통합 기능이 포함되어 있습니다.
Python 언어의 다운로드 링크는 다음과 같습니다. www.python.org/downloads Windows, MacOS 및 Linux 배포판과 같은 다양한 운영 체제 용 패키지가 포함되어 있습니다.
파이썬 문자열
문자열의 기본 선언은 다음과 같습니다.
str = 'Hello World!'파이썬 목록
파이썬 목록은 쉼표로 구분하고 대괄호 ([])로 묶은 복합 데이터 유형으로 선언 할 수 있습니다.
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']Python 튜플
튜플은 쉼표로 구분 된 값의 수로 구성된 Python의 동적 데이터 유형입니다. 튜플은 괄호로 묶습니다.
tinytuple = (123, 'john')파이썬 사전
Python 사전은 해시 테이블 유형입니다. 사전 키는 일반적으로 숫자 또는 문자열 인 거의 모든 데이터 유형의 Python 일 수 있습니다.
tinydict = {'name': 'omkar','code':6734, 'dept': 'sales'}암호화 패키지
Python에는 암호화 레시피와 기본 형식을 제공하는 암호화라는 패키지가 포함되어 있습니다. Python 2.7, Python 3.4+ 및 PyPy 5.3+를 지원합니다. 암호화 패키지의 기본 설치는 다음 명령을 통해 수행됩니다.
pip install cryptography다음과 같은 일반적인 암호화 알고리즘에 대한 높은 수준의 레시피와 낮은 수준의 인터페이스를 모두 갖춘 다양한 패키지가 있습니다. symmetric ciphers, message digests 과 key derivation functions.
이 튜토리얼 전체에서 암호화 알고리즘 구현을 위해 다양한 Python 패키지를 사용할 것입니다.
이전 장에서는 로컬 컴퓨터에 Python을 설치하는 방법에 대해 간략히 설명했습니다. 이 장에서는 역 암호 및 그 코딩에 대해 자세히 알아 봅니다.
역 암호 알고리즘
역 암호 알고리즘은 다음과 같은 기능을 보유하고 있습니다.
Reverse Cipher는 일반 텍스트 문자열을 반전하여 암호 텍스트로 변환하는 패턴을 사용합니다.
암호화 및 복호화 과정은 동일합니다.
암호 텍스트를 해독하려면 사용자는 암호 텍스트를 반전하여 일반 텍스트를 가져 오기만하면됩니다.
약점
역 암호의 주요 단점은 매우 약하다는 것입니다. 해커는 원본 메시지를 얻기 위해 암호 텍스트를 쉽게 해독 할 수 있습니다. 따라서 역 암호는 보안 통신 채널을 유지하기위한 좋은 옵션으로 간주되지 않습니다.
예
예를 들면 다음과 같습니다. This is program to explain reverse cipher역 암호 알고리즘으로 구현됩니다. 다음 Python 코드는 알고리즘을 사용하여 출력을 얻습니다.
message = 'This is program to explain reverse cipher.'
translated = '' #cipher text is stored in this variable
i = len(message) - 1
while i >= 0:
translated = translated + message[i]
i = i - 1
print(“The cipher text is : “, translated)산출
다음 이미지와 같이 반전 된 텍스트를 볼 수 있습니다.
설명
일반 텍스트는 변수 메시지에 저장되고 번역 된 변수는 생성 된 암호 텍스트를 저장하는 데 사용됩니다.
일반 텍스트의 길이는 다음을 사용하여 계산됩니다. for 루프 및 도움으로 index number. 문자는 암호 텍스트 변수에 저장됩니다.translated 마지막 줄에 인쇄됩니다.
지난 장에서 우리는 역 암호를 다루었습니다. 이 장에서는 Caesar 암호에 대해 자세히 설명합니다.
Caesar Cipher의 알고리즘
Caesar 암호 알고리즘은 다음과 같은 특징을 가지고 있습니다.
Caesar Cipher Technique는 간단하고 쉬운 암호화 기법입니다.
단순한 유형의 대체 암호입니다.
일반 텍스트의 각 문자는 알파벳 아래로 고정 된 위치 수를 가진 문자로 대체됩니다.
다음 다이어그램은 Caesar 암호 알고리즘 구현의 작동을 설명합니다.
Caesar 암호 알고리즘의 프로그램 구현은 다음과 같습니다.
def encrypt(text,s):
result = ""
# transverse the plain text
for i in range(len(text)):
char = text[i]
# Encrypt uppercase characters in plain text
if (char.isupper()):
result += chr((ord(char) + s-65) % 26 + 65)
# Encrypt lowercase characters in plain text
else:
result += chr((ord(char) + s - 97) % 26 + 97)
return result
#check the above function
text = "CEASER CIPHER DEMO"
s = 4
print "Plain Text : " + text
print "Shift pattern : " + str(s)
print "Cipher: " + encrypt(text,s)산출
다음 이미지와 같이 출력 인 Caesar 암호를 볼 수 있습니다.
설명
일반 텍스트 문자는 한 번에 하나씩 순회됩니다.
주어진 일반 텍스트의 각 문자에 대해 텍스트의 암호화 및 복호화 절차에 따라 규칙에 따라 주어진 문자를 변환합니다.
단계를 수행 한 후 암호 텍스트라고하는 새 문자열이 생성됩니다.
Caesar Cipher 알고리즘 해킹
암호문은 다양한 가능성으로 해킹 될 수 있습니다. 그러한 가능성 중 하나는Brute Force Technique,가능한 모든 암호 해독 키를 시도해야합니다. 이 기술은 많은 노력이 필요하지 않으며 해커에게는 비교적 간단합니다.
Caesar 암호 알고리즘을 해킹하기위한 프로그램 구현은 다음과 같습니다.
message = 'GIEWIVrGMTLIVrHIQS' #encrypted message
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for key in range(len(LETTERS)):
translated = ''
for symbol in message:
if symbol in LETTERS:
num = LETTERS.find(symbol)
num = num - key
if num < 0:
num = num + len(LETTERS)
translated = translated + LETTERS[num]
else:
translated = translated + symbol
print('Hacking key #%s: %s' % (key, translated))이전 예에서 암호화 된 암호 텍스트를 고려하십시오. 그런 다음 키로 가능한 해킹 방법과 무차별 대입 공격 기법을 사용한 출력은 다음과 같습니다.
지금까지 역 암호 및 Caesar 암호 알고리즘에 대해 배웠습니다. 이제 ROT13 알고리즘과 그 구현에 대해 논의하겠습니다.
ROT13 알고리즘 설명
ROT13 암호는 축약 된 형식을 나타냅니다. Rotate by 13 places. 시프트가 항상 13 인 Caesar Cipher의 특별한 경우입니다. 모든 문자는 메시지를 암호화하거나 해독하기 위해 13 자리 씩 이동합니다.
예
다음 다이어그램은 ROT13 알고리즘 프로세스를 그림으로 설명합니다.
프로그램 코드
ROT13 알고리즘의 프로그램 구현은 다음과 같습니다.
from string import maketrans
rot13trans = maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm')
# Function to translate plain text
def rot13(text):
return text.translate(rot13trans)
def main():
txt = "ROT13 Algorithm"
print rot13(txt)
if __name__ == "__main__":
main()다음 이미지와 같이 ROT13 출력을 볼 수 있습니다.
약점
ROT13 알고리즘은 13 교대를 사용합니다. 따라서 암호문을 해독하기 위해 역방향으로 문자를 이동하는 것은 매우 쉽습니다.
ROT13 알고리즘 분석
ROT13 암호 알고리즘은 Caesar Cipher의 특별한 경우로 간주됩니다. 그것은 매우 안전한 알고리즘이 아니며 주파수 분석을 통해 또는 가능한 25 개의 키를 시도하여 쉽게 깨질 수있는 반면 ROT13은 13 개 위치를 이동하여 깨뜨릴 수 있습니다. 따라서 실제 사용은 포함되지 않습니다.
Transposition Cipher는 일반 텍스트의 알파벳 순서가 다시 정렬되어 암호 텍스트를 형성하는 암호화 알고리즘입니다. 이 과정에서 실제 일반 텍스트 알파벳은 포함되지 않습니다.
예
전치 암호의 간단한 예는 다음과 같습니다. columnar transposition cipher여기서 일반 텍스트의 각 문자는 지정된 알파벳 너비로 가로로 작성됩니다. 암호는 세로로 작성되어 완전히 다른 암호 텍스트를 만듭니다.
일반 텍스트 고려 hello world, 그리고 아래와 같이 간단한 열 전치 기법을 적용 해 보겠습니다.
일반 텍스트 문자는 가로로 배치되고 암호 텍스트는 다음과 같은 세로 형식으로 생성됩니다. : holewdlo lr. 이제 수신자는 동일한 테이블을 사용하여 암호 텍스트를 일반 텍스트로 해독해야합니다.
암호
다음 프로그램 코드는 열 전치 기법의 기본 구현을 보여줍니다-
def split_len(seq, length):
return [seq[i:i + length] for i in range(0, len(seq), length)]
def encode(key, plaintext):
order = {
int(val): num for num, val in enumerate(key)
}
ciphertext = ''
for index in sorted(order.keys()):
for part in split_len(plaintext, len(key)):
try:ciphertext += part[order[index]]
except IndexError:
continue
return ciphertext
print(encode('3214', 'HELLO'))설명
기능 사용 split_len(), 일반 텍스트 문자를 분할 할 수 있으며 열 또는 행 형식으로 배치 할 수 있습니다.
encode 메서드는 열 수를 지정하는 키로 암호 텍스트를 생성하고 각 열을 통해 문자를 읽어 암호 텍스트를 인쇄합니다.
산출
열 전치 기법의 기본 구현을위한 프로그램 코드는 다음과 같은 출력을 제공합니다.
Note− Cryptanalysts는 전치 기법을 수행 할 때 암호화 보안이 크게 향상되었음을 관찰했습니다. 그들은 또한 동일한 전치 암호를 사용하여 암호 텍스트를 다시 암호화하면 보안이 향상된다는 점에 주목했습니다.
이전 장에서 우리는 Transposition Cipher에 대해 배웠습니다. 이 장에서는 암호화에 대해 설명하겠습니다.
파이퍼 클립
주요 용도 pyperclipPython 프로그래밍 언어의 플러그인은 텍스트를 클립 보드에 복사하여 붙여 넣기위한 크로스 플랫폼 모듈을 수행하는 것입니다. 파이썬을 설치할 수 있습니다pyperclip 표시된 명령을 사용하여 모듈
pip install pyperclip요구 사항이 시스템에 이미 존재하는 경우 다음 출력을 볼 수 있습니다.
암호
pyperclip이 메인 모듈 인 전치 암호를 암호화하는 파이썬 코드는 다음과 같습니다.
import pyperclip
def main():
myMessage = 'Transposition Cipher'
myKey = 10
ciphertext = encryptMessage(myKey, myMessage)
print("Cipher Text is")
print(ciphertext + '|')
pyperclip.copy(ciphertext)
def encryptMessage(key, message):
ciphertext = [''] * key
for col in range(key):
position = col
while position < len(message):
ciphertext[col] += message[position]
position += key
return ''.join(ciphertext) #Cipher text
if __name__ == '__main__':
main()산출
전치 암호를 암호화하기위한 프로그램 코드입니다. pyperclip 메인 모듈은 다음과 같은 출력을 제공합니다.
설명
함수 main() 전화 encryptMessage() 다음을 사용하여 문자를 분할하는 절차를 포함합니다. len 함수 및 열 형식으로 반복합니다.
주 함수는 마지막에 초기화되어 적절한 출력을 얻습니다.
이 장에서는 전치 암호를 해독하는 절차를 배웁니다.
암호
전치 암호 해독에 대한 더 나은 이해를 위해 다음 코드를 관찰하십시오. 메시지의 암호 텍스트Transposition Cipher 키로 6 다음과 같이 가져옵니다. Toners raiCntisippoh.
import math, pyperclip
def main():
myMessage= 'Toners raiCntisippoh'
myKey = 6
plaintext = decryptMessage(myKey, myMessage)
print("The plain text is")
print('Transposition Cipher')
def decryptMessage(key, message):
numOfColumns = math.ceil(len(message) / key)
numOfRows = key
numOfShadedBoxes = (numOfColumns * numOfRows) - len(message)
plaintext = float('') * numOfColumns
col = 0
row = 0
for symbol in message:
plaintext[col] += symbol
col += 1
if (col == numOfColumns) or (col == numOfColumns - 1 and row >= numOfRows - numOfShadedBoxes):
col = 0 row += 1 return ''.join(plaintext)
if __name__ == '__main__':
main()설명
암호 텍스트와 언급 된 키는 문자를 열 형식으로 배치하고 가로 방향으로 읽어 역방향 기술로 암호 텍스트를 해독하거나 해독하기위한 입력 매개 변수로 사용되는 두 값입니다.
열 형식으로 문자를 배치하고 나중에 다음 코드를 사용하여 결합하거나 연결할 수 있습니다.
for symbol in message:
plaintext[col] += symbol
col += 1
if (col == numOfColumns) or (col == numOfColumns - 1 and row >= numOfRows - numOfShadedBoxes):
col = 0
row += 1
return ''.join(plaintext)산출
전치 암호 해독을위한 프로그램 코드는 다음과 같은 출력을 제공합니다.
Python에서는 통신 채널로 전송하기 전에 파일을 암호화하고 해독 할 수 있습니다. 이를 위해서는 플러그인을 사용해야합니다.PyCrypto. 아래 명령을 사용하여이 플러그인을 설치할 수 있습니다.
pip install pycrypto
암호
암호 보호기로 파일을 암호화하는 프로그램 코드는 다음과 같습니다.
# =================Other Configuration================
# Usages :
usage = "usage: %prog [options] "
# Version
Version="%prog 0.0.1"
# ====================================================
# Import Modules
import optparse, sys,os
from toolkit import processor as ps
def main():
parser = optparse.OptionParser(usage = usage,version = Version)
parser.add_option(
'-i','--input',type = 'string',dest = 'inputfile',
help = "File Input Path For Encryption", default = None)
parser.add_option(
'-o','--output',type = "string",dest = 'outputfile',
help = "File Output Path For Saving Encrypter Cipher",default = ".")
parser.add_option(
'-p','--password',type = "string",dest = 'password',
help = "Provide Password For Encrypting File",default = None)
parser.add_option(
'-p','--password',type = "string",dest = 'password',
help = "Provide Password For Encrypting File",default = None)
(options, args)= parser.parse_args()
# Input Conditions Checkings
if not options.inputfile or not os.path.isfile(options.inputfile):
print " [Error] Please Specify Input File Path"
exit(0)
if not options.outputfile or not os.path.isdir(options.outputfile):
print " [Error] Please Specify Output Path"
exit(0)
if not options.password:
print " [Error] No Password Input"
exit(0)
inputfile = options.inputfile
outputfile = os.path.join(
options.outputfile,os.path.basename(options.inputfile).split('.')[0]+'.ssb')
password = options.password
base = os.path.basename(inputfile).split('.')[1]
work = "E"
ps.FileCipher(inputfile,outputfile,password,work)
return
if __name__ == '__main__':
main()다음 명령을 사용하여 암호와 함께 암호화 프로세스를 실행할 수 있습니다.
python pyfilecipher-encrypt.py -i file_path_for_encryption -o output_path -p password산출
위에 주어진 코드를 실행하면 다음 출력을 관찰 할 수 있습니다.
설명
암호는 MD5 해시 알고리즘을 사용하여 생성되며 값은 아래 표시된 값을 포함하는 Windows 시스템의 간단한 안전한 백업 파일에 저장됩니다.
이 장에서는 Python을 사용한 암호화에서 파일의 복호화에 대해 설명합니다. 복호화 과정에서는 동일한 절차를 따르지만 출력 경로를 지정하는 대신 입력 경로 또는 암호화 된 필요한 파일에 초점을 맞 춥니 다.
암호
다음은 Python을 사용하여 암호화 파일을 해독하는 샘플 코드입니다.
#!/usr/bin/python
# ---------------- READ ME ---------------------------------------------
# This Script is Created Only For Practise And Educational Purpose Only
# This Script Is Created For http://bitforestinfo.blogspot.in
# This Script is Written By
#
#
##################################################
######## Please Don't Remove Author Name #########
############### Thanks ###########################
##################################################
#
#
# =================Other Configuration================
# Usages :
usage = "usage: %prog [options] "
# Version
Version="%prog 0.0.1"
# ====================================================
# Import Modules
import optparse, sys,os
from toolkit import processor as ps
def main():
parser = optparse.OptionParser(usage = usage,version = Version)
parser.add_option(
'-i','--input',type = 'string',dest = 'inputfile',
help = "File Input Path For Encryption", default = None)
parser.add_option(
'-o','--output',type = "string",dest = 'outputfile',
help = "File Output Path For Saving Encrypter Cipher",default = ".")
parser.add_option(
'-p','--password',type = "string",dest = 'password',
help = "Provide Password For Encrypting File",default = None)
(options, args) = parser.parse_args()
# Input Conditions Checkings
if not options.inputfile or not os.path.isfile(options.inputfile):
print " [Error] Please Specify Input File Path"
exit(0)
if not options.outputfile or not os.path.isdir(options.outputfile):
print " [Error] Please Specify Output Path"
exit(0)
if not options.password:
print " [Error] No
exit(0)
inputfile = options.inputfile
outputfile = options.outputfile
password = options.password
work = "D"
ps.FileCipher(inputfile,outputfile,password,work)
return
if __name__ == '__main__':
main()위의 코드를 실행하기 위해 다음 명령을 사용할 수 있습니다.
python pyfilecipher-decrypt.py -i encrypted_file_path -p password산출
위에 표시된 명령을 실행하면 다음 코드를 관찰 할 수 있습니다.
Note − 출력은 암호화 전과 복호화 후의 해시 값을 지정하여 동일한 파일이 암호화되고 프로세스가 성공했음을 기록합니다.
Base64 인코딩은 바이너리 데이터를 텍스트 형식으로 변환하여 사용자가 안전하게 텍스트를 처리 할 수있는 통신 채널을 통해 전달합니다. Base64는Privacy enhanced Electronic mail (PEM) 주로 이메일 암호화 프로세스에 사용됩니다.
Python에는 BASE64 아래에 주어진 두 가지 주요 기능을 포함합니다-
base64.decode(input, output) − 지정된 입력 값 매개 변수를 디코딩하여 디코딩 된 출력을 객체로 저장합니다.
Base64.encode(input, output) − 지정된 입력 값 매개 변수를 인코딩하고 디코딩 된 출력을 객체로 저장합니다.
인코딩 프로그램
다음 코드를 사용하여 base64 인코딩을 수행 할 수 있습니다.
import base64
encoded_data = base64.b64encode("Encode this text")
print("Encoded text with base 64 is")
print(encoded_data)산출
base64 인코딩 코드는 다음과 같은 출력을 제공합니다.
디코딩 프로그램
다음 코드를 사용하여 base64 디코딩을 수행 할 수 있습니다.
import base64
decoded_data = base64.b64decode("RW5jb2RlIHRoaXMgdGV4dA==")
print("decoded text is ")
print(decoded_data)산출
base64 디코딩 코드는 다음과 같은 출력을 제공합니다.
ASCII와 base64의 차이점
데이터 인코딩을 위해 ASCII 및 base64에서 작업 할 때 다음과 같은 차이점을 관찰 할 수 있습니다.
ASCII로 텍스트를 인코딩 할 때 텍스트 문자열로 시작하여 일련의 바이트로 변환합니다.
Base64로 데이터를 인코딩 할 때 바이트 시퀀스로 시작하여 텍스트 문자열로 변환합니다.
약점
Base64 알고리즘은 일반적으로 데이터베이스에 암호를 저장하는 데 사용됩니다. 가장 큰 단점은 디코딩 된 각 단어를 온라인 도구를 통해 쉽게 인코딩 할 수 있고 침입자가 정보를 쉽게 얻을 수 있다는 것입니다.
이 장에서는 Python 코딩과 함께 XOR 프로세스를 이해하겠습니다.
연산
암호화 및 복호화의 XOR 알고리즘은 일반 텍스트를 ASCII 바이트 형식으로 변환하고 XOR 프로 시저를 사용하여 지정된 바이트로 변환합니다. 사용자에게 다음과 같은 이점을 제공합니다.
- 빠른 계산
- 왼쪽과 오른쪽에 표시된 차이 없음
- 이해하고 분석하기 쉬움
암호
다음 코드를 사용하여 XOR 프로세스를 수행 할 수 있습니다.
def xor_crypt_string(data, key = 'awesomepassword', encode = False, decode = False):
from itertools import izip, cycle
import base64
if decode:
data = base64.decodestring(data)
xored = ''.join(chr(ord(x) ^ ord(y)) for (x,y) in izip(data, cycle(key)))
if encode:
return base64.encodestring(xored).strip()
return xored
secret_data = "XOR procedure"
print("The cipher text is")
print xor_crypt_string(secret_data, encode = True)
print("The plain text fetched")
print xor_crypt_string(xor_crypt_string(secret_data, encode = True), decode = True)산출
XOR 프로세스의 코드는 다음과 같은 출력을 제공합니다.
설명
함수 xor_crypt_string() 인코딩 및 디코딩 모드와 문자열 값을 지정하는 매개 변수를 포함합니다.
기본 기능은 일반 텍스트 / 암호화 텍스트를 암호화하거나 해독하기 위해 XOR 절차 / 연산을 따르는 base64 모듈로 수행됩니다.
Note − XOR 암호화는 데이터를 암호화하는 데 사용되며 무차별 대입 방식, 즉 올바른 암호 텍스트와 일치하는 임의 암호화 키를 생성하여 크래킹하기 어렵습니다.
Caesar 암호 기술을 사용하는 동안 기호를 암호화하고 해독하려면 간단한 기본 더하기 또는 빼기 절차를 사용하여 값을 숫자로 변환해야합니다.
곱셈이 암호 텍스트로 변환하는 데 사용되는 경우 wrap-around상태. 아래와 같이 사용할 문자와 관련 숫자를 고려하십시오.
숫자는 곱셈 절차에 사용되며 관련 키는 7입니다. 이러한 시나리오에서 곱셈 암호를 생성하는 데 사용되는 기본 공식은 다음과 같습니다.
(Alphabet Number * key)mod(total number of alphabets)출력을 통해 가져온 숫자는 위에서 언급 한 표에 매핑되며 해당 문자는 암호화 된 문자로 간주됩니다.
파이썬에서 곱셈 암호의 기본 변조 기능은 다음과 같습니다.
def unshift(key, ch):
offset = ord(ch) - ASC_A
return chr(((key[0] * (offset + key[1])) % WIDTH) + ASC_A)Note− 곱셈 암호의 장점은 8,953,851과 같은 매우 큰 키로 작동 할 수 있다는 것입니다. 컴퓨터가 9 백만 개의 키를 통해 무차별 대입하는 데는 꽤 오랜 시간이 걸립니다.
Affine Cipher는 Multiplicative Cipher와 Caesar Cipher 알고리즘의 조합입니다. 아핀 암호의 기본 구현은 아래 이미지와 같습니다.
이 장에서는 암호화 및 복호화를위한 두 가지 기본 기능을 포함하는 해당 클래스를 생성하여 아핀 암호를 구현합니다.
암호
다음 코드를 사용하여 아핀 암호를 구현할 수 있습니다.
class Affine(object):
DIE = 128
KEY = (7, 3, 55)
def __init__(self):
pass
def encryptChar(self, char):
K1, K2, kI = self.KEY
return chr((K1 * ord(char) + K2) % self.DIE)
def encrypt(self, string):
return "".join(map(self.encryptChar, string))
def decryptChar(self, char):
K1, K2, KI = self.KEY
return chr(KI * (ord(char) - K2) % self.DIE)
def decrypt(self, string):
return "".join(map(self.decryptChar, string))
affine = Affine()
print affine.encrypt('Affine Cipher')
print affine.decrypt('*18?FMT')산출
아핀 암호를 구현할 때 다음 출력을 관찰 할 수 있습니다.
출력은 일반 텍스트 메시지에 대해 암호화 된 메시지를 표시합니다. Affine Cipher 입력으로 전송 된 메시지에 대한 해독 된 메시지 abcdefg.
이 장에서는 단 알파벳 암호와 파이썬을 사용한 해킹에 대해 배웁니다.
단 알파벳 암호
Monoalphabetic 암호는 전체 메시지를 암호화하기 위해 고정 된 대체를 사용합니다. JSON 객체와 함께 Python 사전을 사용하는 단일 알파벳 암호는 다음과 같습니다.
monoalpha_cipher = {
'a': 'm',
'b': 'n',
'c': 'b',
'd': 'v',
'e': 'c',
'f': 'x',
'g': 'z',
'h': 'a',
'i': 's',
'j': 'd',
'k': 'f',
'l': 'g',
'm': 'h',
'n': 'j',
'o': 'k',
'p': 'l',
'q': 'p',
'r': 'o',
's': 'i',
't': 'u',
'u': 'y',
'v': 't',
'w': 'r',
'x': 'e',
'y': 'w',
'z': 'q',
' ': ' ',
}이 사전의 도움으로 JSON 객체의 값으로 연결된 문자가있는 문자를 암호화 할 수 있습니다. 다음 프로그램은 암호화 및 복호화의 모든 기능을 포함하는 클래스 표현으로 단일 알파벳 프로그램을 생성합니다.
from string import letters, digits
from random import shuffle
def random_monoalpha_cipher(pool = None):
if pool is None:
pool = letters + digits
original_pool = list(pool)
shuffled_pool = list(pool)
shuffle(shuffled_pool)
return dict(zip(original_pool, shuffled_pool))
def inverse_monoalpha_cipher(monoalpha_cipher):
inverse_monoalpha = {}
for key, value in monoalpha_cipher.iteritems():
inverse_monoalpha[value] = key
return inverse_monoalpha
def encrypt_with_monoalpha(message, monoalpha_cipher):
encrypted_message = []
for letter in message:
encrypted_message.append(monoalpha_cipher.get(letter, letter))
return ''.join(encrypted_message)
def decrypt_with_monoalpha(encrypted_message, monoalpha_cipher):
return encrypt_with_monoalpha(
encrypted_message,
inverse_monoalpha_cipher(monoalpha_cipher)
)이 파일은 다음에 언급되는 Monoalphabetic 암호의 암호화 및 복호화 프로세스를 구현하기 위해 나중에 호출됩니다.
import monoalphabeticCipher as mc
cipher = mc.random_monoalpha_cipher()
print(cipher)
encrypted = mc.encrypt_with_monoalpha('Hello all you hackers out there!', cipher)
decrypted = mc.decrypt_with_monoalpha('sXGGt SGG Nt0 HSrLXFC t0U UHXFX!', cipher)
print(encrypted)
print(decrypted)산출
위에 주어진 코드를 구현할 때 다음 출력을 관찰 할 수 있습니다.
따라서 암호 텍스트를 실제 일반 텍스트로 크래킹하는 지정된 키 값 쌍을 사용하여 단일 알파벳 암호를 해킹 할 수 있습니다.
단순 대체 암호는 가장 일반적으로 사용되는 암호이며 모든 암호 텍스트 문자에 대해 모든 일반 텍스트 문자를 대체하는 알고리즘을 포함합니다. 이 과정에서 알파벳은 Caesar 암호 알고리즘과 비교하여 뒤죽박죽입니다.
예
단순 대체 암호의 키는 일반적으로 26 자로 구성됩니다. 예제 키는-
plain alphabet : abcdefghijklmnopqrstuvwxyz
cipher alphabet: phqgiumeaylnofdxjkrcvstzwb위의 키를 사용한 암호화의 예는 다음과 같습니다.
plaintext : defend the east wall of the castle
ciphertext: giuifg cei iprc tpnn du cei qprcni다음 코드는 간단한 대체 암호를 구현하는 프로그램을 보여줍니다-
import random, sys
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def main():
message = ''
if len(sys.argv) > 1:
with open(sys.argv[1], 'r') as f:
message = f.read()
else:
message = raw_input("Enter your message: ")
mode = raw_input("E for Encrypt, D for Decrypt: ")
key = ''
while checkKey(key) is False:
key = raw_input("Enter 26 ALPHA key (leave blank for random key): ")
if key == '':
key = getRandomKey()
if checkKey(key) is False:
print('There is an error in the key or symbol set.')
translated = translateMessage(message, key, mode)
print('Using key: %s' % (key))
if len(sys.argv) > 1:
fileOut = 'enc.' + sys.argv[1]
with open(fileOut, 'w') as f:
f.write(translated)
print('Success! File written to: %s' % (fileOut))
else: print('Result: ' + translated)
# Store the key into list, sort it, convert back, compare to alphabet.
def checkKey(key):
keyString = ''.join(sorted(list(key)))
return keyString == LETTERS
def translateMessage(message, key, mode):
translated = ''
charsA = LETTERS
charsB = key
# If decrypt mode is detected, swap A and B
if mode == 'D':
charsA, charsB = charsB, charsA
for symbol in message:
if symbol.upper() in charsA:
symIndex = charsA.find(symbol.upper())
if symbol.isupper():
translated += charsB[symIndex].upper()
else:
translated += charsB[symIndex].lower()
else:
translated += symbol
return translated
def getRandomKey():
randomList = list(LETTERS)
random.shuffle(randomList)
return ''.join(randomList)
if __name__ == '__main__':
main()산출
위에 주어진 코드를 구현할 때 다음 출력을 관찰 할 수 있습니다.
이 장에서는 아래와 같이 임의의 문자열을 생성하는 데 도움이되는 다양한 방법을 사용하여 대체 암호를 테스트하는 데 중점을 둘 것입니다.
import random, string, substitution
def main():
for i in range(1000):
key = substitution.getRandomKey()
message = random_string()
print('Test %s: String: "%s.."' % (i + 1, message[:50]))
print("Key: " + key)
encrypted = substitution.translateMessage(message, key, 'E')
decrypted = substitution.translateMessage(encrypted, key, 'D')
if decrypted != message:
print('ERROR: Decrypted: "%s" Key: %s' % (decrypted, key))
sys.exit()
print('Substutition test passed!')
def random_string(size = 5000, chars = string.ascii_letters + string.digits):
return ''.join(random.choice(chars) for _ in range(size))
if __name__ == '__main__':
main()산출
아래와 같이 임의의 일반 텍스트 메시지를 생성하는 데 도움이되는 무작위로 생성 된 문자열로 출력을 관찰 할 수 있습니다.
테스트가 성공적으로 완료되면 출력 메시지를 볼 수 있습니다. Substitution test passed!.
따라서 체계적인 방식으로 대체 암호를 해킹 할 수 있습니다.
이 장에서는 단순 대체 암호 기법에서 사용되는 논리에 따라 암호화 및 복호화 된 메시지를 표시하는 대체 암호의 간단한 구현에 대해 알아볼 수 있습니다. 이것은 코딩의 대안적인 접근 방식으로 간주 될 수 있습니다.
암호
다음 코드를 사용하여 간단한 대체 암호를 사용하여 복호화를 수행 할 수 있습니다.
import random
chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + \
'abcdefghijklmnopqrstuvwxyz' + \
'0123456789' + \
':.;,?!@#$%&()+=-*/_<> []{}`~^"\'\\'
def generate_key():
"""Generate an key for our cipher"""
shuffled = sorted(chars, key=lambda k: random.random())
return dict(zip(chars, shuffled))
def encrypt(key, plaintext):
"""Encrypt the string and return the ciphertext"""
return ''.join(key[l] for l in plaintext)
def decrypt(key, ciphertext):
"""Decrypt the string and return the plaintext"""
flipped = {v: k for k, v in key.items()}
return ''.join(flipped[l] for l in ciphertext)
def show_result(plaintext):
"""Generate a resulting cipher with elements shown"""
key = generate_key()
encrypted = encrypt(key, plaintext)
decrypted = decrypt(key, encrypted)
print 'Key: %s' % key
print 'Plaintext: %s' % plaintext
print 'Encrypted: %s' % encrypted
print 'Decrypted: %s' % decrypted
show_result('Hello World. This is demo of substitution cipher')산출
위의 코드는 다음과 같이 출력을 제공합니다.
이 장에서는 Python의 다양한 암호화 모듈에 대해 자세히 배웁니다.
암호화 모듈
여기에는 모든 레시피와 기본 요소가 포함되어 있으며 Python 코딩의 높은 수준의 인터페이스를 제공합니다. 다음 명령을 사용하여 암호화 모듈을 설치할 수 있습니다-
pip install cryptography
암호
다음 코드를 사용하여 암호화 모듈을 구현할 수 있습니다.
from cryptography.fernet import Fernet
key = Fernet.generate_key()
cipher_suite = Fernet(key)
cipher_text = cipher_suite.encrypt("This example is used to demonstrate cryptography module")
plain_text = cipher_suite.decrypt(cipher_text)산출
위에 주어진 코드는 다음과 같은 출력을 생성합니다.
여기에 제공된 코드는 암호를 확인하고 해시를 만드는 데 사용됩니다. 또한 인증 목적으로 암호를 확인하는 논리도 포함됩니다.
import uuid
import hashlib
def hash_password(password):
# uuid is used to generate a random number of the specified password
salt = uuid.uuid4().hex
return hashlib.sha256(salt.encode() + password.encode()).hexdigest() + ':' + salt
def check_password(hashed_password, user_password):
password, salt = hashed_password.split(':')
return password == hashlib.sha256(salt.encode() + user_password.encode()).hexdigest()
new_pass = input('Please enter a password: ')
hashed_password = hash_password(new_pass)
print('The string to store in the db is: ' + hashed_password)
old_pass = input('Now please enter the password again to check: ')
if check_password(hashed_password, old_pass):
print('You entered the right password')
else:
print('Passwords do not match')산출
Scenario 1 − 올바른 비밀번호를 입력했다면 다음과 같은 결과를 볼 수 있습니다 −
Scenario 2 − 잘못된 비밀번호를 입력하면 다음과 같은 결과를 볼 수 있습니다 −
설명
Hashlibpackage는 데이터베이스에 암호를 저장하는 데 사용됩니다. 이 프로그램에서salt 해시 함수를 구현하기 전에 암호 문자열에 임의의 시퀀스를 추가하는 데 사용됩니다.
Vignere Cipher에는 암호화 및 복호화에 사용되는 Caesar Cipher 알고리즘이 포함되어 있습니다. Vignere Cipher는 Caesar Cipher 알고리즘과 유사하게 작동하며 단 하나의 주요 차이점이 있습니다. Caesar Cipher는 한 문자 이동을위한 알고리즘을 포함하는 반면 Vignere Cipher는 여러 알파벳 이동이있는 키를 포함합니다.
수학 방정식
암호화의 경우 수학 방정식은 다음과 같습니다.
$$ E_ {k} \ 왼쪽 (M {_ {i {}}} \ 오른쪽) = \ 왼쪽 (M_ {i} + K_ {i} \ 오른쪽) \; \; \; 모드 \; \; 26 $$
복호화의 경우 수학 방정식은 다음과 같습니다.
$$ D_ {k} \ 왼쪽 (C {_ {i {}}} \ 오른쪽) = \ 왼쪽 (C_ {i} -K_ {i} \ 오른쪽) \; \; \; 모드 \; \; 26 $$
Vignere 암호는 둘 이상의 대체 세트를 사용하므로 polyalphabetic cipher. Vignere Cipher는 숫자 키 표현 대신 문자 키를 사용합니다. 문자 A는 키 0에, 문자 B는 키 1에 사용됩니다. 암호화 처리 전후의 문자 수는 다음과 같습니다.
Vignere 키 길이를 기반으로 가능한 키 수의 가능한 조합은 다음과 같이 주어지며, 이는 Vignere Cipher Algorithm이 얼마나 안전한지 결과를 제공합니다.
Vignere Tableau
Vignere 암호에 사용되는 표는 다음과 같습니다.
이 장에서는 Vignere 암호를 구현하는 방법을 이해하겠습니다. 텍스트 고려This is basic implementation of Vignere Cipher 인코딩되고 사용되는 키는 PIZZA.
암호
다음 코드를 사용하여 Python에서 Vignere 암호를 구현할 수 있습니다.
import pyperclip
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def main():
myMessage = "This is basic implementation of Vignere Cipher"
myKey = 'PIZZA'
myMode = 'encrypt'
if myMode == 'encrypt':
translated = encryptMessage(myKey, myMessage)
elif myMode == 'decrypt':
translated = decryptMessage(myKey, myMessage)
print('%sed message:' % (myMode.title()))
print(translated)
print()
def encryptMessage(key, message):
return translateMessage(key, message, 'encrypt')
def decryptMessage(key, message):
return translateMessage(key, message, 'decrypt')
def translateMessage(key, message, mode):
translated = [] # stores the encrypted/decrypted message string
keyIndex = 0
key = key.upper()
for symbol in message:
num = LETTERS.find(symbol.upper())
if num != -1:
if mode == 'encrypt':
num += LETTERS.find(key[keyIndex])
elif mode == 'decrypt':
num -= LETTERS.find(key[keyIndex])
num %= len(LETTERS)
if symbol.isupper():
translated.append(LETTERS[num])
elif symbol.islower():
translated.append(LETTERS[num].lower())
keyIndex += 1
if keyIndex == len(key):
keyIndex = 0
else:
translated.append(symbol)
return ''.join(translated)
if __name__ == '__main__':
main()산출
위에 주어진 코드를 구현할 때 다음 출력을 관찰 할 수 있습니다.
Vignere 암호를 해킹하는 가능한 조합은 거의 불가능합니다. 따라서 보안 암호화 모드로 간주됩니다.
일회용 패드 암호는 다음과 같은 기능을 포함하는 Vignere 암호 유형입니다.
깨지지 않는 암호입니다.
키는 암호화 된 메시지 길이와 정확히 동일합니다.
키는 임의의 기호로 구성됩니다.
이름에서 알 수 있듯이 키는 한 번만 사용되며 다른 메시지를 암호화하는 데 다시 사용되지 않습니다.
이로 인해 암호화 된 메시지는 암호 분석가의 공격에 취약합니다. 일회성 패드 암호에 사용되는 키는 다음과 같습니다.pad, 종이 패드에 인쇄되어 있습니다.
왜 깨지지 않는가?
키는 다음과 같은 기능으로 인해 깨지지 않습니다.
열쇠는 주어진 메시지만큼 길다.
키는 실제로 무작위이며 특별히 자동 생성됩니다.
모듈로 10/26/2로 계산 된 키 및 일반 텍스트.
각 키는 한 번만 사용하고 발신자와 수신자 모두 폐기해야합니다.
키 사본은 두 개가 있어야합니다. 하나는 발신자 용이고 다른 하나는 수신자 용입니다.
암호화
편지를 암호화하려면 사용자가 일반 텍스트 아래에 키를 작성해야합니다. 일반 텍스트 문자는 상단에, 키 문자는 왼쪽에 배치됩니다. 두 글자 사이의 단면은 일반 텍스트입니다. 아래 예에서 설명합니다.
복호화
문자를 해독하기 위해 사용자는 왼쪽의 키 문자를 가져와 해당 행에서 암호 텍스트 문자를 찾습니다. 일반 텍스트 문자는 사용자가 암호 텍스트 문자를 찾을 수있는 열 맨 위에 배치됩니다.
Python에는 다음을위한 해키 구현 모듈이 포함되어 있습니다. one-time-pad암호 구현. 패키지 이름은 일회성 패드 암호 알고리즘과 유사한 암호화 메커니즘을 사용하는 명령 줄 암호화 도구를 포함하는 One-Time-Pad라고합니다.
설치
다음 명령을 사용하여이 모듈을 설치할 수 있습니다.
pip install onetimepad명령 줄에서 사용하려면 다음 명령을 실행하십시오.
onetimepad
암호
다음 코드는 일회용 패드 암호를 생성하는 데 도움이됩니다.
import onetimepad
cipher = onetimepad.encrypt('One Time Cipher', 'random')
print("Cipher text is ")
print(cipher)
print("Plain text is ")
msg = onetimepad.decrypt(cipher, 'random')
print(msg)산출
위에 주어진 코드를 실행하면 다음 출력을 볼 수 있습니다.
Note − 암호화 된 메시지는 키의 길이가 메시지의 길이 (일반 텍스트)보다 짧으면 크래킹하기 매우 쉽습니다.
어쨌든 키가 반드시 무작위가 아니므로 일회용 패드 암호를 가치있는 도구로 만듭니다.
이 장에서는 대칭 및 비대칭 암호화에 대해 자세히 설명하겠습니다.
대칭 암호화
이 유형에서 암호화 및 암호 해독 프로세스는 동일한 키를 사용합니다. 그것은 또한secret key cryptography. 대칭 암호화의 주요 기능은 다음과 같습니다.
- 더 간단하고 빠릅니다.
- 두 당사자는 안전한 방식으로 키를 교환합니다.
약점
대칭 암호화의 가장 큰 단점은 키가 침입자에게 유출되면 메시지가 쉽게 변경 될 수 있으며 이는 위험 요소로 간주된다는 것입니다.
데이터 암호화 표준 (DES)
가장 널리 사용되는 대칭 키 알고리즘은 DES (데이터 암호화 표준)이며 Python에는 DES 알고리즘의 논리를 포함하는 패키지가 포함되어 있습니다.
설치
DES 패키지 설치 명령 pyDES 파이썬에서-
pip install pyDES
DES 알고리즘의 간단한 프로그램 구현은 다음과 같습니다.
import pyDes
data = "DES Algorithm Implementation"
k = pyDes.des("DESCRYPT", pyDes.CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=pyDes.PAD_PKCS5)
d = k.encrypt(data)
print "Encrypted: %r" % d
print "Decrypted: %r" % k.decrypt(d)
assert k.decrypt(d) == data변수를 요구합니다. padmode DES 알고리즘 구현에 따라 모든 패키지를 가져오고 지정된 방식으로 암호화 및 암호 해독을 따릅니다.
산출
위에 주어진 코드의 결과로 다음 출력을 볼 수 있습니다.
비대칭 암호화
그것은 또한 public key cryptography.대칭 암호화의 반대 방식으로 작동합니다. 이것은 두 개의 키가 필요함을 의미합니다. 하나는 암호화 용이고 다른 하나는 복호화 용입니다. 공개 키는 암호화에 사용되며 개인 키는 암호 해독에 사용됩니다.
약점
- 키 길이로 인해 암호화 속도가 느려집니다.
- 키 관리가 중요합니다.
Python의 다음 프로그램 코드는 RSA 알고리즘과 그 구현을 사용하는 비대칭 암호화의 작동을 보여줍니다.
from Crypto import Random
from Crypto.PublicKey import RSA
import base64
def generate_keys():
# key length must be a multiple of 256 and >= 1024
modulus_length = 256*4
privatekey = RSA.generate(modulus_length, Random.new().read)
publickey = privatekey.publickey()
return privatekey, publickey
def encrypt_message(a_message , publickey):
encrypted_msg = publickey.encrypt(a_message, 32)[0]
encoded_encrypted_msg = base64.b64encode(encrypted_msg)
return encoded_encrypted_msg
def decrypt_message(encoded_encrypted_msg, privatekey):
decoded_encrypted_msg = base64.b64decode(encoded_encrypted_msg)
decoded_decrypted_msg = privatekey.decrypt(decoded_encrypted_msg)
return decoded_decrypted_msg
a_message = "This is the illustration of RSA algorithm of asymmetric cryptography"
privatekey , publickey = generate_keys()
encrypted_msg = encrypt_message(a_message , publickey)
decrypted_msg = decrypt_message(encrypted_msg, privatekey)
print "%s - (%d)" % (privatekey.exportKey() , len(privatekey.exportKey()))
print "%s - (%d)" % (publickey.exportKey() , len(publickey.exportKey()))
print " Original content: %s - (%d)" % (a_message, len(a_message))
print "Encrypted message: %s - (%d)" % (encrypted_msg, len(encrypted_msg))
print "Decrypted message: %s - (%d)" % (decrypted_msg, len(decrypted_msg))산출
위에 주어진 코드를 실행하면 다음 출력을 찾을 수 있습니다.
RSA 알고리즘은 공개 키 암호화 기술이며 가장 안전한 암호화 방법으로 간주됩니다. Rivest, Shamir 및 Adleman에 의해 1978 년에 발명되었으므로 이름이RSA 연산.
연산
RSA 알고리즘에는 다음과 같은 기능이 있습니다.
RSA 알고리즘은 소수를 포함한 정수에 대한 유한 필드에서 널리 사용되는 지수입니다.
이 방법에서 사용하는 정수는 충분히 커서 해결하기 어렵습니다.
이 알고리즘에는 개인 키와 공개 키의 두 가지 키 세트가 있습니다.
RSA 알고리즘을 작업하려면 다음 단계를 거쳐야합니다.
1 단계 : RSA 모듈러스 생성
초기 절차는 두 개의 소수, 즉 p와 q를 선택한 다음 다음과 같이 곱 N을 계산하는 것으로 시작합니다.
N=p*q여기서 N을 지정된 큰 수라고합니다.
2 단계 : 파생 번호 (e)
숫자 e를 1보다 크고 (p-1) 및 (q-1)보다 작아야하는 파생 된 숫자로 간주합니다. 1 차 조건은 1을 제외하고 (p-1)과 (q-1)의 공통 인자가 없어야한다는 것입니다.
3 단계 : 공개 키
지정된 숫자 쌍 n 과 e RSA 공개 키를 형성하고 공개됩니다.
4 단계 : 개인 키
개인 키 d숫자 p, q 및 e에서 계산됩니다. 숫자 사이의 수학적 관계는 다음과 같습니다.
ed = 1 mod (p-1) (q-1)위 공식은 p와 q를 입력 매개 변수로 사용하는 확장 유클리드 알고리즘의 기본 공식입니다.
암호화 공식
공개 키가있는 사람에게 일반 텍스트 메시지를 보내는 보낸 사람을 생각해보십시오. (n,e). 주어진 시나리오에서 일반 텍스트 메시지를 암호화하려면 다음 구문을 사용하십시오.
C = Pe mod n복호화 공식
복호화 프로세스는 매우 간단하며 체계적인 접근 방식의 계산 분석을 포함합니다. 수신자 고려 C 개인 키가 있습니다 d, 결과 계수는 다음과 같이 계산됩니다.
Plaintext = Cd mod n이 장에서는 Python을 사용하여 RSA 알고리즘을 단계별로 구현하는 데 중점을 둘 것입니다.
RSA 키 생성
다음 단계는 RSA 키 생성에 관련됩니다-
즉, 두 개의 큰 소수 만들기 p 과 q. 이 번호의 제품은n, 어디 n= p*q
상대적으로 소수 인 난수 생성 (p-1) 과 (q-1). 번호를 e.
e의 모듈 식 역을 계산합니다. 계산 된 역은 다음과 같이 호출됩니다.d.
RSA 키 생성을위한 알고리즘
Python을 사용하여 RSA 키를 생성하려면 두 가지 기본 알고리즘이 필요합니다. Cryptomath module 과 Rabin Miller module.
Cryptomath 모듈
RSA 알고리즘의 모든 기본 구현을 따르는 cryptomath 모듈의 소스 코드는 다음과 같습니다.
def gcd(a, b):
while a != 0:
a, b = b % a, a
return b
def findModInverse(a, m):
if gcd(a, m) != 1:
return None
u1, u2, u3 = 1, 0, a
v1, v2, v3 = 0, 1, m
while v3 != 0:
q = u3 // v3
v1, v2, v3, u1, u2, u3 = (u1 - q * v1), (u2 - q * v2), (u3 - q * v3), v1, v2, v3
return u1 % mRabinMiller 모듈
RSA 알고리즘의 모든 기본 구현을 따르는 RabinMiller 모듈의 소스 코드는 다음과 같습니다.
import random
def rabinMiller(num):
s = num - 1
t = 0
while s % 2 == 0:
s = s // 2
t += 1
for trials in range(5):
a = random.randrange(2, num - 1)
v = pow(a, s, num)
if v != 1:
i = 0
while v != (num - 1):
if i == t - 1:
return False
else:
i = i + 1
v = (v ** 2) % num
return True
def isPrime(num):
if (num 7< 2):
return False
lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241,
251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,317, 331, 337, 347, 349,
353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449,
457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569,
571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661,
673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787,
797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907,
911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
if num in lowPrimes:
return True
for prime in lowPrimes:
if (num % prime == 0):
return False
return rabinMiller(num)
def generateLargePrime(keysize = 1024):
while True:
num = random.randrange(2**(keysize-1), 2**(keysize))
if isPrime(num):
return numRSA 키 생성을위한 전체 코드는 다음과 같습니다.
import random, sys, os, rabinMiller, cryptomath
def main():
makeKeyFiles('RSA_demo', 1024)
def generateKey(keySize):
# Step 1: Create two prime numbers, p and q. Calculate n = p * q.
print('Generating p prime...')
p = rabinMiller.generateLargePrime(keySize)
print('Generating q prime...')
q = rabinMiller.generateLargePrime(keySize)
n = p * q
# Step 2: Create a number e that is relatively prime to (p-1)*(q-1).
print('Generating e that is relatively prime to (p-1)*(q-1)...')
while True:
e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
# Step 3: Calculate d, the mod inverse of e.
print('Calculating d that is mod inverse of e...')
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
publicKey = (n, e)
privateKey = (n, d)
print('Public key:', publicKey)
print('Private key:', privateKey)
return (publicKey, privateKey)
def makeKeyFiles(name, keySize):
# Creates two files 'x_pubkey.txt' and 'x_privkey.txt'
(where x is the value in name) with the the n,e and d,e integers written in them,
# delimited by a comma.
if os.path.exists('%s_pubkey.txt' % (name)) or os.path.exists('%s_privkey.txt' % (name)):
sys.exit('WARNING: The file %s_pubkey.txt or %s_privkey.txt already exists! Use a different name or delete these files and re-run this program.' % (name, name))
publicKey, privateKey = generateKey(keySize)
print()
print('The public key is a %s and a %s digit number.' % (len(str(publicKey[0])), len(str(publicKey[1]))))
print('Writing public key to file %s_pubkey.txt...' % (name))
fo = open('%s_pubkey.txt' % (name), 'w')
fo.write('%s,%s,%s' % (keySize, publicKey[0], publicKey[1]))
fo.close()
print()
print('The private key is a %s and a %s digit number.' % (len(str(publicKey[0])), len(str(publicKey[1]))))
print('Writing private key to file %s_privkey.txt...' % (name))
fo = open('%s_privkey.txt' % (name), 'w')
fo.write('%s,%s,%s' % (keySize, privateKey[0], privateKey[1]))
fo.close()
# If makeRsaKeys.py is run (instead of imported as a module) call
# the main() function.
if __name__ == '__main__':
main()산출
다음 출력과 같이 공개 키와 개인 키가 생성되고 각 파일에 저장됩니다.
이 장에서는 RSA 암호 암호화의 다양한 구현과 이와 관련된 기능에 중점을 둘 것입니다. RSA 암호 알고리즘 구현을 구현하기 위해이 Python 파일을 참조하거나 포함 할 수 있습니다.
암호화 알고리즘에 포함 된 모듈은 다음과 같습니다.
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"더 나은 보안을 위해 해시 값을 SHA-256으로 초기화했습니다. 다음 코드를 사용하여 새 키 또는 공개 키와 개인 키 쌍을 생성하는 함수를 사용합니다.
def newkeys(keysize):
random_generator = Random.new().read
key = RSA.generate(keysize, random_generator)
private, public = key, key.publickey()
return public, private
def importKey(externKey):
return RSA.importKey(externKey)암호화의 경우 RSA 알고리즘을 따르는 다음 기능이 사용됩니다.
def encrypt(message, pub_key):
cipher = PKCS1_OAEP.new(pub_key)
return cipher.encrypt(message)두 가지 매개 변수는 필수입니다. message 과 pub_key공개 키를 나타냅니다. 암호화에는 공개 키가 사용되고 암호 해독에는 개인 키가 사용됩니다.
암호화 절차를위한 전체 프로그램은 다음과 같습니다.
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"
def newkeys(keysize):
random_generator = Random.new().read
key = RSA.generate(keysize, random_generator)
private, public = key, key.publickey()
return public, private
def importKey(externKey):
return RSA.importKey(externKey)
def getpublickey(priv_key):
return priv_key.publickey()
def encrypt(message, pub_key):
cipher = PKCS1_OAEP.new(pub_key)
return cipher.encrypt(message)이 장은 RSA 알고리즘을 사용하여 단계별로 암호화를 구현 한 이전 장의 연속이며 이에 대해 자세히 설명합니다.
암호 텍스트를 해독하는 데 사용되는 기능은 다음과 같습니다.
def decrypt(ciphertext, priv_key):
cipher = PKCS1_OAEP.new(priv_key)
return cipher.decrypt(ciphertext)공개 키 암호화 또는 비대칭 키 암호화의 경우 두 가지 중요한 기능을 유지하는 것이 중요합니다. Authentication 과 Authorization.
권한 부여
권한 부여는 보낸 사람이 메시지를 전송 한 유일한 사람임을 확인하는 프로세스입니다. 다음 코드는 이것을 설명합니다-
def sign(message, priv_key, hashAlg="SHA-256"):
global hash
hash = hashAlg
signer = PKCS1_v1_5.new(priv_key)
if (hash == "SHA-512"):
digest = SHA512.new()
elif (hash == "SHA-384"):
digest = SHA384.new()
elif (hash == "SHA-256"):
digest = SHA256.new()
elif (hash == "SHA-1"):
digest = SHA.new()
else:
digest = MD5.new()
digest.update(message)
return signer.sign(digest)입증
인증은 아래와 같은 검증 방법으로 가능합니다.
def verify(message, signature, pub_key):
signer = PKCS1_v1_5.new(pub_key)
if (hash == "SHA-512"):
digest = SHA512.new()
elif (hash == "SHA-384"):
digest = SHA384.new()
elif (hash == "SHA-256"):
digest = SHA256.new()
elif (hash == "SHA-1"):
digest = SHA.new()
else:
digest = MD5.new()
digest.update(message)
return signer.verify(digest, signature)디지털 서명은 보낸 사람 및받는 사람의 세부 정보와 함께 확인됩니다. 이것은 보안 목적으로 더 많은 체중 연령을 추가합니다.
RSA 암호 해독
RSA 암호 해독을 위해 다음 코드를 사용할 수 있습니다.
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"
def newkeys(keysize):
random_generator = Random.new().read
key = RSA.generate(keysize, random_generator)
private, public = key, key.publickey()
return public, private
def importKey(externKey):
return RSA.importKey(externKey)
def getpublickey(priv_key):
return priv_key.publickey()
def encrypt(message, pub_key):
cipher = PKCS1_OAEP.new(pub_key)
return cipher.encrypt(message)
def decrypt(ciphertext, priv_key):
cipher = PKCS1_OAEP.new(priv_key)
return cipher.decrypt(ciphertext)
def sign(message, priv_key, hashAlg = "SHA-256"):
global hash
hash = hashAlg
signer = PKCS1_v1_5.new(priv_key)
if (hash == "SHA-512"):
digest = SHA512.new()
elif (hash == "SHA-384"):
digest = SHA384.new()
elif (hash == "SHA-256"):
digest = SHA256.new()
elif (hash == "SHA-1"):
digest = SHA.new()
else:
digest = MD5.new()
digest.update(message)
return signer.sign(digest)
def verify(message, signature, pub_key):
signer = PKCS1_v1_5.new(pub_key)
if (hash == "SHA-512"):
digest = SHA512.new()
elif (hash == "SHA-384"):
digest = SHA384.new()
elif (hash == "SHA-256"):
digest = SHA256.new()
elif (hash == "SHA-1"):
digest = SHA.new()
else:
digest = MD5.new()
digest.update(message)
return signer.verify(digest, signature)RSA 암호 해킹은 소수로도 가능하지만 큰 숫자로 사용하면 불가능한 것으로 간주됩니다. RSA 암호를 해킹하기 어려운 이유를 지정하는 이유는 다음과 같습니다.
처리 할 수있는 키가 너무 많기 때문에 무차별 대입 공격은 작동하지 않습니다. 또한 이것은 많은 시간을 소비합니다.
키가 숫자이고 문자를 포함하지 않기 때문에 사전 공격은 RSA 알고리즘에서 작동하지 않습니다.
문자의 빈도 분석은 단일 암호화 된 블록이 다양한 문자를 나타 내기 때문에 따라 가기가 매우 어렵습니다.
RSA 암호를 해킹하는 특별한 수학적 트릭은 없습니다.
RSA 복호화 방정식은 다음과 같습니다.
M = C^d mod n작은 소수의 도움으로 RSA 암호를 해킹 할 수 있으며 동일한 샘플 코드가 아래에 언급되어 있습니다.
def p_and_q(n):
data = []
for i in range(2, n):
if n % i == 0:
data.append(i)
return tuple(data)
def euler(p, q):
return (p - 1) * (q - 1)
def private_index(e, euler_v):
for i in range(2, euler_v):
if i * e % euler_v == 1:
return i
def decipher(d, n, c):
return c ** d % n
def main():
e = int(input("input e: "))
n = int(input("input n: "))
c = int(input("input c: "))
# t = 123
# private key = (103, 143)
p_and_q_v = p_and_q(n)
# print("[p_and_q]: ", p_and_q_v)
euler_v = euler(p_and_q_v[0], p_and_q_v[1])
# print("[euler]: ", euler_v)
d = private_index(e, euler_v)
plain = decipher(d, n, c)
print("plain: ", plain)
if __name__ == "__main__":
main()산출
위의 코드는 다음 출력을 생성합니다.
