تخفیف نوروزی پی استور
کد تخفیف: PR1404
شامل تمامی آثار
روز
ساعت
دقیقه
ثانیه
تخفیف نوروزی پی استور
در زمان‌های خیلی دور، یک روش رمزنگاری در بین یونانیان باستان رواج پیدا کرده بود که در اغلب جنگ‌ها از آن روش استفاده می‌شد. به‌این‌ترتیب که، فرماندهان مستقر در نقاط جنگی، برای ارتباط با یکدیگر، متن نامه‌ها و مکتوب‌هایشان را با آب‌لیمو یا هر مایع دیگری که خاصیت اسیدی داشته باشد؛ می‌نوشتند. بعد از گذشت چند لحظه، آب‌لیمو از صفحه محو می‌شد و اگر آن مکتوب به‌دست دشمن می‌افتاد؛ تکه کاغذی بیش نبود.
به‌بیان‌دیگر یونانیان، در آن زمان داده‌های مکتوب خود را با استفاده از این کلید ساده رمزگذاری می‌کردند و برای رمزگشایی کافی بود که فرمانده گیرنده مکتوب، آن نامه را بر روی شعله‌های آتش بگیرد. در این روش داده‌های ورودی و خروجی، اندازه و شکل خود که اغلب نقشه جنگ بود را حفظ می‌کردند. در الگوریتم des نیز روال کار به همین شکل است.
استاندارد رمزگذاری داده یا همان الگوریتم معروف des به این ترتیب کار می‌کند که برای مثال ۶۴ بیت ورودی ساده که می‌تواند شامل هرگونه اطلاعاتی باشد را گرفته و طی عملیات رمزگذاری، با استفاده از کلید ۵۶ بیتی رمزگذاری کرده و ۶۴ بیت خروجی رمزشده تحویل کاربر می‌دهد.
خروجی الگوریتم رمزنگاری des به شکل بلوک‌های ۶۵ بیتی تحویل برنامه نویس داده می‌شود تا در عملیات بعدی، اعم از انجام تراکنش مشتری، ثبت اطلاعات نمره دانشجو، تبادل پیام رئیس شرکت و کارمند ارشد او و غیره به صورت کاملاً ایمن، انجام شود و دسترسی هکر به جزئیات هرکدام از این سیستم‌ها بلوکه شود. در ادامه، شمای کلی الگوریتم رمزنگاری des آورده شده است.
در توضیحات بالا، گفتیم که الگوریتم، از یک کلید ۵۶ بیتی استفاده می‌کند. حتماً با تکرار این جمله، برایتان این سؤال پیش‌آمده که در الگوریتم رمزنگاری des، داده‌های ورودی ۶۴ بیتی اولیه چگونه به ۵۶ بیت تبدیل می‌شوند؟
در پاسخ به این سؤال، باید بگویم که بر اساس قانون این الگوریتم، در همان ابتدای فرآیند ۸ بیت از بلوک داده، کنار گذاشته می‌شود که این ۸ بیت عبارت‌اند از بیت‌های ۸، ۱۶، ۲۴، ۳۲، ۴۰، ۴۸، ۵۶ و ۶۴ که طی جدول زیر، حذف می‌شوند.
الگوریتم رمزنگاری des بر دو اساس توانسته پایه‌های شهرت خود را بچیند. اول اینکه با ویژگی جابجایی، داده‌های خود را انتشار می‌دهد و کلید خود را منعطف‌تر می‌کند؛ دوم اینکه با عمل جایگزینی به‌راحتی آب خوردن می‌تواند هکر را سردرگم کرده و حملات انجام‌شده بر روی سرور را خنثی سازد. برای همین ما استفاده از الگوریتم رمزنگاری داده را برای تراکنش‌هایی پیشنهاد می‌کنیم که به‌صورت گسسته انجام می‌شوند.
در لینک زیر پاورپوینت الگوریتم رمزنگاری des قرار داده شده که به بررسی الگوریتم رمزنگاری Data Encryption Standard پرداخته این الگوریتم یکی از الگوریتم‌های رمزمتقارن است که مزایا و معایب خود را دارد. در این پاورپوینت که دارای ۲۲ اسلاید قابل ویرایش می‌باشد، به ساختار و اجزای این الگوریتم پرداخته شده و مراحل عملیاتی این الگوریتم را نیز توضیح داده‌ایم.
همان‌طور که قبلاً هم اشاره شد؛ الگوریتم رمزنگاری des با یک بلوک ۶۴ بیتی که حاوی یک متن ساده است؛ کار خود را آغاز می‌کند. مراحل انجام کار در ادامه به ترتیب بیان‌شده است.
برای جمع‌بندی آنچه گفته شد؛ در ادامه؛ یک شمای دقیق‌تر از الگوریتم رمزنگاری des آورده شده است.
اگر در شکل بالا دقت کنید؛ متوجه خواهید شد که نحوه انتقال IP آورده شده و می‌خواهد به ما نشان دهد که جایگشت اولیه در اولین مرحله الگوریتم رمزنگاری des اتفاق می‌افتد. همان‌طور که از نام آن مشخص است؛ جایگشت اولیه وظیفه جابجایی بلوک‌های داده را بر عهده دارد. برای مثال، IP بیت اول بلوک متن ساده اصلی را با بیت ۵۸ متن و بیت دوم را با بیت ۵۰ بلوک متن ساده جایگزین می‌کند. این عمل، گمراهی هکر را به دنبال خواهد داشت. جدول زیر، نمونه یک جایگشت اولیه را نشان می‌دهد.
همان‌طور که بعد از انجام جایگشت اولیه یا IP اشاره کردیم؛ بلوک متنی تغییریافته ۶۴ بیتی به دو نیمه بلوک ۳۲ بیتی تقسیم می‌شود که برای هرکدام از آن‌ها، ۱۶ حالت وجود دارد و شامل محاسبات پیچیده ریاضی می‌شود. فرایند کدگذاری داده، نتایج گسترده‌ای برای الگوریتم رمزنگاری des تولید خواهد کرد. درنتیجه تولید این نتایج، سیستم موردنظر امنیت بیشتری خواهد داشت. دوستان عزیز، در ادامه به توضیح گام‌های کدگذاری و چگونگی برنامه‌نویسی آن پرداخته‌شده است پس با دقت بیشتری به مطالعه خود ادامه دهید که وارد قسمت‌های مهم مقاله خواهیم شد.
از کلید ۵۶ بیتی اولیه، یک کلید فرعی ۴۸ بیتی جدید طی فرآیندی به نام تبدیل کلید، تولید می‌شود. به‌این‌ترتیب که کلید ۵۶ بیتی به دو نصف ۲۸ بیتی تقسیم‌شده و بسته به شماره دور، به یک یا دو بلوک چپ، جابه‌جا می‌شوند. برای این که در مورد جابه‌جایی آن‌ها دچار اشتباه نشوید؛ چرخ عقربه‌های ساعت را برای بیت‌ها در نظر بگیرید. برای مثال، در شکل زیر، جابه‌جایی مربوط به بیت‌های ۱، ۲، ۹ یا ۱۶ آورده شده است.
به همین راحتی و پس از انجام یک شیفت مناسب، ۴۸ بیت از ۵۶ بیت انتخاب می‌شود. به‌عنوان‌مثال پس از شیفت، بیت شماره ۱۴ دقیقاً مثل سرباز شطرنج در موقعیت اول حرکت می‌کند و بیت شماره ۱۷ در موقعیت دوم! انتخاب ۴۸ بیت از ۵۶ بیت در جدول زیر، نشان داده‌شده است.
اگر جدول را با دقت مشاهده کنیم متوجه می‌شویم که ۷ بیت مثل بیت شماره ۱۸ کنار گذاشته‌شده‌اند و جدول فقط دارای موقعیت‌های ۴۸ بیتی است. این عملیات صرفاً برای کاهش یک کلید ۵۶ بیتی به یک کلید ۴۸ بیتی انجام‌شده است. از آنجایی‌که فرآیند تبدیل کلید شامل ترکیبی از عمل جایگشت و همچنین عمل انتخاب یک زیرمجموعه ۴۸ بیتی از کلید اصلی ۵۶ بیتی است؛ به آن جایگشت فشرده می‌گویند. جایگشت فشرده باعث می‌شود الگوریتم رمزنگاری des در مقابل حملات سایبری، به‌راحتی شکسته نشود.
اگر به خاطر داشته باشید در توضیح فرایند الگوریتم رمزنگاری des پس از جایگشت اولیه، دو بلوک متن ساده ۳۲ بیتی تولیدشده به نام‌های Left Plain Text و Right Plain Text داشتیم. در ادامه انجام الگوریتم و در طول عملیات گسترش جایگشتی، RPT از ۳۲ بیت به ۴۸ بیت افزایش‌یافته؛ بیت‌ها جایگشت می‌شوند و ازاین‌رو عملیات بسط جایگشت، انجام می‌گیرد.
برای توضیح بیشتر، RPT 32 بیتی به ۸ بلوک تقسیم می‌شود که هر بلوک از ۴ بیت تشکیل‌شده است. سپس، هر بلوک ۴ بیتی مرحله قبل، به یک بلوک ۶ بیتی مربوطه گسترش می‌یابد؛ یعنی در هر بلوک ۴ بیتی، ۲ بیت دیگر اضافه می‌گردد. برای درک بیشتر آنچه گفته شد؛ به شکل زیر توجه کنید.
حالا وقت آن رسیده است که آنچه را که گفته شد؛ به‌صورت کدهای برنامه‌نویسی شده پیاده‌سازی کنیم. کدهای زیر در محیط پایتون نوشته شده‌اند. پس از کد نویسی خروجی الگوریتم هم مورد بررسی قرار می‌گیرد تا در نتیجه‌گیری از این مقاله و درک بهتر الگوریتم به شما کمک کند.
# Hexadecimal to binary conversion
def hex2bin(s):
mp = {'0' : "0000",
'۱' : "۰۰۰۱",
'۲' : "۰۰۱۰",
'۳' : "۰۰۱۱",
'۴' : "۰۱۰۰",
'۵' : "۰۱۰۱",
'۶' : "۰۱۱۰",
'۷' : "۰۱۱۱",
'۸' : "۱۰۰۰",
'۹' : "۱۰۰۱",
'A' : "1010",
'B' : "1011",
'C' : "1100",
'D' : "1101",
'E' : "1110",
'F' : "1111" }
bin = ""
for i in range(len(s)):
bin = bin + mp[s[i]]
return bin
# Binary to hexadecimal conversion
def bin2hex(s):
mp = {"0000" : '0',
"۰۰۰۱" : '۱',
"۰۰۱۰" : '۲',
"۰۰۱۱" : '۳',
"۰۱۰۰" : '۴',
"۰۱۰۱" : '۵',
"۰۱۱۰" : '۶',
"۰۱۱۱" : '۷',
"۱۰۰۰" : '۸',
"۱۰۰۱" : '۹',
"۱۰۱۰" : 'A',
"۱۰۱۱" : 'B',
"۱۱۰۰" : 'C',
"۱۱۰۱" : 'D',
"۱۱۱۰" : 'E',
"۱۱۱۱" : 'F' }
hex = ""
for i in range(0,len(s),4):
ch = ""
ch = ch + s[i]
ch = ch + s[i + 1]
ch = ch + s[i + 2]
ch = ch + s[i + 3]
hex = hex + mp[ch]
return hex
# Binary to decimal conversion
def bin2dec(binary):
binary1 = binary
decimal, i, n = 0, 0, 0
while(binary != 0):
dec = binary % 10
decimal = decimal + dec * pow(2, i)
binary = binary//10
i += 1
return decimal
# Decimal to binary conversion
def dec2bin(num):
res = bin(num).replace("0b", "")
if(len(res)%4 != 0):
div = len(res) / 4
div = int(div)
counter =(4 * (div + 1)) - len(res)
for i in range(0, counter):
res = '0' + res
return res
# Permute function to rearrange the bits
def permute(k, arr, n):
permutation = ""
for i in range(0, n):
permutation = permutation + k[arr[i] - 1]
return permutation
# shifting the bits towards left by nth shifts
def shift_left(k, nth_shifts):
s = ""
for i in range(nth_shifts):
for j in range(1,len(k)):
s = s + k[j]
s = s + k[0]
k = s
s = ""
return k
# calculating xow of two strings of binary number a and b
def xor(a, b):
ans = ""
for i in range(len(a)):
if a[i] == b[i]:
ans = ans + "0"
else:
ans = ans + "1"
return ans
# Table of Position of 64 bits at initial level: Initial Permutation Table
initial_perm = [58, 50, 42, 34, 26, 18, 10, 2,
۶۰, ۵۲, ۴۴, ۳۶, ۲۸, ۲۰, ۱۲, ۴,
۶۲, ۵۴, ۴۶, ۳۸, ۳۰, ۲۲, ۱۴, ۶,
۶۴, ۵۶, ۴۸, ۴۰, ۳۲, ۲۴, ۱۶, ۸,
۵۷, ۴۹, ۴۱, ۳۳, ۲۵, ۱۷, ۹, ۱,
۵۹, ۵۱, ۴۳, ۳۵, ۲۷, ۱۹, ۱۱, ۳,
۶۱, ۵۳, ۴۵, ۳۷, ۲۹, ۲۱, ۱۳, ۵,
۶۳, ۵۵, ۴۷, ۳۹, ۳۱, ۲۳, ۱۵, ۷]
# Expansion D-box Table
exp_d = [32, 1 , 2 , 3 , 4 , 5 , 4 , 5,
۶ , ۷ , ۸ , ۹ , ۸ , ۹ , ۱۰, ۱۱,
۱۲, ۱۳, ۱۲, ۱۳, ۱۴, ۱۵, ۱۶, ۱۷,
۱۶, ۱۷, ۱۸, ۱۹, ۲۰, ۲۱, ۲۰, ۲۱,
۲۲, ۲۳, ۲۴, ۲۵, ۲۴, ۲۵, ۲۶, ۲۷,
۲۸, ۲۹, ۲۸, ۲۹, ۳۰, ۳۱, ۳۲, ۱ ]
# Straight Permutation Table
per = [ 16, 7, 20, 21,
۲۹, ۱۲, ۲۸, ۱۷,
۱, ۱۵, ۲۳, ۲۶,
۵, ۱۸, ۳۱, ۱۰,
۲, ۸, ۲۴, ۱۴,
۳۲, ۲۷, ۳, ۹,
۱۹, ۱۳, ۳۰, ۶,
۲۲, ۱۱, ۴, ۲۵ ]
# S-box Table
sbox = [[[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
[ ۰, ۱۵, ۷, ۴, ۱۴, ۲, ۱۳, ۱, ۱۰, ۶, ۱۲, ۱۱, ۹, ۵, ۳, ۸],
[ ۴, ۱, ۱۴, ۸, ۱۳, ۶, ۲, ۱۱, ۱۵, ۱۲, ۹, ۷, ۳, ۱۰, ۵, ۰],
[۱۵, ۱۲, ۸, ۲, ۴, ۹, ۱, ۷, ۵, ۱۱, ۳, ۱۴, ۱۰, ۰, ۶, ۱۳ ]],
[[۱۵, ۱, ۸, ۱۴, ۶, ۱۱, ۳, ۴, ۹, ۷, ۲, ۱۳, ۱۲, ۰, ۵, ۱۰],
[۳, ۱۳, ۴, ۷, ۱۵, ۲, ۸, ۱۴, ۱۲, ۰, ۱, ۱۰, ۶, ۹, ۱۱, ۵],
[۰, ۱۴, ۷, ۱۱, ۱۰, ۴, ۱۳, ۱, ۵, ۸, ۱۲, ۶, ۹, ۳, ۲, ۱۵],
[۱۳, ۸, ۱۰, ۱, ۳, ۱۵, ۴, ۲, ۱۱, ۶, ۷, ۱۲, ۰, ۵, ۱۴, ۹ ]],
[ [۱۰, ۰, ۹, ۱۴, ۶, ۳, ۱۵, ۵, ۱, ۱۳, ۱۲, ۷, ۱۱, ۴, ۲, ۸],
[۱۳, ۷, ۰, ۹, ۳, ۴, ۶, ۱۰, ۲, ۸, ۵, ۱۴, ۱۲, ۱۱, ۱۵, ۱],
[۱۳, ۶, ۴, ۹, ۸, ۱۵, ۳, ۰, ۱۱, ۱, ۲, ۱۲, ۵, ۱۰, ۱۴, ۷],
[۱, ۱۰, ۱۳, ۰, ۶, ۹, ۸, ۷, ۴, ۱۵, ۱۴, ۳, ۱۱, ۵, ۲, ۱۲ ]],
[ [۷, ۱۳, ۱۴, ۳, ۰, ۶, ۹, ۱۰, ۱, ۲, ۸, ۵, ۱۱, ۱۲, ۴, ۱۵],
[۱۳, ۸, ۱۱, ۵, ۶, ۱۵, ۰, ۳, ۴, ۷, ۲, ۱۲, ۱, ۱۰, ۱۴, ۹],
[۱۰, ۶, ۹, ۰, ۱۲, ۱۱, ۷, ۱۳, ۱۵, ۱, ۳, ۱۴, ۵, ۲, ۸, ۴],
[۳, ۱۵, ۰, ۶, ۱۰, ۱, ۱۳, ۸, ۹, ۴, ۵, ۱۱, ۱۲, ۷, ۲, ۱۴] ],
[ [۲, ۱۲, ۴, ۱, ۷, ۱۰, ۱۱, ۶, ۸, ۵, ۳, ۱۵, ۱۳, ۰, ۱۴, ۹],
[۱۴, ۱۱, ۲, ۱۲, ۴, ۷, ۱۳, ۱, ۵, ۰, ۱۵, ۱۰, ۳, ۹, ۸, ۶],
[۴, ۲, ۱, ۱۱, ۱۰, ۱۳, ۷, ۸, ۱۵, ۹, ۱۲, ۵, ۶, ۳, ۰, ۱۴],
[۱۱, ۸, ۱۲, ۷, ۱, ۱۴, ۲, ۱۳, ۶, ۱۵, ۰, ۹, ۱۰, ۴, ۵, ۳ ]],
[ [۱۲, ۱, ۱۰, ۱۵, ۹, ۲, ۶, ۸, ۰, ۱۳, ۳, ۴, ۱۴, ۷, ۵, ۱۱],
[۱۰, ۱۵, ۴, ۲, ۷, ۱۲, ۹, ۵, ۶, ۱, ۱۳, ۱۴, ۰, ۱۱, ۳, ۸],
[۹, ۱۴, ۱۵, ۵, ۲, ۸, ۱۲, ۳, ۷, ۰, ۴, ۱۰, ۱, ۱۳, ۱۱, ۶],
[۴, ۳, ۲, ۱۲, ۹, ۵, ۱۵, ۱۰, ۱۱, ۱۴, ۱, ۷, ۶, ۰, ۸, ۱۳] ],
[ [۴, ۱۱, ۲, ۱۴, ۱۵, ۰, ۸, ۱۳, ۳, ۱۲, ۹, ۷, ۵, ۱۰, ۶, ۱],
[۱۳, ۰, ۱۱, ۷, ۴, ۹, ۱, ۱۰, ۱۴, ۳, ۵, ۱۲, ۲, ۱۵, ۸, ۶],
[۱, ۴, ۱۱, ۱۳, ۱۲, ۳, ۷, ۱۴, ۱۰, ۱۵, ۶, ۸, ۰, ۵, ۹, ۲],
[۶, ۱۱, ۱۳, ۸, ۱, ۴, ۱۰, ۷, ۹, ۵, ۰, ۱۵, ۱۴, ۲, ۳, ۱۲] ],
[ [۱۳, ۲, ۸, ۴, ۶, ۱۵, ۱۱, ۱, ۱۰, ۹, ۳, ۱۴, ۵, ۰, ۱۲, ۷],
[۱, ۱۵, ۱۳, ۸, ۱۰, ۳, ۷, ۴, ۱۲, ۵, ۶, ۱۱, ۰, ۱۴, ۹, ۲],
[۷, ۱۱, ۴, ۱, ۹, ۱۲, ۱۴, ۲, ۰, ۶, ۱۰, ۱۳, ۱۵, ۳, ۵, ۸],
[۲, ۱, ۱۴, ۷, ۴, ۱۰, ۸, ۱۳, ۱۵, ۱۲, ۹, ۰, ۳, ۵, ۶, ۱۱] ] ]
# Final Permutation Table
final_perm = [ 40, 8, 48, 16, 56, 24, 64, 32,
۳۹, ۷, ۴۷, ۱۵, ۵۵, ۲۳, ۶۳, ۳۱,
۳۸, ۶, ۴۶, ۱۴, ۵۴, ۲۲, ۶۲, ۳۰,
۳۷, ۵, ۴۵, ۱۳, ۵۳, ۲۱, ۶۱, ۲۹,
۳۶, ۴, ۴۴, ۱۲, ۵۲, ۲۰, ۶۰, ۲۸,
۳۵, ۳, ۴۳, ۱۱, ۵۱, ۱۹, ۵۹, ۲۷,
۳۴, ۲, ۴۲, ۱۰, ۵۰, ۱۸, ۵۸, ۲۶,
۳۳, ۱, ۴۱, ۹, ۴۹, ۱۷, ۵۷, ۲۵ ]
def encrypt(pt, rkb, rk):
pt = hex2bin(pt)
# Initial Permutation
pt = permute(pt, initial_perm, 64)
print("After initial permutation", bin2hex(pt))
# Splitting
left = pt[0:32]
right = pt[32:64]
for i in range(0, 16):
# Expansion D-box: Expanding the 32 bits data into 48 bits
right_expanded = permute(right, exp_d, 48)
# XOR RoundKey[i] and right_expanded
xor_x = xor(right_expanded, rkb[i])
# S-boxex: substituting the value from s-box table by calculating row and column
sbox_str = ""
for j in range(0, 8):
row = bin2dec(int(xor_x[j * 6] + xor_x[j * 6 + 5]))
col = bin2dec(int(xor_x[j * 6 + 1] + xor_x[j * 6 + 2] + xor_x[j * 6 + 3] + xor_x[j * 6 + 4]))
val = sbox[j][row][col]
sbox_str = sbox_str + dec2bin(val)
# Straight D-box: After substituting rearranging the bits
sbox_str = permute(sbox_str, per, 32)
# XOR left and sbox_str
result = xor(left, sbox_str)
left = result
# Swapper
if(i != 15):
left, right = right, left
print("Round ", i + 1, " ", bin2hex(left), " ", bin2hex(right), " ", rk[i])
# Combination
combine = left + right
# Final permutation: final rearranging of bits to get cipher text
cipher_text = permute(combine, final_perm, 64)
return cipher_text
pt = "123456ABCD132536"
key = "AABB09182736CCDD"
# Key generation
# --hex to binary
key = hex2bin(key)
# --parity bit drop table
keyp = [57, 49, 41, 33, 25, 17, 9,
۱, ۵۸, ۵۰, ۴۲, ۳۴, ۲۶, ۱۸,
۱۰, ۲, ۵۹, ۵۱, ۴۳, ۳۵, ۲۷,
۱۹, ۱۱, ۳, ۶۰, ۵۲, ۴۴, ۳۶,
۶۳, ۵۵, ۴۷, ۳۹, ۳۱, ۲۳, ۱۵,
۷, ۶۲, ۵۴, ۴۶, ۳۸, ۳۰, ۲۲,
۱۴, ۶, ۶۱, ۵۳, ۴۵, ۳۷, ۲۹,
۲۱, ۱۳, ۵, ۲۸, ۲۰, ۱۲, ۴ ]
# getting 56 bit key from 64 bit using the parity bits
key = permute(key, keyp, 56)
# Number of bit shifts
shift_table = [1, 1, 2, 2,
۲, ۲, ۲, ۲,
۱, ۲, ۲, ۲,
۲, ۲, ۲, ۱ ]
# Key- Compression Table : Compression of key from 56 bits to 48 bits
key_comp = [14, 17, 11, 24, 1, 5,
۳, ۲۸, ۱۵, ۶, ۲۱, ۱۰,
۲۳, ۱۹, ۱۲, ۴, ۲۶, ۸,
۱۶, ۷, ۲۷, ۲۰, ۱۳, ۲,
۴۱, ۵۲, ۳۱, ۳۷, ۴۷, ۵۵,
۳۰, ۴۰, ۵۱, ۴۵, ۳۳, ۴۸,
۴۴, ۴۹, ۳۹, ۵۶, ۳۴, ۵۳,
۴۶, ۴۲, ۵۰, ۳۶, ۲۹, ۳۲ ]
# Splitting
left = key[0:28] # rkb for RoundKeys in binary
right = key[28:56] # rk for RoundKeys in hexadecimal
rkb = []
rk = []
for i in range(0, 16):
# Shifting the bits by nth shifts by checking from shift table
left = shift_left(left, shift_table[i])
right = shift_left(right, shift_table[i])
# Combination of left and right string
combine_str = left + right
# Compression of key from 56 to 48 bits
round_key = permute(combine_str, key_comp, 48)
rkb.append(round_key)
rk.append(bin2hex(round_key))
print("Encryption")
cipher_text = bin2hex(encrypt(pt, rkb, rk))
print("Cipher Text : ",cipher_text)
print("Decryption")
rkb_rev = rkb[::-1]
rk_rev = rk[::-1]
text = bin2hex(encrypt(cipher_text, rkb_rev, rk_rev))
print("Plain Text : ",text)
دوستان و همراهان گرامی، در آخر خروجی حاصل از اجرای الگوریتم کد نویسی شده بالا، آورده شده است. مشاهده می‌کنید که به‌آسانی و با طی ۱۶ مرحله ساده، داده‌های ورودی اولیه، رمزگذاری شده و موجبات امنیت سیستم موردمطالعه را فراهم کرد.
Encryption: After initial permutation: 14A7D67818CA18AD After splitting: L0=14A7D678 R0=18CA18AD Round 1 18CA18AD 5A78E394 194CD072DE8C Round 2 5A78E394 4A1210F6 4568581ABCCE Round 3 4A1210F6 B8089591 06EDA4ACF5B5 Round 4 B8089591 236779C2 DA2D032B6EE3 Round 5 236779C2 A15A4B87 69A629FEC913 Round 6 A15A4B87 2E8F9C65 C1948E87475E Round 7 2E8F9C65 A9FC20A3 708AD2DDB3C0 Round 8 A9FC20A3 308BEE97 34F822F0C66D Round 9 308BEE97 10AF9D37 84BB4473DCCC Round 10 10AF9D37 6CA6CB20 02765708B5BF Round 11 6CA6CB20 FF3C485F 6D5560AF7CA5 Round 12 FF3C485F 22A5963B C2C1E96A4BF3 Round 13 22A5963B 387CCDAA 99C31397C91F Round 14 387CCDAA BD2DD2AB 251B8BC717D0 Round 15 BD2DD2AB CF26B472 3330C5D9A36D Round 16 19BA9212 CF26B472 181C5D75C66D Cipher Text: C0B7A8D05F3A829C Decryption After initial permutation: 19BA9212CF26B472 After splitting: L0=19BA9212 R0=CF26B472 Round 1 CF26B472 BD2DD2AB 181C5D75C66D Round 2 BD2DD2AB 387CCDAA 3330C5D9A36D Round 3 387CCDAA 22A5963B 251B8BC717D0 Round 4 22A5963B FF3C485F 99C31397C91F Round 5 FF3C485F 6CA6CB20 C2C1E96A4BF3 Round 6 6CA6CB20 10AF9D37 6D5560AF7CA5 Round 7 10AF9D37 308BEE97 02765708B5BF Round 8 308BEE97 A9FC20A3 84BB4473DCCC Round 9 A9FC20A3 2E8F9C65 34F822F0C66D Round 10 2E8F9C65 A15A4B87 708AD2DDB3C0 Round 11 A15A4B87 236779C2 C1948E87475E Round 12 236779C2 B8089591 69A629FEC913 Round 13 B8089591 4A1210F6 DA2D032B6EE3 Round 14 4A1210F6 5A78E394 06EDA4ACF5B5 Round 15 5A78E394 18CA18AD 4568581ABCCE Round 16 14A7D678 18CA18AD 194CD072DE8C Plain Text: 123456ABCD132536
عزیزان، همان‌طور که ملاحظه کردید؛ مراحل آموزش جامع الگوریتم des با استفاده از زبان برنامه نویسی پایتون به زبان ساده بیان گردید. برنامه نویسان و محققان علوم سایبری، استفاده از الگوریتم‌های بهینه و کامل شده des را پیشنهاد می‌کنند. الگوریتم‌های رمزنگاری مختلفی وجود دارند که برای موارد خاص استفاده می‌شوند. چنانچه مایل باشید می‌توانید مطلب الگوریتم رمزنگاری rsa | آموزش جامع الگوریتم rsa به زبان ساده را که در مورد امنیت و حفاظت از داده‌ها و اطلاعات مهم می‌باشد مطالعه نمایید.
4 پاسخ
عالی بود. ممنون.
فرآیندهای des رو خیلی خوب توضیح دادین.
تو کد گذاری داده کمی مشکل داشتم با توضیحات شما خوب متوجه شدم.🥰
سلام
و سپاس از مطلب بسیار ارزشمند و خوبتان.
من قصد داشتم به شما ۵ ستاره امتیاز بدم. اما نمی‌دانستم ستاره‌ها از راست شروع می‌شن یا از چپ! متاسفانه ۱ امتیاز درج شد! خیلی ببخشید. و بعدا هرچه‌قدر تلاش کردم، نتوانستم اصلاح کنم.
من به شما ۵ امتیاز می‌دهم.