निम्नलिखित विनिर्देश दिए गए डेटा को एन्क्रिप्ट और डिक्रिप्ट करने के लिए एक प्रोग्राम या फ़ंक्शन (या प्रोग्राम / फ़ंक्शन का सेट) लिखें:

एन्क्रिप्शन

XOR-ing द्वारा इनपुट की एक XOR हैश की गणना प्रत्येक बाइट को एक-दूसरे के साथ करें।
इस हैश द्वारा इनपुट के हर बाइट XOR।
परिणाम चार बिट छोड़ दिया है।
XOR हैश के पहले चार बिट्स के साथ बाईं ओर पैड।
XOR हैश के अंतिम चार बिट्स के साथ दाईं ओर पैड।

उदाहरण

दिए गए इनपुट: "G0lf"( 0x47306C66)
गणना XOR हैश: 0x47 ^ 0x30 ^ 0x6C ^ 0x66 = 0x7D
XOR हर बाइट हैश द्वारा: 0x3A4D111B
अपेक्षित परिणाम (शिफ्ट और पैड के बाद): "s¤Ñ\x11½"( 0x73A4D111BD)

नियम

जब तक इनपुट / आउटपुट वास्तविक बाइट्स होते हैं, तब तक आपका प्रोग्राम / फंक्शन इनपुट / आउटपुट को आपकी पसंद की गोल्फ भाषा (स्ट्रिंग, बाइट एरे, आदि) से समझ सकता है । उदाहरण के लिए, आप हेक्सिडेसिमल स्ट्रिंग का उत्पादन नहीं कर सकते हैं।
एन्क्रिप्शन और डिक्रिप्शन को अलग-अलग कार्यक्रमों में विभाजित किया जा सकता है (स्कोर उनका संयुक्त आकार होगा) या एकल। एकल विधियाँ इस बात के लिए तर्क दे सकती हैं कि इसे एन्क्रिप्ट या डिक्रिप्ट करना चाहिए।
एन्क्रिप्शन के लिए इनपुट से आकार में कम से कम 1 बाइट होने की उम्मीद की जा सकती है।
डिक्रिप्शन के लिए इनपुट कम से कम 2 बाइट्स होने की उम्मीद की जा सकती है।
गैर-मुद्रण योग्य बाइट्स को आउटपुट में भागने की आवश्यकता नहीं है।

code-golf cryptography bitwise

— nderscore
स्रोत

1

क्या दशमलव सरणी का उपयोग आउटपुट फॉर्म के रूप में किया जा सकता है?

— atı 17uʎs

@ toı takeuʎs बाइट का प्रतिनिधित्व करने के लिए पूर्णांकों की एक सरणी के रूप में इनपुट और आउटपुट लेना स्वीकार्य होगा।

— nderscore

क्या अधिकतम इनपुट लंबाई है (उदाहरण के लिए, 14 बाइट्स (56 बिट्स), ताकि अंतिम परिणाम 64-बिट पूर्णांक में फिट हो जाए)?

— दरवाज़े

1

बस एक नोट: क्रिप्टोग्राफी के दृष्टिकोण से यह एक एन्क्रिप्शन नहीं है, क्योंकि इसमें कोई कुंजी नहीं है (या 0-बिट कुंजी)।

— पाओलो एबरमन

1

मैं बस किसी को अपने स्वयं के एन्क्रिप्शन को रोल करने के बारे में कुछ पोस्ट करने के लिए इंतजार कर रहा हूं, इस साइट को अनदेखा कर रहा है ...

— user253751

9

CJam, 28 + 27 = 55 बाइट्स

प्रत्येक भाग के लिए मैं एक प्रोग्राम प्रस्तुत कर रहा हूँ जो इनपुट / आउटपुट को पूर्णांक सरणी के रूप में और एक स्ट्रिंग का उपयोग करने की अपेक्षा करता है। उपरोक्त बाइट गिनती पूर्णांक सरणी संस्करण के लिए है, लेकिन लिंक की गई स्क्रिप्ट और स्पष्टीकरण स्ट्रिंग-आधारित संस्करण के लिए हैं (जिसका उपयोग प्रश्न में दिए गए उदाहरण का परीक्षण करने के लिए किया जा सकता है)।

एन्क्रिप्शन

