🙍🏼 🛒 🛤️ सौ लाइनों में जे ♨️ 🐋 😝

जेएस पर तीस-सप्ताह का सप्ताह वास्तव में असामान्य कुछ के साथ पतला होना चाहिए।

मैं सलाह देता हूं कि आप पढ़ने से पहले पढ़ें, उदाहरण के लिए, लेखों की यह श्रृंखला या यह पुस्तक; भाषा शब्दकोश यहाँ ; फिर भी, मैं अपने कार्यों को विस्तार से समझाने की कोशिश करूँगा (सभी स्पष्टीकरण बिगाड़ने के तहत छिपे हुए हैं ताकि लेख को अव्यवस्थित न करें)।

यदि आपके पास कोड के प्रश्न, सुझाव या सुधार हैं - टिप्पणियों में आपका स्वागत है।

डेस क्या है?

DES (डेटा एन्क्रिप्शन स्टैंडर्ड) आईबीएम द्वारा विकसित और 1977 में अमेरिकी सरकार द्वारा आधिकारिक मानक (FIPS 46-3) के रूप में अनुमोदित एक सममित एन्क्रिप्शन एल्गोरिथम है।

डेस 56-बिट कुंजी का उपयोग करके एक विशिष्ट ब्लॉक सिफर है। एन्क्रिप्शन प्रक्रिया में 64-बिट ब्लॉक के बिटकॉइन के प्रारंभिक क्रमांकन, एन्क्रिप्शन के सोलह चक्र और अंत में, बिट्स के रिवर्स क्रमचय शामिल हैं।

जमीन तैयार करना

डेस कई मेट्रिक्स का उपयोग करता है जो समय से पहले तैयार करने के लायक हैं।

प्रारंभिक क्रमपरिवर्तन मैट्रिक्स पी

पैटर्न नग्न आंखों को दिखाई देता है: ऊपर से नीचे तक मैट्रिक्स के ऊपरी आधे हिस्से में दाएं से बाएं 1 से 63 तक विषम संख्याएं हैं, और मैट्रिक्स के निचले आधे हिस्से का प्रत्येक तत्व ऊपरी के संगत तत्व से एक कम है। इसका लाभ उठाएं।

स्पष्टीकरण

सबसे पहले, शीर्ष बनाओ।

|: |. 8 4 $ >: +: i.32 57 49 41 33 25 17 9 1 59 51 43 35 27 19 11 3 61 53 45 37 29 21 13 5 63 55 47 39 31 23 15 7

कोड दाईं से बाईं ओर चलता है। क्रम में:

i.32 शून्य से शुरू होने वाले 32 लगातार संख्याओं का उत्पादन करता है;
+: इसके ऑपरेंड को दोगुना करता है;
>: एक से ऑपरेंड बढ़ाता है;
8 4 $ ऑपरेंड को 8x4 मैट्रिक्स में परिवर्तित करता है;
|. मैट्रिक्स के मुख्य अक्ष को सम्मिलित करता है, अर्थात। रिवर्स ऑर्डर में स्ट्रिंग्स को फिर से व्यवस्थित करता है;
|: मैट्रिक्स को स्थानांतरित करता है।

क्रमिक

  i.32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 +: i.32 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 >: +: i.32 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 8 4 $ >: +: i.32 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 |. 8 4 $ >: +: i.32 57 59 61 63 49 51 53 55 41 43 45 47 33 35 37 39 25 27 29 31 17 19 21 23 9 11 13 15 1 3 5 7 |: |. 8 4 $ >: +: i.32 57 49 41 33 25 17 9 1 59 51 43 35 27 19 11 3 61 53 45 37 29 21 13 5 63 55 47 39 31 23 15 7

मैट्रिक्स के निचले आधे हिस्से को प्राप्त करने में कुछ भी खर्च नहीं होता है:

  <: |: |. 8 4 $ >: +: i.32 56 48 40 32 24 16 8 0 58 50 42 34 26 18 10 2 60 52 44 36 28 20 12 4 62 54 46 38 30 22 14 6

<: ऑपरेटर ऑपरेटर के मूल्य को एक से कम कर देता है।
इसे संयोजित करना बाकी है - यहाँ J का जादू चलन में है:

  (] , <:) |: |. 8 4 $ >: +: i.32 57 49 41 33 25 17 9 1 59 51 43 35 27 19 11 3 61 53 45 37 29 21 13 5 63 55 47 39 31 23 15 7 56 48 40 32 24 16 8 0 58 50 42 34 26 18 10 2 60 52 44 36 28 20 12 4 62 54 46 38 30 22 14 6

