mofos

mofos

Mofos एक उपकरण है जो वर्चुअल मशीनों को बनाने, चलाने और प्रबंधित करने के लिए डिज़ाइन किया गया है। यह Libvirt/QEMU/KVM और Python का उपयोग करता है, जिससे यह किसी भी Linux वितरण के साथ संगत बन जाता है। Qubes OS (https://www.qubes-os.org/) से काफी प्रेरित होकर, Mofos इसकी कई विशेषताओं को दोहराने का लक्ष्य रखता है।

इस उपकरण का व्यापक रूप से Debian और Debian-आधारित वर्चुअल मशीनों पर परीक्षण किया गया है। जबकि अन्य Linux वितरणों के काम करने की उम्मीद है, कुछ अतिरिक्त कॉन्फ़िगरेशन आवश्यक हो सकते हैं। अधिक विवरण बाद में जोड़े जाएँगे।

Mofos सुरक्षित रूप से वर्चुअल मशीनों के प्रबंधन पर केंद्रित कई सुविधाएँ प्रदान करता है, जिनमें शामिल हैं:

Xpra का उपयोग करके निर्बाध विंडो एकीकरण।
एक क्लिपबोर्ड प्रणाली जो होस्ट और वर्चुअल मशीनों के बीच क्लिपबोर्ड सामग्री भेजने और प्राप्त करने में सक्षम बनाती है।
वर्चुअल मशीनों के साथ SSH संचार।
डिफ़ॉल्ट नेटवर्क प्रतिबंध, जिसमें एक वर्चुअल मशीन से ट्रैफ़िक को अन्य या दूरस्थ सर्वरों के माध्यम से रूट या टनल करने के लचीले विकल्प शामिल हैं।

अवधारणा

एक mofos मशीन में overlayfs का उपयोग करके संयोजित दो डिस्क होते हैं। पहली डिस्क, जिसे निचली परत के रूप में जाना जाता है, एक केवल-पठनीय टेम्पलेट डिस्क है, जबकि दूसरी डिस्क वर्चुअल मशीन द्वारा किए गए सभी परिवर्तनों को संग्रहीत करती है। यह टेम्पलेट डिस्क कई वर्चुअल मशीनों के बीच साझा की जाती है। परिणामस्वरूप, एक नई वर्चुअल मशीन बनाने के लिए केवल एक खाली डिस्क क्लोन करने की आवश्यकता होती है जो पहले से ही संशोधित डेटा रखने के लिए विभाजित हो। यह दृष्टिकोण सुनिश्चित करता है कि नई वर्चुअल मशीनें जल्दी से बनाई जा सकें, जबकि टेम्पलेट को स्वतंत्र रूप से अद्यतन करने की अनुमति मिलती है। टेम्पलेट में किए गए कोई भी अद्यतन निर्भर वर्चुअल मशीनों पर उनके अगले रीबूट पर प्रभावी होंगे।

स्थापना

Linux वितरण के आधार पर, Makefile का उपयोग या तो deb पैकेज उत्पन्न करने या फ़ाइलों को सीधे स्थापित करने के लिए किया जा सकता है।``` make deb apt install ./mofos-VERSION.deb

During the `apt` स्थापना के दौरान, विभिन्न सेटिंग्स पूछी जाएंगी। डिफ़ॉल्ट विकल्पों को आम तौर पर स्वीकार किया जा सकता है। एकमात्र सेटिंग जिस पर ध्यान देने की आवश्यकता है वह है mofos libvirt नेटवर्क द्वारा उपयोग किया जाने वाला सबनेट पता (डिफ़ॉल्ट: `192.168.90.0/24`)।

या 

निम्नलिखित निर्भरताएँ स्थापित करें:
- guestfs-tools
- libnotify-bin
- libvirt
- libvirt-clients
- libvirt-daemon
- make
- python3-click
- python3-click-completion
- python3-colorama
- python3-cryptography
- python3-dbus
- python3-jinja2
- python3-lxml
- python3-prettytable
- python3-pyroute2
- python3-tqdm
- qemu-system-common 
- qemu-system-modules-spice
- socat
- spice-client-gtk
- sudo
- virtinst
- virt-install
- virtiofsd
- virt-manager
- virt-viewer```
make install_files

वितरण के आधार पर, /usr/lib/python3/dist-packages में कॉपी की गई Python फ़ाइलें Python इंटरप्रेटर द्वारा पहचानी नहीं जा सकतीं और उन्हें कहीं और रखा जाना चाहिए। उदाहरण के लिए, Fedora पर, Python फ़ाइलों को /usr/lib/python3.11/site-packages में कॉपी किया जाना चाहिए।

[!WARNING] ध्यान दें, Debian trixie के बाद से xpra अब पैकेज नहीं किया जाता है, आपको इसे इसके कस्टम रिपॉजिटरी से मैन्युअल रूप से इंस्टॉल करना होगा। विस्तृत निर्देशों के लिए https://github.com/Xpra-org/xpra/wiki/Download#-for-debian-based-distributions देखें।

होस्ट को कॉन्फ़िगर करें

QEMU/KVM सिस्टम सेशन

Mofos QEMU/KVM सिस्टम सेशन का उपयोग करता है, इसलिए virsh कमांड को वर्चुअल मशीनों और संबंधित संसाधनों तक पहुंचने की अनुमति देने के लिए, पर्यावरण चर LIBVIRT_DEFAULT_URI को qemu:///system पर सेट करें:```console export LIBVIRT_DEFAULT_URI=qemu:///system

### सुरक्षा संबंधी विचार

QEMU/KVM सिस्टम सेशन का उपयोग, qemu इंस्टेंस को एक समर्पित उपयोगकर्ता (`libvirt-qemu`) के अंतर्गत चलाकर और प्रत्येक इंस्टेंस पर विशिष्ट सुरक्षा प्रोफाइल लागू करके होस्ट और गेस्ट वर्चुअल मशीनों के बीच अलगाव (isolation) को बेहतर बनाता है।

हालाँकि, डिफ़ॉल्ट रूप से, सामान्य उपयोगकर्ता मशीनों, नेटवर्कों और अन्य संसाधनों को प्रबंधित करने के लिए `libvirtd` सिस्टम सॉकेट के साथ इंटरैक्ट नहीं कर सकते हैं। एक्सेस पाने के लिए, उपयोगकर्ताओं को या तो libvirt Unix समूह के सदस्य होना चाहिए या sudo का उपयोग करना चाहिए। ऐतिहासिक रूप से, स्थानीय विशेषाधिकार वृद्धि (privilege escalation) कमजोरियों ने रूट विशेषाधिकार प्राप्त करने के लिए libvirt समूह की सदस्यता का फायदा उठाया है।

इन जोखिमों को कम करने के लिए, यह रिपॉज़िटरी AppArmor का उपयोग करने वाले सिस्टम पर `libvirtd` प्रक्रिया के लिए एक सुदृढ़ (strengthened) AppArmor प्रोफाइल प्रदान करता है। यह प्रोफाइल काफी हद तक सीमित करता है कि `libvirtd` फाइलें कहाँ लिख सकता है और वह कौन से प्रोग्राम चला सकता है।

इसके अतिरिक्त, `libvirt` समूह के सदस्यों के लिए अनुमत क्रियाओं को और अधिक नियंत्रित करने के लिए `polkit` नियम शामिल किए गए हैं।

ध्यान दें कि AppArmor प्रोफाइल `deb` पैकेज में शामिल होते हैं लेकिन Makefile के `install_files` टारगेट द्वारा इंस्टॉल नहीं होते हैं, इसलिए उन्हें अलग से इंस्टॉल किया जाना चाहिए।

## Mofos कॉन्फ़िगरेशन

Mofos को सही ढंग से कार्य करने के लिए `$HOME/.config/mofos/config.toml` पर स्थित न्यूनतम सेटिंग्स वाली एक कॉन्फ़िगरेशन फ़ाइल की आवश्यकता होती है। एक न्यूनतम उदाहरण कॉन्फ़िगरेशन `/usr/share/mofos/config.minimal.toml` पर पाया जा सकता है, जबकि अधिक व्यापक कॉन्फ़िगरेशन `/usr/share/mofos/config.sample.toml` में प्रलेखित है।

निम्न त्रुटि इंगित करती है कि कॉन्फ़िगरेशन फ़ाइल नहीं मिली:```
[-] Copy the sample configuration file from /usr/share/mofos/config.minimal.toml to ~/.config/mofos/config.toml

निम्नलिखित त्रुटि इंगित करती है कि वर्तमान उपयोगकर्ता libvirt समूह का सदस्य नहीं है:``` [-] libvirtError("authentication unavailable: no polkit agent available to authenticate action 'org.libvirt.unix.manage'")

The key configuration settings to customize in the configuration files are as follows:
- key (पथ): वर्चुअल मशीनों तक पहुँचने के लिए उपयोग की जाने वाली SSH निजी कुंजी फ़ाइल। इस उद्देश्य के लिए एक समर्पित कुंजी बनाने की अनुशंसा की जाती है।
- user (स्ट्रिंग): वर्चुअल मशीनों तक SSH पहुँच के लिए उपयोगकर्ता नाम।
- root_password (हैश किया गया मान): नए टेम्पलेट की स्थापना के दौरान सेट किया जाने वाला हैश किया गया रूट पासवर्ड।
- root_ssh_pubkey (स्ट्रिंग): टेम्पलेट स्थापना के दौरान रूट उपयोगकर्ता की निर्देशिका में इंस्टॉल की जाने वाली सार्वजनिक SSH कुंजी।

इसके अतिरिक्त, टेम्पलेट स्थापना के लिए निम्नलिखित पैरामीटर कॉन्फ़िगर किए जाने चाहिए:
- ntp
- dns (वैकल्पिक यदि प्रॉक्सी प्रदान की गई है)
- proxy

## टेम्पलेट इंस्टॉल करें

### फ़ायरवॉल कॉन्फ़िगर करें

चूँकि स्थापना प्रक्रिया PXE नेटबूट पर निर्भर करती है, एक सक्रिय इंटरनेट कनेक्शन आवश्यक है। निम्नलिखित फ़ायरवॉल नियम कॉन्फ़िगर किए जाने चाहिए:```
sysctl net.ipv4.ip_forward=1
iptables -t nat -I POSTROUTING -s 192.168.90.0/24 -j MASQUERADE
iptables -t nat -I POSTROUTING -s 192.168.91.0/24 -j MASQUERADE

या nftables के साथ:``` sysctl net.ipv4.ip_forward=1 nft insert inet nat postrouting iifname "install-*" masquerade nft insert inet nat postrouting iifname "mof0" masquerade

जब `ip_forward` पैरामीटर 1 पर सेट होता है, तो FORWARD चेन को इस प्रकार कॉन्फ़िगर किया जाना चाहिए कि नेटवर्क पर मौजूद अन्य डिवाइस होस्ट को राउटर के रूप में उपयोग न कर सकें।

कुल मिलाकर, निम्नलिखित नियम अनुशंसित हैं:```
iptables -I INPUT -i mof0 -p udp --sport 68 --dport 67 -j ACCEPT -m comment --comment "mofos dhcp"
iptables -I INPUT -i mof0 -p udp --dport 69 -j ACCEPT -m comment --comment "mofos tftp"
iptables -I OUTPUT -o mof0 -j ACCEPT -m comment --comment "host -> mofos"
iptables -I FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
iptables -I FORWARD -i mof0 -j ACCEPT -m comment --comment "mofos ->"
iptables -t nat -I POSTROUTING -s 192.168.90.0/24 -j MASQUERADE
iptables -t nat -I POSTROUTING -s 192.168.91.0/24 -j MASQUERADE

या nftables के साथ:``` table inet filter {

chain input {
  type filter hook input priority 0; policy drop
  
  iifname "install-*" ip daddr 255.255.255.255 udp sport 68 udp dport 67 accept comment "mofos dhcp"
  iifname "mof0" ip daddr 255.255.255.255 udp sport 68 udp dport 67 accept comment "mofos dhcp"
  iifname "install-*" udp dport 69 accept comment "mofos tftp"
}

chain forward {
  type filter hook forward priority 0; policy drop
  
  ct state established,related accept;
  ct state invalid drop;
  
  iifname "mof0" counter accept
  iifname "install-*" counter accept
}

chain output {
  type filter hook output priority 0; policy drop
  
  oifname "mof0" counter accept
}

} table inet nat { chain postrouting { type nat hook postrouting priority 100 iifname "mof0" masquerade iifname "install-*" masquerade } }

अपनी विशिष्ट आवश्यकताओं के आधार पर masquerade और forwarding नियमों को प्रतिबंधित करने की अनुशंसा की जाती है, ताकि mofos वर्चुअल मशीनें पूरे होस्ट नेटवर्क तक न पहुँच सकें।

वर्चुअल मशीनों के बीच अलगाव एक libvirt hook द्वारा स्वचालित रूप से लागू किया जाता है, जिसके समुचित कार्य के लिए nft की आवश्यकता होती है।


### इंस्टॉल

पहला कदम प्रारंभिक परत बनाना है: टेम्पलेट। डिफ़ॉल्ट रूप से, Mofos एक Debian 12–आधारित टेम्पलेट स्थापित कर सकता है।```
mofos template create debian-template

नोट: हर कमांड के लिए, --debug विकल्प का उपयोग अप्रत्याशित व्यवहार की स्थिति में विस्तृत तकनीकी जानकारी प्राप्त करने के लिए किया जा सकता है। विशेष रूप से इस कमांड के लिए, --debug फ़्लैग इंस्टॉलेशन प्रगति दिखाने के लिए एक ग्राफ़िकल विंडो भी प्रदर्शित करता है। वैकल्पिक रूप से, इंस्टॉलेशन की निगरानी virt-manager. का उपयोग करके की जा सकती है।

वर्तमान में, इंस्टॉलेशन के लिए केवल Debian 12 टेम्पलेट समर्थित है। नीचे दिया गया Python डिक्शनरी इस्तेमाल की जाने वाली इंस्टॉलेशन इमेज को निर्दिष्ट करता है:```python NETBOOT = { "debian-stable-amd64": { "variant": "debian11", "url": "https://deb.debian.org/debian/dists/stable/main/installer-amd64/current/images/netboot/netboot.tar.gz", } }

वैरिएंट `debian11` पर सेट है क्योंकि Debian 12 में, Debian 12 के लिए `osinfo` वैरिएंट अभी तक libvirt के माध्यम से इंस्टॉल करने योग्य नहीं है।

किसी अन्य डिस्ट्रीब्यूशन को इंस्टॉल करने के लिए, `/usr/lib/python3/dist-packages/mofos/settings.py` में स्थित डिक्शनरी को संशोधित करें।

जब उपरोक्त कमांड चलाई जाती है, Mofos नेटबूट फ़ाइलें डाउनलोड करता है और `tar.gz` संग्रह को `$HOME/.cache/template-installer` में कैश करता है। वर्तमान में, यदि नेटबूट संग्रह पहले से मौजूद है, तो Mofos इसे फिर से डाउनलोड नहीं करेगा। यदि कैश किया गया संग्रह पुराना है तो इससे त्रुटियाँ हो सकती हैं। यदि इंस्टॉलेशन के दौरान ऐसी त्रुटियाँ आती हैं, तो कैश किए गए संग्रह को हटाने से Mofos एक अद्यतन संस्करण डाउनलोड करने के लिए बाध्य होगा, जिससे समस्या हल हो जानी चाहिए।

इसके बाद, संग्रह को `/tmp` में निकाला जाता है, और libvirt को TFTP के माध्यम से इसकी सामग्री को सर्व करने के लिए कॉन्फ़िगर किया जाता है।

फिर टेम्पलेट वर्चुअल मशीन बनाई जाती है और PXE के माध्यम से बूट करने के लिए सेट की जाती है, जो दिए गए preseed फ़ाइल (डिफ़ॉल्ट रूप से `/usr/share/mofos/templates/debian/preseed.cfg.j2`) का उपयोग करके निर्दिष्ट डिस्ट्रीब्यूशन को इंस्टॉल करती है। यह फ़ाइल एक `jinja2` टेम्पलेट है; इसे TFTP रूट डायरेक्टरी में कॉपी करने से पहले, कॉन्फ़िगरेशन फ़ाइलों (`ntp`, `proxy`, `dns`, `root_password`) से वेरिएबल इंजेक्ट किए जाते हैं।

इंस्टॉलेशन के अंत में, `postinstall` स्क्रिप्ट को TFTP डायरेक्टरी में रखा जाता है और टेम्पलेट पर निष्पादित किया जाता है। डिफ़ॉल्ट रूप से, `/usr/share/mofos/templates/postinstall.sh.j2` पर स्थित स्क्रिप्ट का उपयोग किया जाता है। यह `jinja2` टेम्पलेट टेम्पलेट पर कॉन्फ़िगर की जाने वाली सार्वजनिक SSH कुंजी को इंजेक्ट करता है।

रूट SSH सार्वजनिक कुंजी को कॉन्फ़िगर करने के अलावा, निम्नलिखित ऑपरेशन किए जाते हैं:
- मानक SSH सेवा को अक्षम करें और वर्चुअल सॉकेट (vsock) पर SSHD सक्षम करें।
- `/etc/resolv.conf` फ़ाइल को खाली करें।
- GRUB टाइमआउट को 0 सेकंड पर कॉन्फ़िगर करें।
- एक initramfs हुक इंस्टॉल करें जो `overlay` लेबल वाले पार्टीशन का पता चलने पर overlayfs को माउंट करता है।

एक बार इंस्टॉलेशन पूरा हो जाने पर, libvirt वर्चुअल मशीन को प्राप्त किया जाता है और वर्तमान डायरेक्टरी में सहेजी गई एक स्थानीय `qcow2` फ़ाइल में संपीड़ित किया जाता है।```
$ mofos template create debian-template
[*] Installing debian-template
[*] Configure the SSH host key of the template
[*] Waiting for the installation to be complete
[*] Installation is complete
[*] Downloading the resulting qcow2 disk
[*] Compressing the disk
[*] Save template's public ssh host key
[+] Template installation finished
[+] Template disk is debian-template-disk.qcow2

qcow2 फ़ाइल के अतिरिक्त, यह प्रक्रिया $HOME/.local/share/mofos/ssh.json फ़ाइल में भी एक प्रविष्टि बनाती है, जिसमें मशीन का नाम और उसकी सार्वजनिक SSH कुंजी होती है:```json { "disk": { "debian-template-disk.qcow2": "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAINrbOdOPENEj2KeHrYLdorQe9Ez1b9Bu5agZmgNDMayy" } }

यह फ़ाइल आयात प्रक्रिया के दौरान स्वचालित रूप से उपयोग की जाती है।

### आयात

अगला कदम निर्मित टेम्पलेट `qcow2` फ़ाइल को Mofos में आयात करना है।```
$ mofos template import debian-template debian-template-disk.qcow2 http://debian.org/debian/11 
[*] Uploading debian-template-disk.qcow2 to mofos pool
[*] Creating the virtual machine debian-template
[*] Configuring the template metadata
[*] Configuring the SSH key
[+] debian-template successfully imported

फ़िलहाल, osinfo वैरिएंट अनिवार्य है। इन्हें इस फ़ाइल में पाया जा सकता है: /usr/lib/python3/dist-packages/mofos/settings.py.

इस बिंदु से, टेम्पलेट को आवश्यकतानुसार प्रारंभ और संशोधन के लिए एक्सेस किया जा सकता है।```
$ mofos start debian-template
$ mofos ls
+----+-----------------+---------+-------------+-------+-----+----------------+
| Id | Name            | State   | Description | Alias | Cid | IPv4 address   |
+----+-----------------+---------+-------------+-------+-----+----------------+
| 3  | debian-template | running |             |       | 3   | 192.168.90.202 |
+----+-----------------+---------+-------------+-------+-----+----------------+

🔗 बाहरी आयात```

$ mofos ssh debian-template --user root root@linux:~#

## ऊपरी परत की खाली डिस्क बनाएं

निम्नलिखित कमांड डिस्क के एकमात्र पार्टीशन पर निर्दिष्ट लेबल के साथ एक खाली ऊपरी परत बनाता है:```
$ mofos template create-overlay-disk

डिफ़ॉल्ट रूप से, यह डिस्क 50 GB की होती है लेकिन शुरुआत में केवल लगभग 100 MB स्थान घेरती है। इस आकार को कॉन्फ़िगरेशन फ़ाइल में अनुकूलित किया जा सकता है।

वर्चुअल मशीन बनाएँ

नोट: Mofos वर्चुअल मशीनों में हेरफेर करने से पहले हमेशा एक टेम्पलेट को बंद करने की अनुशंसा की जाती है। हालाँकि एक टेम्पलेट और उसकी वर्चुअल मशीनों को एक साथ चलाना समर्थित है, यह अस्थिरता का कारण बन सकता है।``` $ mofos new test [] New virtual machine name is test [+] Virtual machine test successfully created [] Triggering post install actions [] Create SSH known_hosts entries for test [] Waiting for test to be up [+] test is ready $ mofos ssh test -u root Last login: Mon Jun 2 11:09:51 2025 from UNKNOWN root@linux:~#

ध्यान रखें कि SSH कनेक्शन वर्चुअल सॉकेट के माध्यम से बनाए जाते हैं, इसलिए आप नवनिर्मित मशीन में सीधे SSH नहीं कर सकते। इसके बजाय, आपको mofos ssh कमांड का उपयोग करना होगा। वैकल्पिक रूप से, आप एक SSH कॉन्फ़िगरेशन बना सकते हैं जो मशीन के SSH पोर्ट तक पहुँचने के लिए एक `ProxyCommand ` निर्दिष्ट करता है:```
$ mofos inventory --format ssh
Host debian-template
	User user
	PasswordAuthentication no
	IdentityFile /home/user/.ssh/id_ed25519
	ProxyCommand /usr/bin/mofos proxy-cmd %h
	CanonicalizeHostname=no

Host test
	User user
	PasswordAuthentication no
	IdentityFile /home/user/.ssh/id_ed25519
	ProxyCommand /usr/bin/mofos proxy-cmd %h
	CanonicalizeHostname=no

I don't see any source content in the "INPUT:" section to translate. The chunk appears to be empty. Please provide the actual Markdown content for chunk 41 of 104, and I'll translate it from English to Hindi following the chunk-specific rules.``` $ mofos inventory --format ssh > ~/.ssh/mofos $ echo "Include ~/.ssh/mofos" >> ~/.ssh/config $ ssh root@test Linux linux 6.1.0-37-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.140-1 (2025-05-22) x86_64

The programs included with the Debian GNU/Linux system are free software; the exact distribution terms for each program are described in the individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent permitted by applicable law. Last login: Mon Jun 2 11:09:51 2025 from UNKNOWN root@linux:~#

During a `mofos ssh` सत्र के दौरान, बाद के कनेक्शनों को तेज़ करने के लिए पहले से एक `ControlMaster` सॉकेट स्थापित किया जाता है। इसीलिए MOTD प्रदर्शित नहीं होता है।

## अनुकूलन

टेम्पलेट्स और वर्चुअल मशीनों के अनुकूलन को सरल बनाने के लिए, Mofos हुक्स और टैग्स की अवधारणा प्रस्तुत करता है। प्रत्येक टैग के लिए, एक संगत हुक (Bash स्क्रिप्ट) निष्पादित किया जा सकता है ताकि लक्षित वर्चुअल मशीन या टेम्पलेट पर स्वचालित क्रियाएँ की जा सकें और उसे तदनुसार कॉन्फ़िगर किया जा सके।

न्यूनतम हुक्स `/usr/share/mofos/hooks` में स्थित हैं। ये सरल Bash स्क्रिप्ट हैं जो निम्नलिखित इनपुट प्राप्त करते हैं:```
TAG=$1
NAME=$2
OS=$3
DISTRIB=$4
HOSTNAME=$5

टेम्पलेट - हुक इंस्टॉल

इस तंत्र का उपयोग Ansible के साथ टेम्पलेट इंस्टॉलेशन के दौरान playbooks निष्पादित करने के लिए किया जा सकता है:```bash #!/bin/bash

During template installation, the machine is not yet managed by mofos,

the inventory would not working.

A custom inventory is created on the fly using the given tag as main ansible

group and the distribution as secondary.

TAG=$1 NAME=$2 OS=$3 DISTRIB=$4 HOSTNAME=$5

if [ -z "${TAG}" ] || [ -z "${NAME}" ] || [ -z "${DISTRIB}" ] ; then exit 1 fi

Create inventory

ANSIBLE_DIRECTORY="/home/user/Documents/ansible" RANDOM_SUFFIX=$(printf "%x" $RANDOM) INVENTORY_FILE="${ANSIBLE_DIRECTORY}/inventory-${NAME}-${RANDOM_SUFFIX}.ini"

trap 'rm -f "${INVENTORY_FILE}"; exit' EXIT

cat > $INVENTORY_FILE <<EOF [all:vars] ansible_ssh_common_args="-o ProxyCommand='mofos proxy-cmd %h' -o CanonicalizeHostname=no"

[${TAG}] ${NAME}

[${DISTRIB}] ${NAME} EOF

export ANSIBLE_CONFIG="/home/user/Documents/ansible/ansible.cfg" export ANSIBLE_VERBOSITY=1

/usr/bin/ansible-playbook
-i "${INVENTORY_FILE}"
-l "${NAME}"
/home/user/Documents/ansible/playbooks/pentest/install.yml

### वर्चुअल मशीन - hook new

वर्चुअल मशीन निर्माण के दौरान, एक अन्य हुक का उपयोग किया जा सकता है, उदाहरण के लिए, होस्टनाम को यादृच्छिक करने के लिए।

डिफ़ॉल्ट रूप से, Mofos क्लासिक Windows नामकरण परंपरा के आधार पर एक अलियास उत्पन्न करता है (उदाहरण के लिए, `DESKTOP-2BF9753`)। यह नाम, अन्य जानकारी के साथ, हुक स्क्रिप्ट को पास किया जाता है:```
#!/bin/bash

TAG=$1
NAME=$2
OS=$3
DISTRIB=$4
HOSTNAME=$5

if [ -z "${TAG}" ] || [ -z "${NAME}" ] || [ -z "${OS}" ] ; then
  exit 1
fi

if [ -z "${HOSTNAME}" ] ; then
  HOSTNAME="${NAME}"
fi

mofos run -u root "${NAME}" "echo ${HOSTNAME} > /etc/hostname && hostname ${HOSTNAME}"

इसके बाद, इस हुक को सक्षम करने के लिए कॉन्फ़िगरेशन को संपादित किया जाना चाहिए:``` [hooks.test] new = "/home/user/.config/mofos/hooks/new.sh"

फिर, वर्चुअल मशीन निर्माण के दौरान, यह स्क्रिप्ट निष्पादित की जाएगी:```
$ mofos new test2 --tags test 
[*] New virtual machine name is test2
[+] Virtual machine test2 successfully created
[*] Triggering post install actions
[*] Create SSH known_hosts entries for test2
[*] Waiting for test2 to be up
[*] Running new hook: test
[+] test2 is ready

🧭 फॉलो अप

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

📂 त्वरित अवलोकन

यह खंड उन मुख्य पथों का त्वरित अवलोकन प्रदान करता है जिनका उपयोग आपके प्रोजेक्ट में किया गया है।

त्वरित अवलोकन पहले से ही सारांश में शामिल है, लेकिन नीचे दी गई सूची उपयोग की गई विशिष्ट सामग्री का अधिक विस्तृत दृश्य प्रदान करती है। यह उन्नत उपयोगकर्ताओं के लिए उपयोगी है जो बड़े प्रोजेक्ट्स में अधिक जटिल पथों की जांच करना चाहते हैं।

src - मुख्य स्रोत कोड निर्देशिका``` $ mofos ssh test2 -u root Last login: Mon Jun 2 11:09:51 2025 from UNKNOWN root@DESKTOP-2BF9753:~#

स्थापना चरण के समान, Ansible playbooks को इस चरण में भी निष्पादित किया जा सकता है। इस मामले में, `mofos inventory` कमांड का उपयोग Ansible इन्वेंट्री उत्पन्न करने के लिए किया जा सकता है, जिससे वर्चुअल मशीनों का चयन और उन तक पहुँच की प्रक्रिया सरल हो जाती है:```
$ mofos inventory 
{
    "_meta": {
        "hostvars": {
            "debian-template": {
                "ansible_host": "debian-template",
                "ansible_ssh_common_args": "-o ProxyCommand='/usr/bin/mofos proxy-cmd %h'  -o CanonicalizeHostname=no"
            },
            "test": {
                "ansible_host": "test",
                "ansible_ssh_common_args": "-o ProxyCommand='/usr/bin/mofos proxy-cmd %h'  -o CanonicalizeHostname=no"
            },
            "test2": {
                "ansible_host": "test2",
                "ansible_ssh_common_args": "-o ProxyCommand='/usr/bin/mofos proxy-cmd %h'  -o CanonicalizeHostname=no"
            }
        }
    },
    "debian": [
        "debian-template",
        "test",
        "test2"
    ],
    "test": [
        "test2"
    ]

ध्यान दें कि समूह वितरण वेरिएंट के साथ-साथ टैग के आधार पर बनाए जाते हैं। इन समूहों का उपयोग विभिन्न वेरिएबल्स को लोड करने के लिए किया जा सकता है।

उदाहरण के लिए, नीचे दिया गया स्क्रिप्ट एक मनमाना प्लेबुक चलाता है:```bash #!/bin/bash

TAG=$1 NAME=$2 OS=$3 DISTRIB=$4 HOSTNAME=$5

if [ -z "${TAG}" ] || [ -z "${NAME}" ] || [ -z "${OS}" ] ; then exit 1 fi

if [ -z "$HOSTNAME" ] ; then HOSTNAME=$NAME fi

if [ $OS == "windows" ] ; then TAGS="hostname,desktop" else TAGS="hostname,hosts,desktop" fi

export ANSIBLE_CONFIG="/home/user/Documents/ansible/ansible.cfg" export ANSIBLE_VERBOSITY=0

/usr/bin/ansible-playbook
-i /home/user/Documents/ansible/inventory.py
-l "${NAME}"
-t "${TAGS}"
-e "hostname=${HOSTNAME}"
/home/user/Documents/ansible/playbooks/pentest/update.yml

### वर्चुअल मशीन - प्रारंभ हुक

इसी प्रकार, प्रारंभ हुक तब निष्पादित होता है जब वर्चुअल मशीन प्रारंभ होती है। इसका उपयोग आमतौर पर वर्चुअल मशीन के लिए आवश्यक सेवाओं को लॉन्च करने के लिए किया जाता है।

उदाहरण के लिए, वर्चुअल मशीन के भीतर निर्बाध विंडोज़ एकीकरण सक्षम करने के लिए, आप `Xpra` इंस्टॉल कर सकते हैं।

पहले `ansible` इंस्टॉल करें:```
# apt install ansible

इसके बाद, ansible निर्देशिका में स्थित उपयोगकर्ता प्लेबुक चलाएँ। ऐसा करने से पहले, playbooks/user.yml फ़ाइल को संपादित करके पासवर्ड हैश और उपयोगकर्ता की होम निर्देशिका में स्थापित की जाने वाली सार्वजनिक SSH कुंजी को अपडेट करें।``` ~/mofos/ansible$ ls ansible.cfg ansible.log inventory.sh playbooks

### पीक्यूसी एल्गोरिदम```
$ ansible-playbook playbooks/user.yml -l test2
Using /home/user/mofos/ansible/ansible.cfg as config file
[WARNING]: Found both group and host with same name: test

PLAY [Create and configure a user]

[...]

PLAY RECAP
test2 : ok=4 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0

इसके बाद, आप इस उपयोगकर्ता खाते में SSH कर सकते हैं, बशर्ते कॉन्फ़िगरेशन इस उपयोगकर्ता को डिफ़ॉल्ट के रूप में निर्दिष्ट करता है:``` $ mofos ssh test2 user@DESKTOP-2BF9753:~$

आगे, `Xpra` playbook चलाएँ। यह playbook Debian mirrors से पैकेज इंस्टॉल करता है। कृपया ध्यान दें कि Mofos नेटवर्क डिफ़ॉल्ट रूप से DNS, proxy, या default gateway कॉन्फ़िगर नहीं करता है। इन्हें playbook चलाने से पहले सेट अप किया जाना चाहिए।

डिफ़ॉल्ट रूप से playbook में कोई संशोधन आवश्यक नहीं है।```
ansible-playbook playbooks/xpra.yml -l test2

यह प्लेबुक Xpra को इंस्टॉल और कॉन्फ़िगर करता है और वर्चुअल मशीन पर xpra सेवा शुरू करता है।

रिमोट सेवा को मैन्युअल रूप से निम्न का उपयोग करके शुरू किया जा सकता है:``` user@DESKTOP-2BF9753:~$ systemctl --user start xpra

अन्यथा, सेवा अगले रीबूट पर स्वचालित रूप से प्रारंभ हो जाएगी।

फिर, स्थानीय क्लाइंट सेवा को भी मैन्युअल रूप से प्रारंभ किया जा सकता है:```
$ mofos xpra start test2

वर्चुअल मशीन पर वापस, डिस्प्ले को :10 (डिफ़ॉल्ट) पर सेट किया जाना चाहिए, जिसके बाद एक ग्राफिकल एप्लिकेशन लॉन्च किया जा सकता है और वह होस्ट के डेस्कटॉप वातावरण के भीतर दिखाई देगा।``` user@DESKTOP-2BF9753:~~$ export DISPLAY=:10 user@DESKTOP-2BF9753:~~$ xterm

इस तंत्र को सुचारू रूप से और स्वचालित रूप से चलाने के लिए, `mofos xpra` कमांड को start hook से शुरू किया जा सकता है।```bash
#!/bin/bash

TAG=$1
NAME=$2
OS=$3
DISTRIB=$4
HOSTNAME=$5

if [ -z "${TAG}" ] || [ -z "${NAME}" ] ; then
exit 1
fi

mofos xpra start "${NAME}"

विशेषताएँ

VM शुरू या बंद करते समय सूचना सेट करें

libvirt/qemu मशीनों के शुरू होने और बंद होने की जानकारी पाने के लिए, libvirt qemu हुक को होस्ट उपयोगकर्ता का नाम निर्दिष्ट करने के लिए संशोधित किया जा सकता है (डिफ़ॉल्ट रूप से user):```

sed 's/USER = "user"/USER = "foobar"/' /etc/libvirt/hooks/qemu.d/90-mofos

### क्लिपबोर्ड

Mofos वर्चुअल मशीनों और होस्ट के बीच क्लिपबोर्ड को भी प्रबंधित कर सकता है। विचार यह है कि एक विशिष्ट keybind कॉन्फ़िगर किया जाए जो वर्तमान में फोकस किए गए VM के लिए SSH कनेक्शन ट्रिगर करे, या तो X11 क्लिपबोर्ड को खींचने के लिए या उसमें सामग्री पुश करने के लिए।

वर्चुअल मशीन के X11 क्लिपबोर्ड में सामग्री पुश करने के लिए:```
mofos clipboard in pentest-0

वर्चुअल मशीन X11 क्लिपबोर्ड से सामग्री खींचने के लिए:``` mofos clipboard out pentest-0

प्रत्येक ऑपरेशन के लिए, mofos वर्चुअल मशीन के लिए एक SSH कनेक्शन स्थापित करेगा और xclip का उपयोग करेगा, और होस्ट पर विंडो तकनीक (wayland बनाम X11) के अनुसार `wl-copy` या `xclip` का उपयोग करेगा।

ऊपर दिए गए ट्रेस में मशीन का नाम छोड़ा जा सकता है, ऐसे में स्क्रिप्ट वर्तमान में फोकस की गई वर्चुअल मशीन की पहचान करके उसे लक्षित करेगी।

यदि आप Gnome wayland का उपयोग कर रहे हैं, तो आपको `sudo make install_gnome_extension` का उपयोग करके [email protected] Gnome शेल एक्सटेंशन स्थापित करने की आवश्यकता हो सकती है।
यह सुनिश्चित करने के लिए कि एक्सटेंशन स्थापित है, आपको लॉग आउट करके फिर से लॉग इन करना होगा।

### मशीनों के बीच रूटिंग सेटअप करें

mofos में VM को रूट करने के लिए दो विकल्प मौजूद हैं:
- `mofos route` जो एक गेटवे लेता है और होस्ट पर एक `ip rule` कॉन्फ़िगर करता है ताकि वर्चुअल मशीन को इस गेटवे के माध्यम से रूट किया जा सके।
- `mofos pivot` जो एक अन्य mofos मशीन लेता है, उसका IP पता प्राप्त करता है और
उसे वर्तमान वर्चुअल मशीन के लिए डिफ़ॉल्ट गेटवे के रूप में कॉन्फ़िगर करता है।

दोनों विकल्प DNS सर्वर को कॉन्फ़िगर करने के लिए ले सकते हैं।

### पेंटेस्ट बॉक्स के माध्यम से टनलिंग सेटअप करें

`mofos tunnel` कमांड एक SSH vpn (`ssh -w`) सेट करता है ताकि एक
mofos मशीन का ट्रैफ़िक एक सर्वर के माध्यम से रूट हो सके। यह सुविधा कुछ कॉन्फ़िगरेशनों पर निर्भर करती है:

वास्तव में, `mofos tunnel` कमांड निम्नलिखित क्रियाएँ करता है (यहाँ कोई जादू नहीं है):
1. एक स्थानीय tun इंटरफ़ेस बनाएँ (`sudo /usr/libexec/mofos/mofosnet.py tun add pentest_box`) और इस इंटरफ़ेस को एक IP पता असाइन करें।
2. रिमोट सर्वर पर `tunneling.command` चलाएँ, इस कमांड को एक tun इंटरफ़ेस बनाना चाहिए जिसे फिर स्थानीय इंटरफ़ेस से जोड़ा जाएगा (`/usr/libexec/mofos/mofosnet.py sshvpn start pentest_box`)।
3. mofos मशीन के ट्रैफ़िक को रिमोट बॉक्स के गेटवे के माध्यम से रूट करें (`/usr/libexec/mofos/mofosnet.py route mofos_vm_ip gateway_ip`), mofos वर्चुअल मशीन का डिफ़ॉल्ट गेटवे भी बदल दिया जाता है।

`tunneling.command` को `/etc/mofos/mofosnet.toml` कॉन्फ़िगरेशन फ़ाइल में परिभाषित किया जाना चाहिए। उदाहरण के लिए:```toml
[tunneling.command]
start = "sudo ssh-vpn start"  # the peer remote address will be supplied as argv[1]
stop = "sudo ssh-vpn stop"

जहां तक route और pivot कमांड का सवाल है, उसे कॉन्फ़िगर करने के लिए एक DNS भी प्रदान किया जा सकता है।

USB प्रबंधन

mofos usb कमांड USB डिवाइसों को प्रबंधित करने की अनुमति देता है।

The `force` विकल्प किसी डिवाइस को अलग करता है और पुनः जोड़ता है। इसका उपयोग आमतौर पर किसी ऐसे डिवाइस को पुनः जोड़ने के लिए किया जाता है जिसे पहले अलग किए बिना अनप्लग कर दिया गया हो।

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

### PCI डिवाइस प्रबंधन

USB डिवाइसों के समान, mofos चल रही वर्चुअल मशीन में PCI डिवाइस जोड़ने की अनुमति देता है, कमांड समान हैं। 

एक अतिरिक्त सीमा कुछ PCI डिवाइसों से संबंधित है जो एक समूह से संबंधित होते हैं। उदाहरण के लिए, चल रही वर्चुअल मशीन में ईथरनेट बोर्ड जोड़ने के लिए पूरे PCI समूह को वर्चुअल मशीन के अंदर स्थानांतरित करने की आवश्यकता हो सकती है। चूँकि इसे क्रमिक रूप से नहीं किया जा सकता, यह अभी तक समर्थित नहीं है। हालाँकि, एक अद्वितीय PCI डिवाइस जैसे कि Wi-Fi नेटवर्क कार्ड के लिए, यह ठीक काम करता है।

### साझा फ़ोल्डर

`mofos mount` कमांड साझा फ़ोल्डर बनाता है और नए जोड़े गए फाइलसिस्टम को वर्चुअल मशीन के अंदर किसी निर्देशिका में माउंट कर सकता है। `mofos umount` निर्देशिका को अनमाउंट करेगा और वर्चुअल मशीन कॉन्फ़िगरेशन से साझा फ़ोल्डर हटा देगा।

यह तंत्र `virtiofsd` तकनीक पर निर्भर करता है, जिसके लिए साझा मेमोरी सक्षम करना आवश्यक है, यह अब वर्चुअल मशीन बनाते समय डिफ़ॉल्ट रूप से किया जाता है। अन्यथा, निम्न कमांड इसे सक्षम करेगा:```console
virt-xml -c qemu:///system --edit --memorybacking source.type=memfd,access.mode=shared DOMAIN

इसके अलावा, दिए गए AppArmor नीतियां उन निर्देशिकाओं को प्रतिबंधित करती हैं जिन्हें होस्ट द्वारा साझा किया जा सकता है। ऐसा आपके उपयोगकर्ता को /etc निर्देशिका या फाइलसिस्टम रूट पर साझाकरण कॉन्फ़िगर करने और वर्चुअल मशीन के भीतर रूट विशेषाधिकारों का उपयोग करके संशोधित करने से रोकने के लिए किया जाता है। इसलिए, मनमानी निर्देशिकाओं को साझा करने की अनुमति देने के लिए usr.lib.qemu.virtiofsd नीति को संशोधित करना आवश्यक है।

दो पंक्तियों को अनुकूलित किया जाना चाहिए:``` @{SHARE_DIRS}=/data/libvirt/shares// /home/user/Public/**/ [...] pivot_root /data/libvirt/shares//, pivot_root /home/user/Public/**/,

`SHARE_DIRS` वेरिएबल का पुनः उपयोग नीति में किया गया है, हालाँकि, apparmor की सीमाओं के कारण, `pivot_root` निर्देशों के लिए इसका पुनः उपयोग संभव नहीं है। इसलिए, प्रत्येक साझा निर्देशिका के लिए `pivot_root` निर्देशों को मैन्युअल रूप से अनुकूलित करना आवश्यक है।

स्थानीय निर्देशिका को माउंट करने के लिए:```
mofos mount test ./Public/share -d /home/user/share

जिस वर्चुअल मशीन पर शेयर माउंट किया जाना है, उसे बाधित न करने के लिए, यदि रिमोट निर्देशिका खाली नहीं है तो एक चेतावनी जारी की जाती है और स्क्रिप्ट आपको माउंट ऑपरेशन मैन्युअल रूप से करने देती है।

अंत में, माउंट ऑपरेशन स्थायी नहीं होता है और प्रत्येक रिबूट पर इसे फिर से जारी किया जाना चाहिए।

विंडोज़ मशीनें

विंडोज़ वर्चुअल मशीनें बनाने के लिए, पहले एक टेम्पलेट मशीन मैन्युअल रूप से बनाई जानी चाहिए। इस टेम्पलेट की डिस्क का उपयोग फिर चाइल्ड मशीनें बनाने के लिए बैकिंग फ़ाइल के रूप में किया जाता है। डिफ़ॉल्ट रूप से, Mofos के साथ बनाई गई विंडोज़ वर्चुअल मशीनें पूर्व-कॉन्फ़िगर नहीं होती हैं। हालाँकि, हुक का उपयोग करके Mofos को पोस्ट-कॉन्फ़िगरेशन कार्य करने के लिए कॉन्फ़िगर करना संभव है, जैसे कि होस्टनाम बदलना और known_hosts फ़ाइल में एक समर्पित प्रविष्टि जोड़ना।

पोस्ट-क्रिएशन सेटअप को सक्षम करने के लिए, निम्नलिखित पूर्वापेक्षाएँ अनिवार्य हैं:

OpenSSH सर्वर को सुनना (listening) चाहिए
एक SSH कुंजी को प्रशासक (Administrators) उपयोगकर्ता के रूप में सुचारू रूप से प्रमाणित करने के लिए कॉन्फ़िगर किया जाना चाहिए। authorized_keys को C:\Program Data\ssh\administrators_authorized_keys और विशिष्ट ACL में बनाना होता है```powershell $admin_group = "Administrators" $system = "SYSTEM"

$acl = Get-Acl C:\ProgramData\ssh\administrators_authorized_keys $acl.SetAccessRuleProtection($true, $false) $administratorsRule = New-Object system.security.accesscontrol.filesystemaccessrule($admin_group,"FullControl","Allow") $systemRule = New-Object system.security.accesscontrol.filesystemaccessrule($system,"FullControl","Allow") $acl.SetAccessRule($administratorsRule) $acl.SetAccessRule($systemRule) $acl | Set-Acl

- OpenSSH को एक `PowerShell` शेल के साथ कॉन्फ़िगर किया जाना चाहिए, न कि `cmd.exe` के साथ।```powershell
New-ItemProperty -Path "HKLM:\SOFTWARE\OpenSSH" `
                 -Name DefaultShell `
                 -Value "C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe" `
                 -PropertyType String `
                 -Force

विंडोज़ टेम्पलेट की SSH होस्ट कुंजी को $HOME/.local/share/mofos/ssh.json में परिभाषित किया जाना चाहिए। यह सुनिश्चित करेगा कि प्रत्येक नई मशीन के लिए संबंधित known_hosts प्रविष्टि टेम्पलेट होस्ट कुंजी के साथ बनाई जाए।
टेम्पलेट मशीन के मेटाडेटा को संशोधित करके उसे टेम्पलेट के रूप में पहचाना जाना चाहिए:``` mofos metadata update --set_template windows-server-template

## स्वतः पूर्णता

`bash` और `fish` के लिए स्वतः पूर्णता डिफ़ॉल्ट रूप से संभाल ली जानी चाहिए। `zsh` के लिए, निम्नलिखित कमांड चलाना आवश्यक हो सकता है:```
autoload -Uz compinit
compinit
source /usr/share/zsh/vendor-completions/_mofos

IP पते ओवरलैप

समान टेम्पलेट डिस्क पर आधारित वर्चुअल मशीनों को समान IP पता प्राप्त हो सकता है, भले ही DHCP पहचानकर्ता के कारण उनके नेटवर्क कार्ड का MAC पता बदल जाता है। यह व्यवहार टेम्पलेट की नेटवर्क कॉन्फ़िगरेशन को संपादित करके बदला जा सकता है:

systemd-networkd के साथ:``` [Match] Name=eth0

[Network] DHCP=yes MulticastDNS=no IPv6AcceptRA=no

[DHCP] ClientIdentifier=mac

विरासत नेटवर्क इंटरफ़ेस `/etc/network/interfaces` के साथ:```
iface eth0 inet dhcp
  client no

mofos

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

mofos

अवधारणा

स्थापना

होस्ट को कॉन्फ़िगर करें

QEMU/KVM सिस्टम सेशन

🔗 बाहरी आयात```

वर्चुअल मशीन बनाएँ

टेम्पलेट - हुक इंस्टॉल

During template installation, the machine is not yet managed by mofos,

the inventory would not working.

A custom inventory is created on the fly using the given tag as main ansible

group and the distribution as secondary.

Create inventory

🧭 फॉलो अप

📂 त्वरित अवलोकन

विशेषताएँ

VM शुरू या बंद करते समय सूचना सेट करें

sed 's/USER = "user"/USER = "foobar"/' /etc/libvirt/hooks/qemu.d/90-mofos

USB प्रबंधन

विंडोज़ मशीनें

IP पते ओवरलैप