q~_:^_GbYUe[\@f^Gfbe_*2/Gfbp
q:i_:^_GbYUe[\@f^Gfbe_*2/Gfb:c

डिक्रिप्शन

q~{_G/\G%}%)\(G*@+\2/Gfbf^p
q:i{_G/\G%}%)\(G*@+\2/Gfbf^:c

यहां एक परीक्षण स्क्रिप्ट है जो एक पूर्ण राउंड ट्रिप करती है और डिक्रिप्शन कोड को फिर से डिक्रिप्शन करने से पहले प्रिंट करती है।

व्याख्या

q:i_:^_GbYUe[\@f^Gfbe_*2/Gfb:c
q:i                            e# Read the input and convert characters to byte values.
   _:^                         e# Duplicate and fold XOR onto the characters to get 
                               e# the hash.
      _Gb                      e# Duplicate and convert to base 16 to get nibbles.
         YUe[                  e# Pad to width 2 with zeroes.
             \@                e# Pull up other copy and integer array.
               f^              e# XOR each integer with the hash.
                 Gfbe_         e# Convert each result to base 16 and flatten that.
                      *        e# Join the hash nibbles with this array.
                       2/      e# Split into pairs.
                         Gfb   e# Interpret each pair as base 16.
                            :c e# Convert each integer to a character.

q:i{_G/\G%}%)\(G*@+\2/Gfbf^:c
q:i                            e# Read the input and convert characters to byte values.
   {      }%                   e# Map this block onto each byte.
    _G/\G%                     e# Get the two base 16 digits individually.
            )\(                e# Slice off the last and first nibble.
               G*@+\           e# Combine into byte (the hash) and swap with array.
                    2/Gfb      e# Split array into pairs and interpret each as base 16.
                         f^    e# XOR each with the hash.
                           :c  e# Convert each integer to a character.

— मार्टिन एंडर
स्रोत

6

CJam, 36 + 34 = 70 बाइट्स

बाइनरी रूपों का उपयोग करके थोड़ा अलग दृष्टिकोण

एनक्रिप्ट :

q_:^:Hf^H+{i2b8Ue[}%)4/~@\]e_8/2fb:c

यह काम किस प्रकार करता है:

q_:^                                  e# Read input as string, copy and XOR all the chars
    :Hf^                              e# Store the XOR in H and XOR each char with H
        H+                            e# Append H to the char array
          {       }%                  e# On each of the elements in the array
           i2b                        e# Convert the ASCII value to binary
              8Ue[                    e# Pad with 0 so that the length is 8
                    )                 e# Pop out the last array element, which is H
                     4/~@\            e# Put first 4 bits of H before the input array
                                      e# And rest 4 after it
                          ]e_8/       e# Flatten everything into a single array and group
                                      e# into pieces of 8 bits
                               2fb:c  e# Convert each 8 bit part to integer and then to
                                      e# its character form

डिक्रिप्टर :

q{i2b8Ue[4/~}%)\(@+2b\:+8/2fb\f^:c

यह काम किस प्रकार करता है:

q{          }%                      e# For each character of the input string
  i2b                               e# Convert to ASCII code and then to its binary form
     8Ue[                           e# Pad with enough 0 so that length is 8 bit
         4/~                        e# Split into parts of 4 and unwrap
              )\(@+                 e# Take out the first and last 4 bit group and join
                                    e# them together to get the XOR Hash H
                   2b\              e# Convert H to decimal form and swap to put the
                                    e# remaining converted input array on top
                      :+8/          e# Join all bits together and split into groups of 8
                          2fb       e# Convert each 8 but group to decimal form
                             \f^    e# Swap to put H on top and XOR each number with H
                                :c  e# Get character from each of the ASCII value

ऑनलाइन एन्क्रिप्ट और डिक्रिप्टर की कोशिश करो

— अनुकूलक
स्रोत

6

पायथ, 69 बाइट्स

Ksm>+0jCd16_2zJ?,hKeKQmxFdCcK2=KsmmxFkC,dJc?tPKQK2smCid16c?KQ++hJKeJ2

यह एन्क्रिप्शन और डिक्रिप्शन को जोड़ती है, बस 0एन्क्रिप्शन या 1डिक्रिप्शन के लिए तर्क के रूप में जोड़ें । इतना सरल होने का कारण। स्ट्रिंग्स को बिट्स (या 4 बिट पूर्णांक) या रिवर्स में परिवर्तित करना वास्तव में पाइथ में बहुत लंबा है। दोनों फ़ंक्शन को एक कार्यक्रम में जोड़कर, मैं बहुत सारे बाइट्स बचा सकता हूं।

ऑनलाइन प्रदर्शन: एन्क्रिप्शन और डिक्रिप्शन ।

स्पष्टीकरण:

पहला भाग इनपुट को 4-बिट पूर्णांक की सूची में परिवर्तित करता है (प्रत्येक चार को 2 4-बिट पूर्णांक में परिवर्तित किया जाता है) और इसमें स्टोर होता है K।

  m          z   map each character d of input (=z) to:
       Cd            the ascii-value of d
      j  16          convert the result into base 16
   >+0     _2        insert a zero to the front and take the last 2 values
                     (so that each char gets mapped to exactly 2 numbers)
Ks               chain all these tuples and assign them to K

दूसरा भाग हैश मूल्यों को निर्धारित करता है और उन्हें स्टोर करता है J। यदि Q==0यह उन्हें xor द्वारा गणना करता है, अन्यथा यह पहले और अंतिम मूल्य को लेता है K।

 ?     Q           ... if Q (=second input) else ...
  ,hKeK            [K[0], K[-1]]
        m   CcK2   map each d of zipped(K chopped into pairs) to:
                   [zipped(...) gives me 2 lists, one with the values of the even indices, and one with the odd indices]
         xFd           fold the list d by xor
J                  store the result in J (this is the hash value)

अगला भाग हैश मानों का उपयोग करके xor करता है। जब Q == 0यह पूरी सूची पर किया जाता है K, तो केवल Kपहले और अंतिम मूल्य के बिना सूची में ।

=KsmmxFkC,dJc?tPKQK2
             ?tPKQK    K[1:-1] if Q else K 
   m        c      2   map each d of [... chopped into pairs] to:
    m   C,dJ              map each pair k of zip(d,J) to:
     xFk                     apply xor to the 2 values in k
=Ks                    chain all these tuples and assign them to K

और अंतिम भाग Kवापस चार्ट में बदल जाता है:

smCid16c?KQ++hJKeJ2
        ?KQ++hJKeJ    K if Q else J[0] + K + J[1]
 m     c          2   map each pair of [... chopped into pairs] to:
   id16                  convert d into a single integer
  C                      convert to char
s                     join all chars and print

— Jakube
स्रोत

0

जावास्क्रिप्ट ( ES6 ) 83 + 73 = 156

दोनों फ़ंक्शन बाइट्स का प्रतिनिधित्व करने के लिए इनपुट के रूप में और संख्याओं की एक श्रृंखला के रूप में इनपुट लेते हैं।

85 84 83 को एन्क्रिप्ट करें

E=s=>s.concat((h=s.reduce((x,y)=>x^y))<<4&240^h).map(x=>a<<4&240|(a=x^h)>>4,a=h>>4)

डिक्रिप्ट 75 73

D=s=>s.map(x=>(a<<4&240|(a=x)>>4)^h,h=(a=s.shift())&240|s[~-s.length]&15)

प्रदर्शन (केवल फ़ायरफ़ॉक्स)

E=s=>s.concat((h=s.reduce((x,y)=>x^y))<<4&240^h).map(x=>a<<4&240|(a=x^h)>>4,a=h>>4)
D=s=>s.map(x=>(a<<4&240|(a=x)>>4)^h,h=(a=s.shift())&240|s[~-s.length]&15)

toHexString = x=>'0x'+x.map(y=>y.toString(16)).join('')

input = [...'G0lf'].map(x=>x.charCodeAt());
document.write('Input: ' + toHexString(input) + '<br />');

encrypted = E(input);
document.write('Encrypted: ' + toHexString(encrypted) + '<br />');

decrypted = D(encrypted);
document.write('Decrypted: ' + toHexString(decrypted) + '<br />');

स्निपेट का विस्तार करें

स्ट्रिंग्स 131 + 129 = 260 का उपयोग करना

और सिर्फ मनोरंजन के लिए ... यहाँ कुछ संस्करण हैं जो इनपुट / आउटपुट के लिए तार का उपयोग करते हैं।

E=(s,h=0)=>[for(x of s)(h^=y=x.charCodeAt(),y)].concat(h<<4&240^h).map(x=>String.fromCharCode(a<<4&240|(a=x^h)>>4),a=h>>4).join('')

D=s=>(s=[s.charCodeAt(j=i)for(i in s)]).map(x=>String.fromCharCode((a<<4&240|(a=x)>>4)^h),h=(a=s.shift())&240|s[~-j]&15).join('')

E('G0lf') // 's¤Ñ\x11½'
D('s¤Ñ\x11½') // 'G0lf'