Xxd आउटपुट को शेलकोड में बदलें

15

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

नियम

आपका सबमिशन एक फंक्शन, लैम्ब्डा, स्क्रिप्ट, या उनमें से कोई भी उचित समतुल्य हो सकता है। आप परिणाम प्रिंट कर सकते हैं, या यदि आपका सबमिशन एक फंक्शन / लैम्ब्डा है तो आप इसे वापस भी कर सकते हैं।

आपको प्रोग्राम में तीन तर्क देने होंगे, पहला xxd के आउटपुट से युक्त एक स्ट्रिंग होना चाहिए, एक फ़ाइल नाम के अलावा कोई तर्क नहीं है, जैसे xxd some_file:। यहां एक उदाहरण दिया गया है कि पहला तर्क कैसा दिखेगा:

00000000: 31c0 b046 31db 31c9 cd80 eb16 5b31 c088  1..F1.1.....[1..
00000010: 4307 895b 0889 430c b00b 8d4b 088d 530c  C..[..C....K..S.
00000020: cd80 e8e5 ffff ff2f 6269 6e2f 7368 4e58  ......./bin/shNX
00000030: 5858 5859 5959 59                        XXXYYYY

आपकी ज़रूरत है कि बाइट्स वाले मध्य खंड (पहले 8 कॉलम :) के बाद और इसे किसी भी व्हाट्सएप को हटाकर शेलकोड में बदल दिया जाए, फिर \xप्रत्येक बाइट के पहले एक डाल दिया जाए ।

यहां इनपुट के लिए आउटपुट क्या होना चाहिए (किसी अन्य तर्क की अनदेखी):

\x31\xc0\xb0\x46\x31\xdb\x31\xc9\xcd\x80\xeb\x16\x5b\x31\xc0\x88\x43\x07\x89\x5b\x08\x89\x43\x0c\xb0\x0b\x8d\x4b\x08\x8d\x53\x0c\xcd\x80\xe8\xe5\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x4e\x58\x58\x58\x58\x59\x59\x59\x59

आप मान सकते हैं कि पहला तर्क हमेशा एक वैध xxd आउटपुट होगा, फ़ाइल नाम के अलावा कोई तर्क नहीं दिया गया।

आपका आउटपुट एक स्ट्रिंग भी होना चाहिए जहां बैकस्लैश शाब्दिक बैकस्लैश हैं, जिनका उपयोग एस्केप वर्ण के रूप में नहीं किया जाता है। इसलिए जब मैं "\ x65" कहता हूं, तो मैं बाइट 0x65, या यहां तक ​​कि पत्र "ए" के बारे में बात नहीं कर रहा हूं। कोड में, यह स्ट्रिंग "\ x65" होगा।

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

यहाँ कुछ परीक्षण मामले हैं:

तर्क 1:

00000000: 31c0 b046 31db 31c9 cd80 eb16 5b31 c088  1..F1.1.....[1..
00000010: 4307 895b 0889 430c b00b 8d4b 088d 530c  C..[..C....K..S.
00000020: cd80 e8e5 ffff ff2f 6269 6e2f 7368 4e58  ......./bin/shNX
00000030: 5858 5859 5959 59                        XXXYYYY

तर्क 2:, 7तर्क 3: e(ये दोनों तंत्र हेक्साडेसिमल संख्याओं का प्रतिनिधित्व करते हैं)

आउटपुट: \xc9\xcd\x80\xeb\x16\x5b\x31\xc0

तर्क 1:

00000000: 31c0 b046 31db 31c9 cd80 eb16 5b31 c088  1..F1.1.....[1..
00000010: 4307 895b 0889 430c b00b 8d4b 088d 530c  C..[..C....K..S.
00000020: cd80 e8e5 ffff ff2f 6269 6e2f 7368 4e58  ......./bin/shNX
00000030: 5858 5859 5959 59                        XXXYYYY

तर्क 2:, 0तर्क 3:2e

आउटपुट: \x31\xc0\xb0\x46\x31\xdb\x31\xc9\xcd\x80\xeb\x16\x5b\x31\xc0\x88\x43\x07\x89\x5b\x08\x89\x43\x0c\xb0\x0b\x8d\x4b\x08\x8d\x53\x0c\xcd\x80\xe8\xe5\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x4e

तर्क 1:

00000000: 31c0 b046 31db 31c9 cd80 eb16 5b31 c088  1..F1.1.....[1..
00000010: 4307 895b 0889 430c b00b 8d4b 088d 530c  C..[..C....K..S.
00000020: cd80 e8e5 ffff ff2f 6269 6e2f 7368 4e58  ......./bin/shNX
00000030: 5858 5859 5959 59                        XXXYYYY

तर्क 2:, aतर्क 3:-1

आउटपुट: \xeb\x16\x5b\x31\xc0\x88\x43\x07\x89\x5b\x08\x89\x43\x0c\xb0\x0b\x8d\x4b\x08\x8d\x53\x0c\xcd\x80\xe8\xe5\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x4e\x58\x58\x58\x58\x59\x59\x59\x59

कम से कम बाइट्स वाला कोड जीतता है। विजेता की घोषणा सात दिनों में, 15 अगस्त 2016 को की जाएगी (लेकिन उसके बाद प्रस्तुतियाँ अभी भी सराही जाती हैं)।

अपडेट करें

चुनौती जीतने के लिए @ अदनान को बधाई !

code-golf  hexadecimal 
— एडिसन
स्रोत
बस स्पष्ट करने के लिए, क्या प्रविष्टियां एक स्ट्रिंग लौटा सकती हैं या उन्हें इसे प्रिंट करना चाहिए?
— जॉर्डन
एक स्ट्रिंग लौटना तब तक ठीक है जब तक कि यह एक फ़ंक्शन, लैम्ब्डा या ऐसा कुछ है (मैंने यह पूछने के बाद निर्दिष्ट करने के लिए नियमों को अद्यतन किया है)।
— Addison
1
क्या कोड प्रिंट होने पर हम नियमित ASCII कोड भी वापस कर सकते हैं? के ~बजाय \x7e। और क्या हम \tइसके बदले लौट सकते हैं \x09?
— orlp
@orlp क्षमा करें नहीं, इसे एक सुसंगत प्रारूप में होना चाहिए।
— Addison
क्या तर्क हेक्स में होना आवश्यक है? इसके अलावा, जिस तरह से आपने दूसरा उदाहरण दिया 7है, वह शून्य-आधारित सूचकांक की तरह दिखता है और eएक-आधारित सूचकांक है ( e-7=7लेकिन आपके आउटपुट में 8 हेक्स कोड हैं), या क्या मैं कुछ अनदेखी कर रहा हूं?
— नील

जवाबों:

5

05AB1E , 39 38 बाइट्स

फार्म में इनपुट:

arg2
arg3
arg1

कोड:

²\|vy9F¦}40£ðK}J2ô„\xì²H>²®Qi²}£¹HF¦}J

स्पष्टीकरण:

²\                                       # Get the first two inputs and discard them.
  |                                      # Take the rest of the input as an array.
   vy         }                          # For each line...
     9F¦}                                #   Ten times, remove the first character.
         40£                             #   Only remain the substring [0:40].
            ðK                           #   Remove spaces.
               J                         # Join the string.
                2ô                       # Split into pieces of 2.
                  „\xì                   # Prepend a "\x" at each string.
                      ²H                 # Convert the second line from hex to int.
                        >                # Increment by one.
                         ²               # Push the second input again.
                          ®Qi }          # If equal to -1...
                             ²           #   Push the second input again.
                               £         # Take the substring [0:(² + 1)].
                                ¹H       # Convert the first input from hex to int.
                                  F¦}    # Remove that many characters at the beginning.
                                     J   # Join the array and implicitly output.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत
12

बैश + कोरुटिल्स + xxd, 73 71 69 बाइट्स

printf \\x%s `xxd -r|xxd -p -s0x$1 -l$[(e=1+0x$2)?e-0x$1:-1]|fold -2`

एसटीडीआईएन पर हेक्सडंप की अपेक्षा करता है और कमांड-लाइन तर्कों के रूप में शुरू / समाप्त होता है।

यह STDERR को कुछ चेतावनी देता है, जो डिफ़ॉल्ट रूप से अनुमत है।

— डेनिस
स्रोत
1
मैं उम्मीद कर रहा था कि कोई वास्तव xxdमें उनके समाधान में उपयोग करेगा !
— Addison
@ एडिसन मैंने करने की कोशिश की, लेकिन मेरा लैंग कमांडलाइन इनपुट में नईलाइनों का समर्थन नहीं करता है। : c
— Addison Crump
मैं बदलने के लिए कर रहा हूँ 16#के साथ 0x?
— डिजिटल ट्रामा
@DigitalTrauma मुझे लगा कि यह एक xxdचीज़ है, लेकिन यह हर जगह काम करता है।
— डेनिस
1
हां, बॉक्स से बाहर 0xnहेक्स शैली और अष्ट0m शैली संख्या को बैश करें : gnu.org/software/bash/manual/bash.html#Shell-Arithmetic । echo $[0x2a] $[052]।
— डिजिटल ट्रामा
5