तीन-क्रिया निर्माण को कांटा कहा जाता है:
(fgh) y <-> (fy) g (hy)
इस प्रकार, ऊपर का निर्माण इसके बराबर है:

 (] |: |. 8 4 $ >: +: i.32) , (<: |: |. 8 4 $ >: +: i.32)

डाईएड सरणियों का संघटन करता है, और ] बस अपना सही संचालन वापस करता है।
मोनाड वेरिएंट , "सीधा" मैट्रिक्स को एक सरणी में, जिसका हम उपयोग करते हैं, प्रारंभिक अनुमति के मैट्रिक्स के लिए अंतिम सूत्र प्राप्त करते हैं:

 P =: , (] , <:) |: |. 8 4 $ >: +: i.32

उलटा क्रमपरिवर्तन मैट्रिक्स पी ^-1

यह मैट्रिक्स पी के अनुरूप है: पी ^-1 का 0 तत्व 39 है, पी का 39 वां तत्व 0 है, आदि।
दूसरे शब्दों में, मैट्रिक्स P ^-1 के तत्व मैट्रिक्स P में उनके सूचकांकों के सूचक हैं। यह भ्रामक लगता है, लेकिन यह इस मैट्रिक्स के सूत्र को रेखांकित करता है।

स्पष्टीकरण

पहला चरण डाईड कांटा का उपयोग करने के लिए है:
x (fgh) y <-> (xfy) g (xhy)

 (i.64) ([ * =/~) P

परिणाम 64x64 मैट्रिक्स है, जहां प्रत्येक पंक्ति में P [i] की स्थिति में अपना नंबर (कहते हैं, i) है, और शेष तत्व शून्य से भरे हुए हैं।
कांटा के अलावा, क्रियाविशेषण / और ~ का उपयोग किया जाता है: पहला सरणी के प्रत्येक तत्व पर क्रिया को लागू करता है, और दूसरा ऑपरेंड को स्वैप करता है, इसलिए
xf~ y <-> yfx
यदि हम u/ y लिखते u/ y , जहाँ u एक डायडिक क्रिया है, J इसे y के सभी तत्वों के बीच प्रतिस्थापित करेगा:
+/ 1 2 3 <-> 1 + 2 + 3
या इसकी लाइनों को जोड़कर और अंतिम सूत्र प्राप्त करके हमारे मैट्रिक्स पर लागू करें:

 iP =: +/ (i.64) ([ * =/~) P

कुंजी जी के प्रारंभिक क्रमचय का मैट्रिक्स

7 वें, 15 वें और इतने पर बिट्स को कुंजी के "बाहर फेंक दिया" जाता है - वे समता को नियंत्रित करने के लिए सेवा करते हैं।
जी में पैटर्न इतना स्पष्ट नहीं है, हालांकि, लगातार संख्याओं के 8x8 मैट्रिक्स से मैट्रिक्स जी को प्राप्त करना मुश्किल नहीं है, जिसमें से अंतिम कॉलम बस बाहर फेंक दिया गया था।

स्पष्टीकरण

  }: |: i. 8 8 0 8 16 24 32 40 48 56 1 9 17 25 33 41 49 57 2 10 18 26 34 42 50 58 3 11 19 27 35 43 51 59 4 12 20 28 36 44 52 60 5 13 21 29 37 45 53 61 6 14 22 30 38 46 54 62

i. 8 8 संख्याओं की एक सरणी के बजाय i. 8 8 तुरंत लगातार संख्याओं का 8x8 मैट्रिक्स बनाता है।
}: मैट्रिक्स के सरणी / पंक्ति के अंतिम तत्व को फेंकता है।

ट्रांसपोज़िंग एक साइड इफेक्ट है, लेकिन यह इस रूप में है कि हमें मैट्रिक्स की आवश्यकता है।
अब आपको लाइनों को उल्टा करने की आवश्यकता है - यदि आप सिर्फ परिणाम पर लागू होते हैं |. , तो पूरी पंक्ति बदली जाएगी। हमारे मामले में, हमें क्रिया की रैंक बदलने की आवश्यकता है ताकि यह प्रत्येक व्यक्तिगत रेखा के साथ काम करे:

  |."1 }: |: i. 8 8 56 48 40 32 24 16 8 0 57 49 41 33 25 17 9 1 58 50 42 34 26 18 10 2 59 51 43 35 27 19 11 3 60 52 44 36 28 20 12 4 61 53 45 37 29 21 13 5 62 54 46 38 30 22 14 6

