सिफरबेसर एन्क्रिप्शन

Question

जैसा कि नीचे वर्णित है, एक सिफरसेबर एन्क्रिप्शन प्रोग्राम लागू करें। दिशानिर्देश:

• बाइट्स में सबसे छोटी प्रविष्टि, जीतती है।
  • हालांकि, कोड-गोल्फ मानदंडों से प्रस्थान में , आपको दिलचस्प प्रविष्टियों को पोस्ट करने का स्वागत है, भले ही वे गंभीर गोल्फ प्रविष्टियां न हों।
• एक प्रविष्टि आम तौर पर एक प्रोग्राम होता है जो मानक इनपुट से प्लेटेक्स्ट लेता है, और मानक आउटपुट के लिए सिफरटेक्स्ट लिखता है, जिसमें कुंजी (उपयोगकर्ता द्वारा) निर्दिष्ट की जाती है।
  • हालाँकि, यदि आप इसे एक प्रक्रिया के रूप में लागू करना चाहते हैं, तो यह ठीक है।
• IV को एक क्रिप्टोग्राफिक रूप से सुरक्षित छद्म आयामी संख्या जनरेटर से आना चाहिए। यदि आपकी भाषा का समर्थन नहीं करता है, तो एक अलग चुनें। ;-)
• कृपया किसी भी क्रिप्टो-विशिष्ट लाइब्रेरी, सिस्टम कॉल या निर्देश (PRNG के अलावा अन्य, जैसा कि ऊपर लिखा गया है) का उपयोग न करें। बेशक, सामान्य निम्न-स्तरीय बिटवाइज़ ऑपरेशन ठीक हैं।

CipherSaber RC4 / Arcfour का एक प्रकार है, इसलिए मैं बाद का वर्णन करके शुरू करूँगा, फिर CipherSaber परिवर्तन करता है।

0. RC4 / Arcfour

Arcfour पूरी तरह से कहीं और निर्दिष्ट है , लेकिन पूर्णता के लिए, मैं यहां इसका वर्णन करूंगा। (इंटरनेट-ड्राफ्ट और इस विवरण के बीच किसी भी विसंगतियों के मामले में, पूर्व मानक है।)

कुंजी सेटअप

दो सरणियों को सेट करें, Sऔर S2, दोनों की लंबाई 256, जहां k_1कुंजी की पहली बाइट है, और k_nअंतिम है।

S = [0, ..., 255]
S2 = [k_1, ..., k_n, k_1, ...]

( S2कुंजी के बाइट्स के साथ बार-बार भरा जाता है, जब तक कि सभी 256 बाइट्स भर न जाएं।)

फिर, j0 से आरंभ करें, और 256 बार फेरबदल करें:

j = 0
for i in (0 .. 255)
    j = (j + S[i] + S2[i]) mod 256
    swap S[i], S[j]
end

यह कुंजी सेटअप पूरा करता है। S2सरणी नहीं रह गया है यहां इस्तेमाल किया जाता है, और झाड़ी जा सकता है।

सिफर स्ट्रीम जनरेशन

प्रारंभिक iऔर j0 के लिए, फिर निम्न के रूप में कुंजी स्ट्रीम उत्पन्न करें:

i = 0
j = 0
while true
    i = (i + 1) mod 256
    j = (j + S[i]) mod 256
    swap S[i], S[j]
    k = (S[i] + S[j]) mod 256
    yield S[k]
end

डेटा एन्क्रिप्ट / डिक्रिप्ट करना

• एन्क्रिप्ट करने के लिए, सादे के साथ कीस्ट्रीम आउटपुट को XOR करें
• डिक्रिप्ट करने के लिए, सिफर के साथ कीरस्ट्रीम आउटपुट को XOR करें

1. सिफरसाबेर

CipherSaber (जो हम इस प्रश्न में लागू कर रहे हैं) RC4 / Arcfour के दो तरीकों से भिन्नता है:

10-बाइट IV / गैर

किसी संदेश को एन्क्रिप्ट करते समय, 10 यादृच्छिक बाइट्स प्राप्त किए जाने चाहिए, जैसे कि के माध्यम से /dev/urandom, और एन्क्रिप्टेड आउटपुट के पहले 10 बाइट्स में लिखा जाना चाहिए। किसी संदेश को डिक्रिप्ट करते समय, इनपुट के पहले 10 बाइट्स IV होते हैं जो इसे एन्क्रिप्ट करने के लिए उपयोग किए जाते हैं।

