Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

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

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
machofile — machofile एक मॉड्यूल है जो Mach-O बाइनरी फ़ाइलों को पार्स करने के लिए है | Kitploit
उपकरण/GitHubGitHub/pstirparo/machofile
स्थैतिक विश्लेषणरिवर्स इंजीनियरिंगफोरेंसिकमालवेयर विश्लेषणबाइनरी विश्लेषण
GitHubpstirparo/machofile

machofile

machofile एक मॉड्यूल है जो Mach-O बाइनरी फ़ाइलों को पार्स करने के लिए है

रिपॉजिटरी देखें
99547 महीने पहलेKitploit द्वारा समीक्षित

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
वेबसाइट
साझा करें

machofile

Downloads

machofile एक मॉड्यूल है जो Mach-O बाइनरी फ़ाइलों को पार्स करता है, जिसमें मैलवेयर विश्लेषण और रिवर्स इंजीनियरिंग पर विशेष ध्यान दिया गया है।

Ero Carrera के pefile से प्रेरित होकर, यह मॉड्यूल समान क्षमताएँ प्रदान करने का लक्ष्य रखता है, लेकिन Mach-O बाइनरी के लिए। फ़ाइल प्रारूप ज्ञान, मूल संरचनाओं और स्थिरांकों को प्राप्त करने के लिए उपयोग की गई संदर्भ सामग्री और दस्तावेज़ नीचे सूचीबद्ध संसाधनों से लिए गए हैं।

machofile स्व-निहित है। इस मॉड्यूल की कोई निर्भरता नहीं है; यह एंडियननेस से स्वतंत्र है; और यह macOS, Windows और Linux पर काम करता है।

जबकि बाज़ार में अन्य Mach-O पार्सिंग मॉड्यूल मौजूद हैं, इसे विकसित करने के पीछे की प्रेरणाएँ ये हैं:

  • सबसे पहले और सबसे महत्वपूर्ण, मेरे लिए यह Mach-O प्रारूप और संरचनाओं के बारे में गहराई से जानने और सीखने का एक शानदार तरीका था
  • विश्लेषण के लिए Mach-O फ़ाइलों को पार्स करने का एक सरल तरीका प्रदान करना
  • बाहरी मॉड्यूल (जैसे lief, macholib, macho आदि) पर निर्भर न होना, क्योंकि सब कुछ सीधे फ़ाइल से निकाला जाता है और पूरी तरह से शुद्ध python में होता है।

अगर आप इसे आज़माते हैं या बग पाते हैं तो मुझे बताएं, लेकिन... नरमी बरतें ;) कोड को अनुकूलित किया जाएगा और अधिक सुविधाएँ जोड़ी जाएँगी।