जावास्क्रिप्ट, 84 बाइट्स

(s,f,t,u)=>s.replace(/.*:|  .*\n?| /g,'').replace(/../g,'\\x$&').slice(f*4,++t*4||u)

स्पष्टीकरण: डंप के सभी अवांछित भागों को निकालता है, \xप्रत्येक हेक्स जोड़ी के लिए प्रस्तुत करता है, फिर परिणाम के वांछित हिस्से को निकालता है। पैरामीटर को ||uबढ़ाकर प्राप्त शून्य को परिवर्तित करने के लिए उपयोग किया जाता है जिसमें एक जादुई मूल्य होता है जो स्ट्रिंग के अंत में टुकड़ा करने का कारण बनता है। 101 बाइट्स यदि और हेक्स अंकों के तार हैं:-1undefinedsliceft

(s,f,t,u)=>s.replace(/.*:|  .*\n?| /g,``).replace(/../g,`\\x$&`).slice(`0x${f}`*4,t<0?u:`0x${t}`*4+4)
— नील
स्रोत
इसके बजाय (s,f,t,u)=>, आप s=>f=>t=>u=>कुछ बाइट्स को बचाने के लिए कर सकते हैं ।
— इस्माइल मिगेल
@IsmaelMiguel क्षमा करें, यह केवल दो वास्तविक मापदंडों के साथ एक फ़ंक्शन के लिए काम करता है। मेरे विशिष्ट मामले में uएक अतिरिक्त पैरामीटर होना चाहिए और इस पर अंकुश नहीं लगाया जा सकता है।
— नील
@IsmaelMiguel इसके अलावा वास्तव में लंबा है ...
— जैकब
5

रूबी: 90 89 87 79 63 बाइट्स

-2 बाइट्स
थैंक्स टू @addison -8 बाइट्स थैंक्स टू @PiersMainwaring

->s,x,y{'\x'+s.scan(/(?<=.{9})\w\w(?=.* )/)[x.hex..y.hex]*'\x'}

Repl.it पर परीक्षण देखें: https://repl.it/Cknc/5

— जॉर्डन
स्रोत
आप 2 बाइट्स को बचाने के .joinसाथ बदल सकते हैं *""।
— Addison
आप बदल सकते हैं .map{|h|h.to_i(16)}के साथ .map(&:hex)8 अधिक बाइट्स को बचाने के लिए!
— पीयर्सड्रियैन
धन्यवाद @PiersMainwaring! मुझे भुलाने के लिए मूर्खतापूर्ण। यह वास्तव में मुझे 16 बचा लिया क्योंकि यह .hexव्यक्तिगत रूप से तर्कों पर कॉल करने के लिए कम हो गया!
— जॉर्डन
4

जेली , 48 44 बाइट्स

ØhiЀɠ’ḅ¥®L’¤Ạ?⁴‘
ṣ⁷ṫ€⁵ḣ€40Fḟ⁶s©2ḣ¢ṫ¢[“\x”]p

यह पूरी तरह से कमांड लाइन तर्क के रूप में हेक्सडंप की अपेक्षा करता है, और एक क्रम में एसटीडीआईएन पर अंत और प्रारंभ बिंदुओं को एक लाइनफीड द्वारा अलग किया जाता है।

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
मुझे इसके लिए स्पष्टीकरण देखना अच्छा लगेगा;)
— कॉनर ओ'ब्रायन
मैं एक बाद में जोड़ दूँगा, लेकिन मैं इसे थोड़ा पहले गोल्फ करने की कोशिश करूँगा। 51 बेली जेली बनाम बश के 69 बाइट्स सही नहीं हो सकते ...
— डेनिस
3

PowerShell v2 +, 175 157 142 133 129 बाइट्स