RC4 / Arcfour कुंजी सेटअप चरण कुंजी के साथ चलाया passphrase || IVजाता है, जहां passphraseउपयोगकर्ता द्वारा निर्दिष्ट पासफ़्रेज़ है, IVजैसा कि ऊपर वर्णित है, और ||समवर्ती है। तो, "नमस्ते, दुनिया!" का पासफ़्रेज़ और "सुपरक्लिफ़" का एक IV (हालांकि इसकी संभावना नहीं है :-P) "हैलो, दुनिया! सुपरफ़ेल्ट" की कुंजी का परिणाम होगा।

कुंजी सेटअप के एकाधिक पुनरावृत्तियों

WEP एन्क्रिप्शन को पूरी तरह से तोड़ने वाले भेद्यता को रोकने में मदद करने के लिए, RC4 के प्रमुख सेटअप चरण के फेरबदल लूप को उपयोगकर्ता द्वारा निर्दिष्ट संख्या में चलाया जाता है। jपुनरावृत्तियों के बीच का मान रखा जाना चाहिए।

2. परीक्षण वैक्टर

यहाँ कुछ परीक्षण वैक्टर हैं जिनका उपयोग आप अपने कार्यक्रमों का परीक्षण करने के लिए कर सकते हैं। इसके अलावा, स्क्विश ओस्सिफ्रेज ने एक सिफरबेस एन्क्रिप्शन और डिक्रिप्शन उपकरण बनाया है जिसका उपयोग आप अपने परिणामों को मान्य करने के लिए कर सकते हैं।

आपको केवल एन्क्रिप्शन प्रोग्राम को लागू करने की आवश्यकता है। आपको डिक्रिप्शन प्रोग्राम को आपूर्ति करने की आवश्यकता नहीं है, लेकिन सही तरीके से लागू डिक्रिप्शन प्रोग्राम के साथ सही कुंजी का उपयोग करने पर संसाधित होने पर आपके एन्क्रिप्शन प्रोग्राम के आउटपुट को मूल इनपुट तक सही ढंग से राउंडट्रिप करना होगा।

Answer 1

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

$import os$KsM$os.urandom(10)$JuuXN@LN,T=+Z+@NT@+CMzKT)bGQU=b256=Z0sCM+K.exCb@=XJ=N@LJ,hk=+Z@Jhk)sNw

यह स्क्रिप्ट $कमांड का उपयोग करता है , जो पायथन कोड को निष्पादित करने की अनुमति देता है। सर्वर पर दुर्भावनापूर्ण कोड को निष्पादित करने से रोकने के लिए, यह कमांड ऑनलाइन कंपाइलर में अक्षम है। आपको इसे ऑफ-लाइन कंपाइलर के साथ चलाना होगा जिसे आप यहां पा सकते हैं ।

इनपुट प्रारूप में है:

secret key
5 (number of repeats)
secret message

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