वर्तमान विशेषताएँ:

  • Mach-O Header पार्स करें
  • Load Commands पार्स करें
  • File Segments पार्स करें
  • Dylib Commands पार्स करें
  • Dylib सूची पार्स करें
  • आयातित फ़ंक्शन निकालें
  • Exported Symbols निकालें
  • हैश: dylib hash, import hash, export hash, entitlement hash, symhash
  • Segment एंट्रॉपी गणना
  • Entry point निकालें
  • UUID निकालें
  • संस्करण जानकारी निकालें
  • बुनियादी Code Signature जानकारी पार्स करें
  • FAT (Universal) बाइनरी के लिए समर्थन
  • FAT (Universal) बाइनरी से अलग-अलग Mach-O स्लाइस डंप करें
  • JSON आउटपुट समर्थन (मानव-पठनीय और raw दोनों प्रारूप)
  • नोट: अभी तक, इसका प्रारंभिक परीक्षण x86, x86_64, arm64 और arm64e Mach-O नमूनों पर किया गया है।

    लागू की जाने वाली अगली विशेषताएँ (यादृच्छिक क्रम में):

    • एम्बेडेड स्ट्रिंग्स
    • फ़ाइल विशेषताएँ
    • संदिग्ध लाइब्रेरी के लिए फ़्लैग
    • पैकर का पता लगाना
    • ...

    उपयोग और उदाहरण

    आप इसे कमांड लाइन से उपयोग कर सकते हैं या अपने python कोड में एक मॉड्यूल के रूप में आयात कर सकते हैं, और केवल उन संरचनाओं को पार्स करने के लिए प्रत्येक फ़ंक्शन को अलग-अलग कॉल कर सकते हैं जिनमें आपकी रुचि है। आप इसे सीधे pip के माध्यम से इंस्टॉल कर सकते हैं और प्रोग्रामेटिक रूप से या कमांड लाइन से उपयोग कर सकते हैं, या इसे स्टैंडअलोन स्क्रिप्ट के रूप में उपयोग कर सकते हैं।

    root@kitploit:~
    pip install machofile
    

    मॉड्यूल संस्करण

    इसे पार्स करने के लिए या तो एक फ़ाइल पथ या एक डेटा बफ़र प्रदान किया जाना अपेक्षित है।

    root@kitploit:~
    import machofile
    macho = machofile.UniversalMachO(file_path='/path/to/machobinary')
    macho.parse()
    

    यदि डेटा बफ़र पहले से उपलब्ध है, तो इसे सीधे इस प्रकार प्रदान किया जा सकता है:

    root@kitploit:~
    import machofile
    with open(file_path, 'rb') as f:
        data = f.read()
    macho = machofile.UniversalMachO(data=data)
    macho.parse()
    

    API के विस्तृत उपयोग के लिए, समर्पित API दस्तावेज़ीकरण पृष्ठ देखें।

    कमांड लाइन संस्करण

    यदि आपने इसे pip के माध्यम से इंस्टॉल किया है तो आप machofile को सीधे CLI टूल के रूप में भी उपयोग कर सकते हैं, या python3 machofile.py के रूप में स्टैंडअलोन टूल के रूप में। मॉड्यूल के रूप में उपलब्ध सभी सुविधाएँ कमांड लाइन टूल के रूप में भी उपलब्ध हैं।

    root@kitploit:~
    % machofile -h
    usage: machofile [-h] -f FILE [-j] [--raw] [-a] [-d] [-e] [-ep] [-g]
                        [-hdr] [-i] [-l] [-seg] [-sig] [-sim] [-u] [-v]
                        [--arch ARCH] [--dump-dir DUMP_DIR]
    
    Parse Mach-O binary structures. (version 2026.02.04)
    
    options:
      -h, --help          show this help message and exit
    
    required arguments:
      -f, --file FILE     Path to the file to be parsed
    
    output format options:
      -j, --json          Output data in JSON format
      --raw               Output raw values in JSON format (use with -j/--json)
    
    data extraction options:
      -a, --all           Print all info about the file
      -d, --dylib         Print Dylib Command Table and Dylib list
      -e, --exports       Print exported symbols
      -ep, --entry-point  Print entry point information
      -g, --general_info  Print general info about the file
      -hdr, --header      Print Mach-O header info
      -i, --imports       Print imported symbols
      -l, --load_cmd_t    Print Load Command Table and Command list
      -seg, --segments    Print File Segments info
      -sig, --signature   Print code signature and entitlements information
      -sim, --similarity  Print similarity hashes
      -u, --uuid          Print UUID
      -v, --version       Print version information
    
    filter options:
      --arch ARCH         Show info for specific architecture only (for Universal binaries)
    
    dump options:
      --dump-dir DUMP_DIR Dump individual Mach-O slices from a FAT/Universal binary
                          to the specified directory
    

    उदाहरण आउटपुट:

    root@kitploit:~
    % machofile -a -f b4f68a58658ceceb368520dafc35b270272ac27b8890d5b3ff0b968170471e2b
    
    [General File Info]
            Filename:         b4f68a58658ceceb368520dafc35b270272ac27b8890d5b3ff0b968170471e2b
            Filesize:         54240
            MD5:              20ffe440e4f557b9e03855b5da2b3c9c
            SHA1:             1bf61ecad8568a774f9fba726a254a9603d09f33
            SHA256:           b4f68a58658ceceb368520dafc35b270272ac27b8890d5b3ff0b968170471e2b
    
    [Mach-O Header]
            magic:            MH_MAGIC (32-bit), 0xFEEDFACE
            cputype:          Intel i386
            cpusubtype:       X86_ALL
            filetype:         EXECUTE
            ncmds:            13
            sizeofcmds:       1180
            flags:            NOUNDEFS, DYLDLINK, TWOLEVEL
    
    [Load Cmd table]
            {'cmd': 'LC_SEGMENT', 'cmdsize': 56}
            {'cmd': 'LC_SEGMENT', 'cmdsize': 192}
            {'cmd': 'LC_SEGMENT', 'cmdsize': 328}
            {'cmd': 'LC_SEGMENT', 'cmdsize': 192}
            {'cmd': 'LC_SEGMENT', 'cmdsize': 56}
            {'cmd': 'LC_SYMTAB', 'cmdsize': 24}
            {'cmd': 'LC_DYSYMTAB', 'cmdsize': 80}
            {'cmd': 'LC_LOAD_DYLINKER', 'cmdsize': 28}
            {'cmd': 'LC_UUID', 'cmdsize': 24}
            {'cmd': 'LC_UNIXTHREAD', 'cmdsize': 80}
            {'cmd': 'LC_LOAD_DYLIB', 'cmdsize': 52}
            {'cmd': 'LC_LOAD_DYLIB', 'cmdsize': 52}
            {'cmd': 'LC_CODE_SIGNATURE', 'cmdsize': 16}
    
    [Load Commands]
            LC_CODE_SIGNATURE
            LC_DYSYMTAB
            LC_LOAD_DYLIB
            LC_LOAD_DYLINKER
            LC_SEGMENT
            LC_SYMTAB
            LC_UNIXTHREAD
            LC_UUID
    
    [File Segments]
            SEGNAME    VADDR VSIZE OFFSET SIZE  MAX_VM_PROTECTION INITIAL_VM_PROTECTION NSECTS FLAGS ENTROPY            
            ------------------------------------------------------------------------------------------------------------
            __PAGEZERO 0     4096  0      0     0                 0                     0      0     0.0                
            __TEXT     4096  28672 0      28672 7                 5                     2      0     5.080680410706916  
            __DATA     32768 4096  28672  4096  7                 3                     4      0     0.1261649636134924 
            __IMPORT   36864 4096  32768  4096  7                 7                     2      0     0.21493796627555234
            __LINKEDIT 40960 20480 36864  17376 7                 1                     0      0     6.637864516225949  
    
    [Dylib Commands]
            DYLIB_NAME_OFFSET DYLIB_TIMESTAMP DYLIB_CURRENT_VERSION DYLIB_COMPAT_VERSION DYLIB_NAME                   
            ----------------------------------------------------------------------------------------------------------
            24                2               65536                 65536                b'/usr/lib/libgcc_s.1.dylib' 
            24                2               7274759               65536                b'/usr/lib/libSystem.B.dylib'
    
    [Dylib Names]
            b'/usr/lib/libgcc_s.1.dylib'
            b'/usr/lib/libSystem.B.dylib'
    
    [UUID]
            d691c242-da49-1081-50d5-4f8991924b06
    
    [Entry Point]
            type:             LC_UNIXTHREAD
            entry_address:    9200
            thread_data_size: 72
    
    [Version Information]
            No version information found
    
    [Code Signature]
            signed:           True
            signing_status:   Apple signed
            certificates_info:
                count:            3
                certificates:
                  index:            0
                  size:             4815
                  subject:          Contains: Developer ID Certification Authority
                  issuer:           Unable to parse
                  is_apple_cert:    True
                  type:             Developer ID Certification Authority
    
                  index:            1
                  size:             1215
                  subject:          Contains: Apple Root CA
                  issuer:           Unable to parse
                  is_apple_cert:    True
                  type:             Apple Root CA
    
                  index:            2
                  size:             1385
                  subject:          Contains: Developer ID Application:
                  issuer:           Unable to parse
                  is_apple_cert:    False
                  type:             Developer ID Application Certificate
            entitlements_info:
                count:            0
                entitlements:
            code_directory:
                version:          131328
                flags:            0
                hash_offset:      144
                identifier_offset:48
                special_slots:    3
                signing_flags:
                    None
                code_slots:       11
                hash_size:        44640
                hash_type:        335609868
                hash_algorithm:   Unknown (335609868)
                identifier:       onmac.unspecified.installer
    
    [Imported Libraries]
            /usr/lib/libgcc_s.1.dylib
            /usr/lib/libSystem.B.dylib
    
    [Imported Functions]
            (Sources: CF=chained_fixups, BO=bind, WB=weak_bind, LB=lazy_bind, ST=symtab)
            /usr/lib/libSystem.B.dylib:
                    __NSGetExecutablePath [ST]
                    ___stderrp [ST]
                    _dlerror [ST]
                    _dlopen [ST]
                    _dlsym [ST]
                    _exit [ST]
                    _fclose [ST]
                    _fopen [ST]
                    _fprintf [ST]
                    _fputs$UNIX2003 [ST]
                    _free [ST]
                    _fwrite$UNIX2003 [ST]
                    _getenv [ST]
                    _getpid [ST]
                    _getpwnam [ST]
                    _lstat [ST]
                    _mbstowcs [ST]
                    _memcpy [ST]
                    _memset [ST]
                    _setenv$UNIX2003 [ST]
                    _setlocale [ST]
                    _snprintf [ST]
                    _stat [ST]
                    _strchr [ST]
                    _strdup [ST]
                    _strlen [ST]
                    _unsetenv$UNIX2003 [ST]
    
    [Exported Symbols]
            <unknown>:
                    _NXArgc
                    _NXArgv
                    ___progname
                    _environ
                    _main
                    start
    
    [Similarity Hashes]
            dylib_hash:       0556bed5dc31bddaee73f3234b3c577b
            export_hash:      824e359e3d0ad7283d0982bd5da2e8fd
            import_hash:      0bae89995ad3900987c49c0bea1d17fe
            symhash:          15e6c1aeba01be1404901f7152213779
    

    Universal (FAT) बाइनरी से स्लाइस डंप करना

    Universal (FAT) बाइनरी के साथ काम करते समय, आप --dump-dir का उपयोग करके प्रत्येक आर्किटेक्चर स्लाइस को उसकी अपनी स्टैंडअलोन Mach-O फ़ाइल में निकाल सकते हैं:

    root@kitploit:~
    # Dump all slices
    % machofile -f universal_binary --dump-dir ./output
    Dumped x86_64 -> ./output/universal_binary.x86_64
    Dumped arm64 -> ./output/universal_binary.arm64
    
    # Dump only a specific architecture (combine with --arch)
    % machofile -f universal_binary --dump-dir ./output --arch arm64
    Dumped arm64 -> ./output/universal_binary.arm64
    

    प्रत्येक डंप की गई फ़ाइल एक मान्य स्टैंडअलोन Mach-O बाइनरी है। यदि आउटपुट निर्देशिका मौजूद नहीं है तो वह स्वचालित रूप से बना दी जाती है। आउटपुट फ़ाइलों का नाम <original_filename>.<arch_name> रखा जाता है।

    JSON आउटपुट

    machofile पार्स किए गए डेटा के प्रोग्रामेटिक उपभोग के लिए JSON आउटपुट का समर्थन करता है। JSON आउटपुट दो प्रारूपों में आता है:

    मानव-पठनीय JSON (डिफ़ॉल्ट)

    डिफ़ॉल्ट JSON आउटपुट उचित स्वरूपण लागू करके मानव-पठनीय मान प्रदान करता है:

    root@kitploit:~
    % python3 machofile.py -j -hdr -f dec750b9d596b14aeab1ed6f6d6d370022443ceceb127e7d2468b903c2d9477a 
    {
      "header": {
        "x86_64": {
          "magic": "MH_MAGIC_64 (64-bit), 0xFEEDFACF",
          "cputype": "x86_64",
          "cpusubtype": "x86_ALL",
          "filetype": "EXECUTE",
          "ncmds": 41,
          "sizeofcmds": 5024,
          "flags": "NOUNDEFS, DYLDLINK, TWOLEVEL, BINDS_TO_WEAK, PIE"
        },
        "arm64": {
          "magic": "MH_MAGIC_64 (64-bit), 0xFEEDFACF",
          "cputype": "ARM 64-bit",
          "cpusubtype": "ARM_ALL",
          "filetype": "EXECUTE",
          "ncmds": 41,
          "sizeofcmds": 5104,
          "flags": "NOUNDEFS, DYLDLINK, TWOLEVEL, BINDS_TO_WEAK, PIE"
        }
      },
      "architectures": [
        "x86_64",
        "arm64"
      ]
    }
    

    Raw JSON आउटपुट

    उन अनुप्रयोगों के लिए जिन्हें raw संख्यात्मक मानों को संसाधित करने की आवश्यकता है, --raw फ़्लैग का उपयोग करें:

    root@kitploit:~
    % python3 machofile.py -j --raw -hdr -f dec750b9d596b14aeab1ed6f6d6d370022443ceceb127e7d2468b903c2d9477a
    {
      "header": {
        "x86_64": {
          "magic": 4277009103,
          "cputype": 16777223,
          "cpusubtype": 3,
          "filetype": 2,
          "ncmds": 41,
          "sizeofcmds": 5024,
          "flags": 2162821
        },
        "arm64": {
          "magic": 4277009103,
          "cputype": 16777228,
          "cpusubtype": 0,
          "filetype": 2,
          "ncmds": 41,
          "sizeofcmds": 5104,
          "flags": 2162821
        }
      },
      "architectures": [
        "x86_64",
        "arm64"
      ]
    }
    

    JSON आउटपुट विकल्प

    • -j, --json: डेटा को JSON प्रारूप में आउटपुट करें (डिफ़ॉल्ट रूप से मानव-पठनीय)
    • --raw: स्वरूपित स्ट्रिंग के बजाय raw संख्यात्मक मान आउटपुट करें (-j के साथ उपयोग किया जाना चाहिए)

    JSON आउटपुट मानक आउटपुट (-a, -hd, -l, -sg आदि) के समान सभी विश्लेषण विकल्पों का समर्थन करता है और सिंगल-आर्किटेक्चर और Universal (FAT) दोनों बाइनरी के साथ काम करता है।

    प्रायोजक

    RationalEdge

    machofile का विकास RationalEdge द्वारा प्रायोजित है।

    श्रेय

    ये वे लोग हैं जिन्हें मैं प्रेरणा स्रोत होने के लिए धन्यवाद देना चाहता हूँ, जिसके कारण मैंने यह मॉड्यूल लिखा:

    • Ero Carrera (@erocarrera) को pefile मॉड्यूल लिखने और बनाए रखने के लिए
    • Patrick Wardle (@patrickwardle) को उनके macOS मैलवेयर विश्लेषण और शोध को साझा करने के शानदार कार्य के लिए, और OBTS को जीवंत बनाने के लिए :)
    • Greg Lesnewich (@greg-l.bsky.social) और Jacob Latonis (@jacoblatonis.me) को mach-o समानता पर उनके कार्य और Mach-O बाइनरी प्रारूप पर निरंतर, गहन और ज्ञानवर्धक विचार-विमर्श सत्रों के लिए। YT पर उनकी OBTS v7 प्रस्तुति देखें।

    संदर्भ/दस्तावेज़ीकरण लिंक:

    • https://opensource.apple.com/source/xnu/xnu-2050.18.24/EXTERNAL_HEADERS/mach-o/loader.h
    • https://github.com/apple-oss-distributions/lldb/blob/10de1840defe0dff10b42b9c56971dbc17c1f18c/llvm/include/llvm/Support/MachO.h
    • https://github.com/apple-oss-distributions/dyld/tree/main
    • https://iphonedev.wiki/Mach-O_File_Format
    • https://lowlevelbits.org/parsing-mach-o-files/
    • https://github.com/aidansteele/osx-abi-macho-file-format-reference
    • https://lief-project.github.io/doc/latest/tutorials/11_macho_modification.html
    • https://github.com/VirusTotal/yara/blob/master/libyara/include/yara/macho.h
    • https://github.com/corkami/pics/blob/master/binary/README.md
    • https://github.com/qyang-nj/llios/tree/main
    • https://github.com/threatstream/symhash
    टूल डाउनलोड करें