" क्रिया की रैंक को बदलता है। 0 के एक रैंक का मतलब है कि क्रिया को ऑपरेंड के प्रत्येक तत्व, 1 से पंक्ति और 2 से पूरे मैट्रिक्स पर लागू किया जाता है।
परिणाम को चर G सहेजें - यह अधिक सुविधाजनक होगा।
यह पहले से ही स्पष्ट है कि मैट्रिक्स के पहले 28 तत्व ठीक उसी तरह हैं जैसे हमें ज़रूरत है, पंक्तियों के क्रम को प्राप्त करके एक और 24 प्राप्त किया जा सकता है। मैं शेष चार तत्वों को अच्छी तरह से बाहर निकालने में सफल नहीं हुआ, इसलिए जैसे हैं वैसे ही उन्हें दर्ज करें:

  4 14 $ (28 {. , G), (24 {. , |. G), (27 19 11 3) 56 48 40 32 24 16 8 0 57 49 41 33 25 17 9 1 58 50 42 34 26 18 10 2 59 51 43 35 62 54 46 38 30 22 14 6 61 53 45 37 29 21 13 5 60 52 44 36 28 20 12 4 27 19 11 3

N {. y N {. y पहले N तत्वों को y से खींचता है।
परिणाम सहेजें।

 G =: |."1 }: |: i. 8 8 G =: (28 {. , G), (24 {. , |. G), (27 19 11 3)

केपी कुंजी क्रमचय मैट्रिक्स

यहां सब कुछ उदास है - पैटर्न दिखाई नहीं देते हैं, इसलिए हम मैट्रिक्स लिखते हैं जैसा कि यह है।

एस पारी मैट्रिक्स

पहली पंक्ति सूचकांक है, दूसरा मान है। मैं यहां विस्तार से नहीं रहूंगा।

 s =:1, (14 $ 1, 6 $ 2), 1

एक्सटेंशन मैट्रिक्स ई

यह मैट्रिक्स आसानी से i. 8 4 से प्राप्त किया जाता है i. 8 4 i. 8 4 : बाएं स्तंभ को चक्रीय रूप से नीचे स्थानांतरित किया गया है और दाईं ओर मैट्रिक्स पर तैनात किया गया है, दायां स्तंभ ऊपर स्थानांतरित कर दिया गया है और बाईं ओर स्थित है।

 E =: |: i. 8 4 E =: , |: (_1 |. _1 { E) , E , (1 |. 0 { E)

संचालक x |. y x |. y सरणी का एक गोलाकार बदलाव करता है।

P2 क्रमपरिवर्तन मैट्रिक्स _{(हाँ, DES में कई क्रमपरिवर्तन हैं)}

यहाँ, कोई भी पैटर्न दिखाई नहीं दे रहा है। और आगे चलते हैं।

एस परिवर्तन मैट्रिक्स

यह बहुत बड़ा है, त्रि-आयामी है, और बिल्कुल भी कोई नियमितता इसमें दिखाई नहीं देती है।
हम इस मैट्रिक्स को नीचे लिखेंगे जैसा कि यह है, और साथ ही हम कुछ क्रियाओं का निर्माण करेंगे ताकि बाद में इससे निपटना आसान हो जाए।

 f =: dyad : '|. #: S {~ < x, ((5{y)++:0{y), (+/(2^i.4)*}:}.y)' " 0 1 fS =: monad : '}. |."1 (4 $ 1), (i.8) f 8 6 $, y' " 2

स्पष्टीकरण

दूसरी क्रिया से शुरू करते हैं। यह 2 के रैंक के साथ एक सनक है, जो मैट्रिक्स को 8x6 प्रारूप में परिवर्तित करता है और इसे सही ऑपरेंड के साथ पहली क्रिया तक खिलाता है। बायाँ ऑपरेंड i.8 । फिर परिणाम में चार इकाइयों की एक पंक्ति जोड़ी जाती है, मैट्रिक्स की सभी पंक्तियों को उलटा कर दिया जाता है और पहली पंक्ति को हटा दिया जाता है।

पहली क्रिया 0 1 की रैंक के साथ एक रंजक है (जैसे रंजक क्रिया में एक रैंक का मतलब है कि रैंक 0 को बाएं ऑपरेंड और 1 से दाएं ऑपरेंड पर लागू किया जाता है)। यह क्रिया मानती है कि दाहिना ऑपरेंड लंबाई के बिट्स की एक सरणी है। 0 और 5 वीं बिट्स एस में लाइन संख्या निर्धारित करते हैं, बिट्स 1 4 के माध्यम से कॉलम संख्या निर्धारित करते हैं, और बाएं ऑपरेंड सबमेट्रिक्स की संख्या को निर्धारित करते हैं। सभी तीन प्राप्त संख्याओं को एक बॉक्स (संरचना का एक स्थानीय एनालॉग) में crammed किया जाता है और इनपुट ऑपरेटर { - इंडेक्स द्वारा सरणी से लेते हुए पास किया जाता है। ऑपरेटर #: परिणाम को एक द्विआधारी संख्या प्रणाली में अनुवाद करता है, जो अगले चरण द्वारा उलटा होता है।

व्युत्क्रम और चार इकाइयों की एक पंक्ति को जोड़ने वाले इस महाकाव्य को परिणाम लाइनों में अग्रणी शून्य जोड़ने के लिए आवश्यक है: यदि वे शुरू में उल्टे नहीं हैं, तो अंत में शून्य जोड़े जाते हैं।

चलो व्यापार के लिए नीचे उतरो

पहले हम उन कुंजियों की एक सूची बनाते हैं जिनका हम उपयोग करेंगे (हम मानते हैं कि key पहले से परिभाषित है):

स्पष्टीकरण

सबसे पहले, हम स्व-लिखित मोनड द्वारा वर्णों को द्विआधारी प्रतिनिधित्व में अनुवाद करते हैं (लेख में कोई कोड नहीं होगा) और कुंजी जी के प्रारंभिक क्रमचय के मैट्रिक्स को परिणाम पर लागू करें:

 binkey =. chr2bin key prmkey =. G { binkey

फिर हम परिणाम के पहले 28 बिट्स लेते हैं और पारी के परिणामों की एक सूची बनाते हैं:

 C =. (28 {. prmkey) |.~"1 0 +/\s

इस लाइन पर नए में से, केवल क्रिया विशेषण: यह क्रिया प्रत्येक उपसर्ग उपसर्ग पर लागू होती है।

  s 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1 +/\s 1 2 4 6 8 10 12 14 15 17 19 21 23 25 27 28

हम पिछले 28 बिट्स के साथ भी ऐसा ही करेंगे:

 D =. (28 }. prmkey) |.~"1 0 +/\s

N }. y N }. y के पहले N तत्वों को y ।
अब हमें संबंधित लाइनों को समाहित करने और परिणाम की प्रत्येक पंक्ति में KP कुंजी क्रमपरिवर्तन मैट्रिक्स लागू करने की आवश्यकता है:

 K =. KP {"1 C ," 1 1 D

 binkey =. chr2bin key prmkey =. G { binkey C =. (28 {. prmkey) |.~"1 0 +/\s D =. (28 }. prmkey) |.~"1 0 +/\s K =. KP {"1 C ," 1 1 D

मूल 8-बाइट पाठ को दो 32-बिट भागों में विभाजित किया गया है:

 bin =. chr2bin plain prm =. P { bin L =. 32 {. prm R =. 32 }. prm

अब हमें निम्न में से प्रत्येक की जोड़ी L, R पर लागू करने की आवश्यकता है:

ऐसा करने के लिए, एक पुनरावर्ती मोनाड बनाएं जो तीन मानों के साथ एक बॉक्स लेता है और एक समान बॉक्स लौटाता है।

स्पष्टीकरण

> "सामग्री खोलता है" बॉक्स को खोलता है।

 K =. > 0 { y L =. > 1 { y R =. > 2 { y

उपरोक्त छवि में f फ़ंक्शन निम्नलिखित करता है:

विस्तार मैट्रिक्स E से R तक लागू होता है;
कुंजी मॉड्यूल 2 के साथ परिणाम जोड़ता है;
परिणाम के प्रत्येक छह-बिट ब्लॉक के लिए मैट्रिक्स एस में संबंधित चार-बिट संख्या मिलती है;
इस पर क्रमपरिवर्तन मैट्रिक्स P2 लागू होता है;
एल मोडुलो 2 के साथ परिणाम जोड़ता है;

कितना भाग्यशाली है कि अनुच्छेद 3 के लिए हमारे पास एक विशेष क्रिया है! उपरोक्त सभी एक सरल रेखा में वर्णित हैं:

 L ~: P2 { , fS (0 { K) ~: E { R

 step =: monad define K =. > 0 { y L =. > 1 { y R =. > 2 { y (}. K); R ; L ~: P2 { , fS (0 { K) ~: E { R )

और हम इसे कई बार कहेंगे जब हमारे पास चाबी होगी:

 result =. step^:(#K) K; L; R

स्पष्टीकरण

इस लाइन में नए में से, केवल यूनियन u^:N , जो क्रिया यू एन बार करता है, उदाहरण के लिए,
u^:4 y <-> uuuuy

फिर से, L और R को स्वैप करें और एन्क्रिप्टेड टेक्स्ट प्राप्त करें।

 R =. > 1 { result L =. > 2 { result bin2chr iP { ,L,R

आइए सब कुछ एक डाइएड में लपेटते हैं जो बाएं ऑपरेंड के साथ एक कुंजी को स्वीकार करता है और दाएं के साथ 8-बाइट सरणी है:

यहां लंबा डॉग

 encode =: dyad define key =. x binkey =. chr2bin key prmkey =. G { binkey C =. (28 {. prmkey) |.~"1 0 +/\s D =. (28 }. prmkey) |.~"1 0 +/\s K =. KP {"1 C ," 1 1 D plain =. y bin =. chr2bin plain prm =. P { bin L =. 32 {. prm R =. 32 }. prm result =. step^:(#K) K; L; R R =. > 1 { result L =. > 2 { result bin2chr iP { ,L,R )

डिक्रिप्शन बिल्कुल उसी तरह से किया जाता है, जिसमें एकमात्र अंतर यह है कि चाबियाँ रिवर्स ऑर्डर में उपयोग की जाती हैं।

हमारे पास जो भी है उसे लागू करने से पहले, हमें पाठ तैयार करने की आवश्यकता है:

in.txt:
Lorem ipsum dolor sit amet consectetur adipiscing elit.

स्पष्टीकरण

1!:1 फ़ाइल की सामग्री को पढ़ता है

 plaintext =: 1!:1 < 'in.txt'

चूंकि एल्गोरिथ्म प्रत्येक 8 अक्षरों के ब्लॉक के साथ काम करता है, इसलिए पूंछ को रिक्त स्थान के साथ हथौड़ा करना बेहतर होता है, अन्यथा पाठ बस दोहराएगा:

 ' ',~^:(8 - 8| # plaintext) plaintext

और अब हम टेक्स्ट को 8 अक्षरों के ब्लॉक में तोड़ देंगे।

 plaintext =: (8,~ >. 8 %~ #plaintext) $, ' ',~^:(8 - 8| # plaintext) plaintext

 plaintext =: 1!:1 < 'in.txt' plaintext =: (8,~ >. 8 %~ #plaintext) $, ' ',~^:(8 - 8| # plaintext) plaintext

परिणाम को एक फ़ाइल में लिखें।

स्पष्टीकरण

1!:21 फ़ाइल खोलता है, 1!:22 - बंद होता है, और 1!:2 फ़ाइल को लिखता है

 out =: 1!:21 < 'out.txt' ('habrhabr' encode"1 1 plaintext) 1!:2 out 1!:22 out

out.txt:

4acc c8ad 32dd 96a1 ae9c 2fdc 2025 e3d0 968c 97c0 5544 0944 2d20 2069 f943 f0d4 e98d bdea 71f9 c516 8a0a b034 5641 b0b5 53cc 2355 2fb1 4bde

और परिणाम को समझने की कोशिश करें।

  cipher =: 1!:1 < 'out.txt' cipher =: (8,~ >. 8 %~ #cipher) $, cipher , 'habrhabr' decode"1 1 cipher Lorem ipsum dolor sit amet consectetur adipiscing elit.

कोड सभी peystbin पर है ।

यदि आपके पास कोड के प्रश्न, सुझाव या सुधार हैं - टिप्पणियों में आपका स्वागत है।

आपका ध्यान देने के लिए आप सभी का धन्यवाद!

सौ लाइनों में जे

डेस क्या है?

जमीन तैयार करना

प्रारंभिक क्रमपरिवर्तन मैट्रिक्स पी

उलटा क्रमपरिवर्तन मैट्रिक्स पी -1

कुंजी जी के प्रारंभिक क्रमचय का मैट्रिक्स

केपी कुंजी क्रमचय मैट्रिक्स

एस पारी मैट्रिक्स

एक्सटेंशन मैट्रिक्स ई

P2 क्रमपरिवर्तन मैट्रिक्स (हाँ, DES में कई क्रमपरिवर्तन हैं)

एस परिवर्तन मैट्रिक्स

चलो व्यापार के लिए नीचे उतरो

More articles:

उलटा क्रमपरिवर्तन मैट्रिक्स पी ^-1

P2 क्रमपरिवर्तन मैट्रिक्स _{(हाँ, DES में कई क्रमपरिवर्तन हैं)}