$import os$KsM$os.urandom(10)$JuuXN@LN,T=+Z+@NT@+CMzKT)bGQU=b256=Z0         
jdm.[2.HCd`0
sCM+K.exCb@=XJ=N@LJ,hk=+Z@Jhk)sNw

पायथ क्रिप्टोग्राफिक रूप से सुरक्षित छद्म आयामी संख्याओं का समर्थन नहीं करता है और पायथन से उन्हें 25 बाइट्स का आयात करता है। एक छोटा कोड, जो Pyth / Python के नॉर्म्स को pseudorandom-नंबर जनरेटर का उपयोग करता है और ऑनलाइन बॉयलर में भी काम करता है:

KmO=b256TJuuXN@LN,T=+Z+@NT@+CMzKT)bGQUb=Z0sCM+K.exCb@=XJ=N@LJ,hk=+Z@Jhk)sNw

इसे ऑनलाइन आज़माएं: एक स्ट्रिंग या हेक्साडेसिमल अंकों की एक श्रृंखला वापस करना

कोड कुछ खास नहीं है। बस बहुत सारे गंदे असाइनमेंट और गणना परिणामों के तत्काल पुन: उपयोग और सूची-स्वैप ट्रिक को दो बार लागू करना ।

स्पष्टीकरण:

                                  implicit: z = 1st input (= key string)
                                  Q = 2nd input (number of repetitions)
$import os$KsM$os.urandom(10)$
$import os$                       import Python's os module
              $os.urandom(10)$    create 10 cryptographically secure 
                                  pseudo-random bytes
            sM                    convert them to ints
           K                      store them in K

JuuXN@LN,T=+Z+@NT@+CMzKT)bGQU=b256
                             =b256assign b with 256
 u                         QUb    start with G = [0, 1, ..., 255], 
                                  evaluate the following expression Q times and
                                  update G with the result each time:
  u                      bG         start with N = G, 
                                    for each T in [0, 1, ..., 255] evaluate the
                                    following expression and update N each time:
                   CMz                convert key to list of ints
                  +   K               extend it with K
                 @     T              take the Tth element (modulo length)
              @NT                     take the Tth element of N
             +                        add these two values
           +Z                         add Z (with is initially 0)
          =                           and update Z with the result
        ,T  Z                         make the pair of indices [T, Z] 
     @LN                              look-up their values in N
   XN                   )             and switch these two values in N
J                                 assign the result (the key setup) to J

=Z0                               set Z to 0

sCM+K.exCb@=XJ=N@LJ,hk=+Z@Jhk)sNw 
                                w read a string from input (message)
     .e                           map each index k, char b in message to:
                         @Jhk       look-up the (k+1)th element in J
                      =+Z           add it to Z and update Z
                   ,hk  Z           make the pair of indices [k+1,Z]
                @LJ                 look-up their values in J
              =N                    assign the result to N
            XJ N             )      swap these values in J
           =                        and update J with the result
          @  J                sN    take the sum(N)th element of J
        Cb                          convert b to int
       x                            bitwise xor of these two elements
   +K                             insert K at the beginning
 CM                               convert each element to char
s                                 sum them (generate a string)
                                  implicitly print

Comments

जाहिर है, अंतर्निहित Pyth फ़ंक्शन में क्रिप्टोग्राफिक रूप से सुरक्षित छद्म आयामी संख्याएं नहीं होती हैं । आप अपनी प्रविष्टि को इस प्रकार रख सकते हैं, और यह हरे रंग की टिक के लिए अर्हता प्राप्त नहीं करेगा, या आप एक ऐसा संस्करण बना सकते हैं जो उपयोग करता है urandom(यदि आप चाहें तो एक अलग प्रविष्टि हो सकती है) यदि आप "जीतने" की परवाह करते हैं। :-)

— क्रिस जस्टर-यंग

@ क्रिसजेस्टर-यंग को इस बारे में खेद है। मैंने नहीं सोचा था कि पायथन का रैंडम-नंबर जनरेटर इतना असुरक्षित है। इसे 25 बाइट की लागत से ठीक किया।

— जकुबे

Answer 2

पायथन 2 - 373 350 326 317 बाइट्स

संभवत: बाद में पाइथ। एक फ़ंक्शन को परिभाषित करता है, c(p,d,r,m)जो पासफ़्रेज़ और डेटा के लिए बाइट सूचियों को लेता है, और दोहराव और मोड के लिए int जो 1 से कम होने पर एन्क्रिप्ट करता है और 0. जब यह होता है, क्योंकि यह केवल उनमें अंतर IV के साथ काम कर रहा है। बाइट सूची लौटाता है।

import os
B=256
def c(p,d,r,m):
    if m:v=map(ord,os.urandom(10))
    else:v,d=d[:10],d[10:]
    p+=v;S=range(B);T=(p*B)[:B];j=0;exec"for i in range(B):j=(j+S[i]+T[i])%B;S[i],S[j]=S[j],S[i]\n"*r;o=[];i=j=0
    for b in d:i=-~i%B;j=(j+S[i])%B;S[i],S[j]=S[j],S[i];k=(S[i]+S[j])%B;o+=[S[k]^b]
    return v+o if m else o

यहाँ कुछ परीक्षण कोड / सहायक कार्य हैं:

phrase = "hello"
text = "Mary had a little lamb, little lamb, little lamb"
N = 5

def make_bytes(string):
    return map(ord, string)

def make_string(bytes):
    return "".join(map(chr, bytes))

def make_hex(bytes):
    return " ".join("%02x" % i for i in bytes)

def from_hex(hex_str):
    return [int(i, 16) for i in hex_str.split()]

cipher = c(make_bytes(phrase), make_bytes(text), N, 1)
print make_hex(cipher)
plain = c(make_bytes(phrase), cipher, N, 0)
print make_string(plain)

Comments

आपको केवल एक एन्क्रिप्शन प्रोग्राम लिखना होगा। तो आप else:v,d=d[:10],d[10:]हिस्सा निकाल सकते हैं ।

— जुलुब

Answer 3

रूबी - 263 वर्ण

यह 2010 में वापस स्टैकओवरफ्लो पर मूल प्रश्न का मेरा रूबी जवाब है! यह एक प्रोग्राम में एक एनकोडर और डिकोडर है

पैरामीटर हैं:
ई या (एनकोड या डीकोड के लिए) घ
कुंजी
समय की संख्या

$ ruby saber.rb e gnibbler 10 < in.txt | ruby saber.rb d gnibbler 10

o,k,l=ARGV;print o<'e'?(v=STDIN.read(10))*0:v=(0..9).map{rand(256).chr}.join;j=0;E=255
S=Array 0..255;(S*l.to_i).each{|i|j=j+S[i]+((k+v)*E)[i].ord&E;S[i],S[j]=S[j],S[i]};i=j=0
STDIN.each_byte{|c|i=i+1&E;j=j+S[i]&E;S[i],S[j]=S[j],S[i];print (c^S[S[i]+S[j]&E]).chr}

Answer 4

सी, 312 बाइट्स

कमांड लाइन पर एक कुंजी और कुंजी मिश्रण पुनरावृत्ति गणना को स्वीकार करता है, फिर स्टडआउट पर सब कुछ stdout को एन्क्रिप्ट करता है। यह BSD / डार्विन लाइब्रेरी फ़ंक्शन का उपयोग करता है arc4random(), जो RC4 पर आधारित PRNG है। यह स्वचालित रूप से खुद को बीज देता है, इसलिए परिणाम हर बार अलग होंगे।

unsigned char n,i,j,q,x,t,s[256],k[256];main(int c,char**v){for(strcpy(k,v[1]),n=strlen(k);x<10;x++)putchar(k[n++]=arc4random());do{s[i]=i;}while(++i);for(x=atoi(v[2]);x--;)do{t=s[i];s[i]=s[j+=s[i]+k[i%n]];s[j]=t;}while(++i);for(;(c=getchar())>0;){q+=s[++i];t=s[i];s[i]=s[q];s[q]=t;t=s[i]+s[q];putchar(c^s[t]);}}

Tidier संस्करण:

unsigned char n,i,j,q,x,t,s[256],k[256];
main(int c,char**v) {
  for (strcpy(k,v[1]),n=strlen(k);x<10;x++) putchar(k[n++]=arc4random());
  do {
    s[i]=i;
  }
  while(++i);
  for (x=atoi(v[2]);x--;) do {
    t=s[i];
    s[i]=s[j+=s[i]+k[i%n]];
    s[j]=t;
  }
  while (++i);
  for (;(c=getchar())>0;) {
    q+=s[++i];
    t=s[i];
    s[i]=s[q];
    s[q]=t;
    t=s[i]+s[q];
    putchar(c^s[t]);
  }
}

उदाहरण:

$ echo -n 'Ciphersaber' | ./csgolf 'hello' 20 | xxd -p
0f6257c330e5e01c3eab07bc9cb4ee4c3eaa514a85

Answer 5

अजगर - 266 वर्ण

यह 2010 में वापस स्टैकओवरफ़्लो पर मूल प्रश्न का मेरा पायथन उत्तर है! यह एक प्रोग्राम में एक एनकोडर और डिकोडर है

पैरामीटर हैं:
ई या (एनकोड या डीकोड के लिए) घ
कुंजी
समय की संख्या

$ python saber.py e gnibbler 10 < in.txt | python saber.py d gnibbler 10

यह संस्करण rc4 के 2 छोरों को एक में मिलाने का प्रयास करता है (अब तक 11 बाइट्स बचाता है ...)

import os,sys;X,Y=sys.stdin.read,os.write;_,o,k,l=sys.argv;p='d'<o
V=(X,os.urandom)[p](10);Y(1,V*p);E,S=255,range(256)
for q in S*int(l),X():
 t=q<'';j=0;i=-t
 for c in q:i=i+1&E;j=j+S[i]+t*ord(((k+V)*E)[i])&E;S[i],S[j]=S[j],S[i];t or Y(1,chr(ord(c)^S[S[i]+S[j]&E]))