param($a,$b,$c)'\x'+(($z=$a-split"`n"|%{$_[10..48]-ne32-join''-split'(..)'-ne''})["0x$b"..(("0x$c",$z.count)[$c-eq-1])]-join'\x')

ले जाता है इनपुट $a, $b, $c, साथ $aके रूप में या तो एक शाब्दिक न्यू लाइन से अलग की गई स्ट्रिंग, या PowerShell के साथ `nचरित्र लाइनों को अलग। हम हेल्पर स्ट्रिंग $zको इस $aप्रकार संसाधित करते हैं जैसे कि -

पहले हम -splitनई कथानकों पर, फिर, प्रत्येक पंक्ति के लिए |%{...}, हम मध्य भाग को स्लाइस करते हैं [10..48], -ne32रिक्त स्थान को हटाने के लिए उपयोग करते हैं , -joinयह एक साथ एक लंबी स्ट्रिंग में वापस आ जाता है, -splitयह हर दो वर्णों पर (दो वर्णों को रखते हुए), और-ne'' खाली तत्वों को निकालने के लिए। इसके परिणामस्वरूप दो-तत्व स्ट्रिंग्स की एक सरणी होती है, जैसे ('31','c0','b0'...)।

उसके बाद हम $bहेक्साडेसिमल ऑपरेटर के साथ कास्ट के आधार पर उस एरे में स्लाइस करते हैं $c। हमें यहां एक छद्म-त्रिशंकु का उपयोग करने की आवश्यकता है जो कि क्या $cहै -1या नहीं के लिए खाता है । यदि यह है, तो हम .count(यानी, अंतिम तत्व) का चयन करते हैं $z। अन्यथा, हम बस 0xहेक्साडेसिमल ऑपरेटर को $cएक स्ट्रिंग में प्रस्तुत करते हैं। ध्यान दें कि यह शून्य-अनुक्रमित है।

उस सरणी स्लाइस में -joinएक एलिमेंट के साथ \xएक स्ट्रिंग बनाने के लिए इसके तत्व एड होते हैं । यह एक और शाब्दिक के साथ तैयार किया गया है और \xपरिणाम पाइपलाइन पर छोड़ दिया गया है। मुद्रण निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\xxd-output.ps1 "00000000: 31c0 b046 31db 31c9 cd80 eb16 5b31 c088  1..F1.1.....[1..
00000010: 4307 895b 0889 430c b00b 8d4b 088d 530c  C..[..C....K..S.
00000020: cd80 e8e5 ffff ff2f 6269 6e2f 7368 4e58  ......./bin/shNX
00000030: 5858 5859 5959 59                        XXXYYYY" a -1
\xeb\x16\x5b\x31\xc0\x88\x43\x07\x89\x5b\x08\x89\x43\x0c\xb0\x0b\x8d\x4b\x08\x8d\x53\x0c\xcd\x80\xe8\xe5\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x4e\x58\x58\x58\x58\x59\x59\x59\x59
— AdmBorkBork
स्रोत
क्या आप इस भाषा के साथ शेल तक पहुँच सकते हैं?
— एडिसन क्रम्प
@VTCAKAVSMoACE सिद्धांत रूप में, लिनक्स के लिए नया विंडोज सबसिस्टम दिया गया है , कमांड लाइन के माध्यम से चीजों को एक साथ पाइप करना और / या पास करना संभव होना चाहिए। कार्यान्वयन पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है। ;-)
— AdmBorkBork
2

जेली , 39 38 37 बाइट्स

ØhiⱮɠ’ḅ¥ȷ9Ṃ?⁴‘
Ỵṫ€⁵ḣ€40Fḟ⁶s2ṭ€⁾\xḣ¢ṫ¢

इसे ऑनलाइन आज़माएं!

अब धड़कता है 05AB1E! ("हेक्साडेसिमल से कनवर्ट करें" बिलिन की कमी के बावजूद)

डेनिस समाधान के रूप में एक ही इनपुट प्रारूप ।

का उपयोग करें Ɱ, जो एक नई सुविधा है (के लिए कम Ѐ)। इसके बिना, यह 38 बाइट्स लेगा।

— user202729
स्रोत
केवल 1e9 तक लेन के साथ इनपुट के लिए काम करता है।
— user202729
लेकिन अगर यह FAT32 पर है (जहां इनपुट आकार अधिकतम 2GB है) यह पर्याप्त है।
— user202729
1

पर्ल, 114 बाइट्स

($_,$a,$b)=@ARGV;s/^.*:|\S*$|\s//gm;@_=(m/../g);for(@_){s/^/\\x/}$"='';say substr"@_",4*$a,$b!=-1?4*($a+$b):2<<20;

कमांड लाइन पर दिए गए तर्क एक उद्धृत स्ट्रिंग के रूप में दो संख्याओं के बाद। संख्या दशमलव में ली गई है (मुझे पता है कि हेक्स का उपयोग उदाहरणों में किया गया था लेकिन यह पोस्ट में निर्दिष्ट नहीं किया गया था)

तकनीकी रूप से केवल इनपुट पर काम करता है 2 ^ 21 बाइट्स के बाद से पर्ल के प्रतिस्थापन विधि मूर्खतापूर्ण है

— theLambGoat
स्रोत
जाहिरा तौर पर रेंज समावेशी है, इसलिए उदाहरण के 7लिए eलंबाई 32 की एक स्ट्रिंग में परिणाम होना चाहिए।
— नील
1

अजगर, 140 बाइट्स

lambda O,a,b:''.join(sum([['\\x'+x[:2],('','\\x')[len(x)>2]+x[2:]]for x in O.split()if len(x)<5],[])[int(a,16):(int(b,16)+1,None)[b=='-1']])

https://repl.it/ClB3

मूल स्ट्रिंग को विभाजित करता है और तत्वों को डुबोता है यदि वे पांच वर्णों से कम हैं, तो प्रीपेंड होते हैं \x तो दूसरे और तीसरे तर्क से और स्लाइस करते हैं।

162 बाइट संस्करण अगर हमें प्रश्न द्वारा निर्दिष्ट अन्य प्रकार के आउटपुट को संभालने की आवश्यकता है:

import re
J=''.join
def f(x,a,b):r=J(J(re.findall(':(.*?)  ',x)).split());print J(['\\x'+i+j for i,j in zip(r,r[1:])][::2][int(a,16):(int(b,16)+1,None)[b=='-1']])
— atlasologist
स्रोत
यह काम नहीं करेगा, उदाहरण के लिए, अंतिम पंक्ति कुछ ऐसी है 00000030: 5858 58 XXXक्योंकि यह अंतिम भाग को बाहर निकालेगी और आपको कुछ ऐसा मिलेगा \x58\x58\x58\xXX\xX।
— AdmBorkBork
@TimmyD मुझे नहीं लगा कि चुनौती को संभालने के लिए इस मामले को संभालने की जरूरत है।
— एटलसोलॉजिस्ट
मैं चुनौती को पढ़ता हूं क्योंकि दिए गए पहले तर्क सिर्फ एक उदाहरण है, इसलिए xxdतर्क के बजाय अन्य आउटपुट का उपयोग किया जा सकता है । "यहाँ एक उदाहरण है कि पहला तर्क क्या दिखेगा:"
— AdmBorkBork
0

अजगर 2 और 3 - 164 162 150 146 134 150 बाइट्स

अब दूसरे और तीसरे तर्कों के लिए हेक्स स्ट्रिंग्स को स्वीकार करता है।

j=''.join
def f(a,b,c):s=j(x[10:49].replace(' ','')for x in a.split('\n'));print(j('\\x'+s[i:i+2]for i in range(int(b,16)*2,1+2*int(c,16)%len(s),2))
— ceilingcat
स्रोत
0

पायथन 3.5, 125 बाइट्स

import re
lambda s,b,e:re.sub(r'(\w\w)',r'\\x\1',re.sub(r'^.*?:|  .*$|\s','',s,0,8)[2*int(b,16):[2*int(e,16)+2,None][e<'0']])

Ungolfed:

def f(s,b,e):
    b = 2*int(b,16)
    e = [2*int(e,16)+2,None][e<'0']
    x = re.sub(r'''(?v)   # verbose (not in golfed version)
            ^.*?:     # match begining of line to the ':'
           |  .*$     # or match '  ' to end of line
           |\s        # or match whitespace
           ''',
           '',        # replacement
           s,
           0,         # replace all matches 
           re.M       # multiline mode
           )
    y = re.sub(r'(\w\w)', # match pairs of 'word' characters
           r'\\x\1',  # insert \x
            x[b:e])
    return y
— RootTwo
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.