foxcage

सुरक्षा अलगाव के लिए Firefox को रूटलेस Podman कंटेनर में चलाएँ। आपका ब्राउज़र लगभग बिना किसी Linux क्षमता के, अपने स्वयं के उपयोगकर्ता और नेटवर्क नेमस्पेस में, होस्ट से अलग चलता है — जबकि पूर्ण GPU त्वरण, ऑडियो और DRM समर्थन अभी भी बरकरार रहता है।

foxcage क्यों?

Firefox में पहले से ही एक मल्टी-प्रोसेस सैंडबॉक्स है जो Linux नेमस्पेस और seccomp-bpf का उपयोग करके वेब कंटेंट रेंडरर्स को अलग करता है। अधिकांश खतरों के लिए, यह प्रभावी है। foxcage एक दूसरी दीवार जोड़ता है: यदि कोई हमलावर Firefox के सैंडबॉक्स से बचने वाली कमजोरी का फायदा उठाता है (जो होता है — इसके लिए CVEs मौजूद हैं), तो वे आपके पूर्ण उपयोगकर्ता सत्र के बजाय एक लॉक-डाउन कंटेनर के अंदर पहुँचते हैं।

foxcage किससे सुरक्षा करता है

• पोस्ट-एक्सप्लॉइट फ़ाइल एक्सेस। बेयर Firefox पर सैंडबॉक्स एस्केप आपके उपयोगकर्ता द्वारा पढ़ी जा सकने वाली हर चीज़ तक पहुँच देता है: ~/.ssh, ~/.gnupg, अन्य ब्राउज़रों के ब्राउज़र प्रोफाइल, पासवर्ड मैनेजर डेटाबेस, दस्तावेज़, सोर्स कोड। foxcage में, हमलावर केवल वही देखता है जो आपने स्पष्ट रूप से माउंट किया है।
• डिस्क पर ट्रैकिंग अवशेष। @tmp अस्थायी केज विंडो बंद होने के बाद डिस्क पर शून्य निशान छोड़ता है — जिसमें एक्सटेंशन, HSTS स्थिति, TLS सत्र कैश और DNS कैश शामिल हैं जिन्हें Firefox का प्राइवेट ब्राउज़िंग अभी भी बनाए रखता है। कई @tmp केज बिना एक-दूसरे में हस्तक्षेप किए समवर्ती रूप से चलते हैं।
• स्थिरता (Persistence)। बेयर Firefox पर, मैलवेयर रिबूट के बाद बचने के लिए ~/.config/autostart, ~/.bashrc, cron या कहीं और लिख सकता है। foxcage का अस्थायी कंटेनर (--rm) का मतलब है कि जब तक आपने इसे बाइंड-माउंट नहीं किया है, कुछ भी स्थायी नहीं रहता।
• पार्श्व नेटवर्क गतिविधि। डिफ़ॉल्ट रूप से, कंटेनर localhost पर सेवाओं की जाँच नहीं कर सकता। बेयर Firefox पर, सैंडबॉक्स एस्केप के पास पूर्ण नेटवर्क एक्सेस होता है। (यदि किसी केज को localhost एक्सेस की आवश्यकता हो, जैसे स्थानीय विकास के लिए, तो [network] mode = "host" का उपयोग करें — लेकिन "नेटवर्किंग" के अंतर्गत चेतावनी देखें: होस्ट मोड होस्ट के अमूर्त Unix सॉकेट्स को भी उजागर करता है।)
• विशेषाधिकार वृद्धि। कंटेनर CAP_SYS_CHROOT को छोड़कर सभी Linux क्षमताओं को हटा देता है और नए विशेषाधिकार अधिग्रहण को रोकता है। Setuid बाइनरी, अस्पष्ट syscalls के माध्यम से कर्नेल एक्सप्लॉइट और समान वृद्धि पथ काट दिए जाते हैं।

foxcage किससे सुरक्षा नहीं करता

• ब्राउज़र-स्तरीय हमले। फ़िशिंग, दुर्भावनापूर्ण एक्सटेंशन और वह सब कुछ जो Firefox की सामान्य कार्यक्षमता के भीतर संचालित होता है, अप्रभावित रहता है — foxcage कंटेनर को होस्ट से अलग करता है, उपयोगकर्ता को ब्राउज़र से नहीं।
• बाइंड-माउंटेड निर्देशिकाएँ। आप जो कुछ भी माउंट करते हैं (profile, downloads_dir, अतिरिक्त बाइंड माउंट) एक समझौता किए गए ब्राउज़र के लिए पूरी तरह से सुलभ है। यदि आप होस्ट प्रोफाइल निर्देशिका माउंट करते हैं, तो एक हमलावर बेयर Firefox की तरह ही उसके साथ छेड़छाड़ कर सकता है।
• PulseAudio के माध्यम से ऑडियो कैप्चर। PulseAudio सॉकेट कंटेनर में बाइंड-माउंटेड है। हालाँकि यह फाइलसिस्टम स्तर पर केवल-पठनीय माउंटेड है, Unix डोमेन सॉकेट द्विदिशात्मक होते हैं — एक समझौता किया गया प्रक्रिया सॉकेट के माध्यम से रिकॉर्डिंग अनुरोध भेज सकती है। ब्राउज़र सैंडबॉक्स एस्केप संभावित रूप से होस्ट माइक्रोफोन से ऑडियो रिकॉर्ड कर सकता है।
• Wayland कम्पोज़िटर एक्सप्लॉइट। Wayland सॉकेट पास-थ्रू किया जाता है। Wayland कम्पोज़िटर डिज़ाइन द्वारा क्लाइंट को एक-दूसरे से अलग करते हैं, लेकिन कम्पोज़िटर में ही एक कमजोरी पहुँच योग्य होगी।

सुरक्षा कॉन्फ़िगरेशन

कंटेनर निम्नलिखित के साथ चलता है:

• सभी Linux क्षमताएँ हटा दी गई हैं (केवल CAP_SYS_CHROOT Firefox के कंटेंट सैंडबॉक्स के लिए वापस जोड़ा गया; CAP_SETUID/CAP_SETGID अस्थायी रूप से तब जोड़ा जाता है जब init.root कॉन्फ़िगर किया गया हो)
• विशेषाधिकार वृद्धि को रोकने के लिए no-new-privileges
• रूटलेस उपयोगकर्ता नेमस्पेस (--userns keep-id)
• निजी /dev/shm (होस्ट के साथ साझा नहीं) — shm_size के माध्यम से कॉन्फ़िगर करने योग्य आकार
• होस्ट लूपबैक डिफ़ॉल्ट रूप से अवरुद्ध के साथ pasta के माध्यम से पृथक नेटवर्किंग
• DNS डिफ़ॉल्ट रूप से होस्ट DNS का उपयोग करता है (network.dns के माध्यम से कॉन्फ़िगर करने योग्य)
• XDG_RUNTIME_DIR से केवल विशिष्ट सॉकेट बाइंड-माउंटेड हैं (Wayland, PulseAudio, PipeWire, और फ़िल्टर किया गया D-Bus प्रॉक्सी) — पूर्ण होस्ट रनटाइम निर्देशिका कभी उजागर नहीं होती
• होस्ट के D-Bus सत्र बस तक पहुँच हमेशा होस्ट पर चल रहे फ़िल्टर किए गए xdg-dbus-proxy द्वारा मध्यस्थ होती है। केवल , , , और (फोर्क्स के लिए) फोर्क का अपना नेमस्पेस (जैसे ) पहुँच योग्य हैं — कीरिंग और SSH/GPG एजेंट जैसी सत्र सेवाएँ अवरुद्ध हैं

प्रत्येक [network] और [mounts] विकल्प जिसे आप सक्षम करते हैं, सुविधा के लिए कुछ अलगाव का व्यापार करता है। डिफ़ॉल्ट सबसे प्रतिबंधात्मक कॉन्फ़िगरेशन है जो अभी भी आपको एक उपयोग योग्य ब्राउज़र देता है।

आवश्यकताएँ

• Python 3.11+
• Podman (रूटलेस)
• Wayland कम्पोज़िटर (X11 समर्थित नहीं है)
• pasta (sudo apt install passt) — जब तक network.mode = "host" न हो
• xdg-dbus-proxy (sudo apt install xdg-dbus-proxy)
• PulseAudio या PulseAudio संगतता के साथ PipeWire (ऑडियो के लिए)
• DRI समर्थन वाला GPU — वैकल्पिक; /dev/dri के बिना foxcage चेतावनी देता है और Firefox सॉफ़्टवेयर में रेंडर करता है। Intel, AMD और nouveau के लिए VA-API ड्राइवर छवि में स्थापित हैं, इसलिए हार्डवेयर वीडियो डिकोडिंग होस्ट ड्राइवर पैकेज के बिना काम करती है — हार्डवेयर वीडियो डिकोडिंग देखें

foxcage को अपने सामान्य डेस्कटॉप उपयोगकर्ता के रूप में चलाएँ, रूट या sudo के माध्यम से नहीं — सैंडबॉक्स आपके उपयोगकर्ता को कंटेनर में मैप करता है, और रूट के रूप में चलाने से वह अलगाव हट जाता है जिसे प्रदान करने के लिए foxcage मौजूद है। यह रूट के रूप में शुरू होने से इनकार करता है।

परीक्षण किया गया वातावरण: GNOME 3 के साथ Debian 13 (Trixie)। अन्य Linux वितरण और Wayland कम्पोज़िटर काम कर सकते हैं लेकिन परीक्षण नहीं किए गए हैं।

स्थापना

foxcage एक एकल Python स्क्रिप्ट है जिसमें Python मानक पुस्तकालय के बाहर कोई निर्भरता नहीं है। इसे अपने PATH में एक निर्देशिका में कॉपी करें:```sh sudo cp foxcage /usr/local/bin/foxcage

या उपयोगकर्ता-स्थानीय इंस्टॉल के लिए:```sh
cp foxcage ~/.local/bin/foxcage

स्क्रिप्ट को निष्पादन योग्य बनाएं (chmod +x foxcage)।

जाँचें कि आपके पास कौन सा रिवीज़न है foxcage --version से — यह समस्या की रिपोर्ट करते समय उपयोगी है, क्योंकि foxcage एक ही फ़ाइल की प्रतिलिपि बनाकर इंस्टॉल किया जाता है।

उपयोग```sh

./foxcage

पहली बार चलाने पर स्क्रिप्ट कंटेनर इमेज बनाती है (Mozilla से Firefox डाउनलोड करती है, न्यूनतम Debian निर्भरताएँ इंस्टॉल करती है) और फिर Firefox शुरू करती है। बाद के रनों में, foxcage Firefox अपडेट की जाँच करता है और जब कोई नया संस्करण उपलब्ध होता है तो इमेज को स्वचालित रूप से फिर से बनाता है। इमेज को समय-समय पर (डिफ़ॉल्ट रूप से हर 7 दिन में) भी फिर से बनाया जाता है ताकि सिस्टम पैकेज अपडेट मिल सकें। यदि अपडेट जाँच विफल हो जाती है (नेटवर्क त्रुटि, टाइमआउट), तो एक चेतावनी लॉग की जाती है और मौजूदा इमेज का उपयोग किया जाता है — स्टार्टअप कभी अवरुद्ध नहीं होता।

Firefox को तर्क पास करें:```sh
./foxcage https://example.com

एक नामित केज को Firefox फ्लैग्स के साथ संयोजित करें:```sh ./foxcage @work --kiosk https://example.com

यदि कोई cage पहले से चल रहा है, तो URL मौजूदा ब्राउज़र में एक नए टैब में खुलता है, दूसरा कंटेनर शुरू करने के बजाय। चल रहे cage के विरुद्ध बिना URL के `foxcage` (या `foxcage @cage`) चलाने पर "cage is already running" संदेश के साथ साफ़-सुथरा निकास होता है — foxcage कंटेनर के बाहर से किसी मौजूदा Wayland विंडो को ऊपर नहीं ला सकता, इसलिए वह कोशिश नहीं करता।

प्रति-लॉन्च फ़्लैग तब लागू **नहीं** होते जब cage पहले से चल रहा हो। `--dns`, `--ipv4-only`, `--lifetime`, `--color` और `--fork` कंटेनर शुरू होने पर उपभोग किए जाते हैं, और चल रहे कंटेनर की सेटिंग्स को बाहर से बदला नहीं जा सकता, इसलिए उन्हें चेतावनी के साथ अनदेखा किया जाता है। उन्हें लागू करने के लिए cage बंद करें और फिर से चलाएँ।

> प्राइवेट-मोड सत्रों के लिए `private_browsing` कॉन्फ़िग कुंजी का उपयोग करें — Firefox के कच्चे `--private-window` CLI फ़्लैग का *नहीं*। कॉन्फ़िग कुंजी सत्र-व्यापी प्राइवेट मोड (`browser.privatebrowsing.autostart`) सेट करती है, इसलिए बाद के `foxcage @cage URL` आह्वान टैब में फिर से खोल सकते हैं। Firefox पासथ्रू के रूप में `--private-window` केवल पहली विंडो को प्राइवेट बनाएगा और ऊपर दिए गए टैब-में-फिर-से-खोलने के व्यवहार को तोड़ देगा।
>
> **सावधानी:** `private_browsing = true` के माध्यम से सक्षम सत्र Firefox के सामान्य प्राइवेट-विंडो UI संकेत (बैंगनी एक्सेंट बार, मास्क आइकन, शीर्षक में "(Private Browsing)") नहीं दिखाते। ऐसा इसलिए है क्योंकि सत्र की हर विंडो प्राइवेट है, इसलिए Firefox के पास दृश्य रूप से तुलना करने के लिए कोई गैर-प्राइवेट विंडो नहीं होती — वह संकेतक को दबा देता है। सत्र वास्तव में प्राइवेट *होता* है; यदि आप चाहें तो cage में `about:privatebrowsing` पर जाकर (मानक Private Browsing जानकारी पृष्ठ दिखाता है) या `about:config` पर जाकर `browser.privatebrowsing.autostart = true` जाँचकर सत्यापित करें।

### `@tmp` के साथ क्षणिक ब्राउज़िंग

ऐसे एक-बार के लिंक के लिए जो कोई निशान न छोड़ें, आरक्षित `tmp` cage का उपयोग करें:```sh
./foxcage @tmp https://somewhere-suspicious.example

हर @tmp लॉन्च एक नया, डिस्पोज़ेबल Firefox होता है जिसमें कोई स्थायी प्रोफ़ाइल नहीं होती। जब विंडो बंद होती है, सब कुछ मिट जाता है — कुकीज़, कैश, इतिहास, एक्सटेंशन, HSTS स्टेट, TLS सत्र कैश, DNS कैश, सेव किया गया टैब स्टेट। यह Firefox प्राइवेट ब्राउज़िंग से भी आगे जाता है, जो अभी भी एक्सटेंशन और डिस्क पर काफी मात्रा में स्टेट बनाए रखता है।

कई @tmp केज एक साथ चलते हैं, प्रत्येक दूसरों से अलग-थलग होता है। मेन्यू बार FoxCage - tmp (<short id>) दिखाता है ताकि आप समवर्ती अस्थायी विंडो को अलग पहचान सकें।

एफेमरल केज स्टार्टअप पर एक खाली पेज और खाली नए टैब खोलते हैं — डिफ़ॉल्ट Firefox होम पेज और नए-टैब सामग्री (टॉप साइट्स, Pocket अनुशंसाएँ, एक्टिविटी स्ट्रीम) एक नई प्रोफ़ाइल पर शुद्ध शोर होती हैं जिसे फेंकने वाला है, इसलिए उन्हें दबा दिया जाता है। स्थायी केज Firefox के डिफ़ॉल्ट बनाए रखते हैं।

नामित एफेमरल केज

यदि आप एक डिस्पोज़ेबल सत्र पर एक सार्थक नाम चाहते हैं (जैसे, एक शोध की खोज जिसे आप नए टैब में फिर से खोलना चाहेंगे), तो @tmp-<name> का उपयोग करें:```sh ./foxcage @tmp-research https://example.com # first call → new window ./foxcage @tmp-research https://another.example # second call → new tab in the existing window

`@tmp-<name>` अभी भी अस्थायी है — जब आप विंडो बंद करते हैं, तो सब कुछ चला जाता है। बेयर `@tmp` से अंतर यह है कि उसी नाम के साथ दूसरी बार लॉन्च करने पर **मौजूदा विंडो का पुन: उपयोग होता है** (स्थायी केजेस के समान), इसलिए आप बाद में समानांतर कॉपी शुरू किए बिना और टैब जोड़ सकते हैं। बेयर `@tmp` अपना "हर लॉन्च एक नया थ्रोअवे" व्यवहार बनाए रखता है।

मेनू-बार लेबल आपके द्वारा चुना गया नाम दिखाता है (`FoxCage - tmp-research`), इसलिए विंडो सार्थक रूप से लेबल होती है।

#### अस्थायी डिफ़ॉल्ट को अनुकूलित करना

सभी अस्थायी केजेस (बेयर `@tmp` और हर `@tmp-<name>` दोनों) के लिए डिफ़ॉल्ट सेट करने हेतु `~/.config/foxcage/tmp.toml` बनाएं। उदाहरण के लिए:```toml
private_browsing = true
lifetime = "30m"
extensions = ["ublock-origin"]

[network]
dns = "cloudflare"

हर एपिसोडिक लॉन्च को अब एक प्राइवेट विंडो, uBlock Origin, Cloudflare DoH मिलता है, और यह 30 मिनट के बाद अपने आप बंद हो जाता है — पूर्ण एपिसोडिकता बरकरार रहती है। नामित एपिसोडिक कॉन्फ़िगरेशन डिफ़ॉल्ट रूप से tmp.toml इनहेरिट करते हैं; यदि आप प्रति नाम ओवरराइड करना चाहते हैं, तो ~/.config/foxcage/tmp-<name>.toml बनाएँ। वह फ़ाइल तब tmp.toml के बजाय लागू होती है — कोई मर्जिंग नहीं, अधिक विशिष्ट फ़ाइल सीधे जीतती है। यदि आप उन्हें चाहते हैं तो साझा डिफ़ॉल्ट उसमें कॉपी करें।

नियमित केज के कॉन्फ़िग में जो कुछ भी सेट कर सकते हैं, वह यहाँ काम करता है, सिवाय उस एक कुंजी के जो एपिसोडिकता को ही खत्म कर देगी:

• profile — हार्ड एरर।

यह होस्ट पर एक स्थायी प्रोफ़ाइल निर्देशिका की ओर इशारा करता है, जो सीधे @tmp के उद्देश्य का खंडन करता है। यदि आप स्थायी प्रोफ़ाइल वाला सैंडबॉक्स्ड केज चाहते हैं, तो एक नियमित नामित केज (@work, @research, आदि) का उपयोग करें जो tmp- से शुरू नहीं होता।

पहले से इंस्टॉल किए गए एक्सटेंशन

एक केज में उसकी इमेज में बेक किए गए एक्सटेंशन हो सकते हैं और हर लॉन्च पर फोर्स-इंस्टॉल किए जा सकते हैं:```toml extensions = ["ublock-origin"]

इसे `~/.config/foxcage/tmp.toml` में रखें और **हर अस्थायी (throwaway) cage में uBlock Origin पहले से चालू रहता है** — जो मायने रखता है, क्योंकि एक क्षणिक (ephemeral) cage अन्यथा आपके पास सबसे कम सुरक्षित ब्राउज़र होता है, जिसका उपयोग ठीक उन्हीं लिंक्स पर होता है जिन पर आप सबसे कम भरोसा करते हैं। एक नया `@tmp` प्रोफ़ाइल में कोई एक्सटेंशन नहीं होता है, और बंद होने पर खुद को नष्ट करने वाले सत्र में इसे हाथ से इंस्टॉल करना व्यर्थ है।

प्रत्येक प्रविष्टि add-on के addons.mozilla.org URL से लिया गया छोटा नाम, लिस्टिंग URL स्वयं, या add-on ID हो सकती है:```toml
extensions = [
    "ublock-origin",
    "https://addons.mozilla.org/firefox/addon/noscript/",
    "[email protected]",
]

एड-ऑन लॉन्च के समय addons.mozilla.org API के माध्यम से हल किए जाते हैं, इमेज बिल्ड के दौरान डाउनलोड किए जाते हैं, और AMO द्वारा प्रकाशित SHA-256 के विरुद्ध सत्यापित किए जाते हैं। हल किया गया संस्करण Containerfile का हिस्सा होता है, इसलिए एक एक्सटेंशन का नया रिलीज़ इमेज हैश बदल देता है और पुनर्निर्माण को ट्रिगर करता है — एक्सटेंशन उसी तरह अपडेट होते हैं जैसे Firefox करता है, और उसी कारण से: रनटाइम पर कुछ भी इंस्टॉल नहीं होता, इसलिए एक नया अस्थायी प्रोफ़ाइल कभी भी कुछ पुनः डाउनलोड नहीं करता।

क्योंकि वे हाथ से नहीं बल्कि एंटरप्राइज़ नीति द्वारा इंस्टॉल किए जाते हैं:

• उन्हें केज के अंदर से हटाया या अक्षम नहीं किया जा सकता (about:addons उन्हें आपके संगठन द्वारा इंस्टॉल किए गए के रूप में दिखाता है)।
• वे निजी विंडो में सक्षम होते हैं, इसलिए वे private_browsing = true चलाने वाले केज में भी काम करते हैं। इसके लिए Firefox 136 या ESR 128.8 की आवश्यकता होती है; पुराने संस्करण सेटिंग को अनदेखा कर देते हैं और एड-ऑन को निजी विंडो में निष्क्रिय छोड़ देते हैं।
• उनका आइकन टूलबार में रखा जाता है, ताकि आप देख सकें कि ब्लॉकर वास्तव में वहाँ है।
• ब्राउज़र के भीतर एक्सटेंशन अपडेट बंद हैं। अपडेट इमेज पुनर्निर्माण के साथ आते हैं।

सीमाएँ:

• केवल AMO। एक्सटेंशन addons.mozilla.org पर सूचीबद्ध होने चाहिए — वह लुकअप ही वह एड-ऑन ID प्रदान करता है जिसकी एक नीति प्रविष्टि को आवश्यकता होती है, साथ ही वह डाइजेस्ट जिसे बिल्ड सत्यापित करता है। एक बेयर .xpi URL अस्वीकार कर दिया जाता है।
• कोई संस्करण पिनिंग नहीं। एक पुनर्निर्माण वही लेता है जो AMO वर्तमान में एड-ऑन के नवीनतम संस्करण के रूप में सूचीबद्ध करता है।
• बिल्ड करने के लिए AMO तक पहुँच होनी चाहिए। यदि लुकअप विफल हो जाता है और केज के पास पहले से एक इमेज है, तो foxcage चेतावनी देता है और मौजूदा इमेज के साथ लॉन्च होता है; यदि केज के पास अभी तक कोई इमेज नहीं है, तो यह बाहर निकल जाता है बजाय उन एड-ऑन के बिना चुपचाप एक केज बनाने के जिन्हें आपने माँगा था।
• सभी अस्थायी केज एक इमेज साझा करते हैं। @tmp और हर @tmp-<name> एक एकल foxcage-tmp इमेज बनाते हैं, इसलिए एक नामित अस्थायी को tmp.toml से भिन्न extensions सूची देना दोनों को वैकल्पिक लॉन्च पर एक-दूसरे के ऊपर पुनर्निर्माण करने पर मजबूर करता है। अस्थायी एक्सटेंशन सूचियाँ tmp.toml में रखें।

प्रति लॉन्च DNS ओवरराइड करना

--dns फ़्लैग (और समतुल्य network.dns कॉन्फ़िग कुंजी) तीन रूप स्वीकार करता है:```sh ./foxcage @tmp --dns 1.1.1.1 https://example.com # IP ./foxcage @tmp --dns cloudflare https://example.com # alias ./foxcage @tmp --dns https://dns.nextdns.io/ # custom DoH URI

**जब मान किसी ज्ञात प्रदाता (alias या IP द्वारा) से मेल खाता है, तो foxcage स्वचालित रूप से उस प्रदाता के लिए forced DNS over HTTPS सक्षम कर देता है।** Firefox का TRR मोड 3 (strict, बिना cleartext fallback) पर सेट हो जाता है, जिसमें bootstrap address भरा होता है ताकि स्टार्टअप पर कोई अनएन्क्रिप्टेड रिज़ॉल्यूशन लीक न हो। आपको stderr पर एक-पंक्ति का नोटिस दिखता है जैसे `Enabling DNS over HTTPS via Cloudflare`।

बिल्ट-इन aliases:

| Alias | IP | फ़िल्टरिंग |
|-------|------|-----------|
| `cloudflare` | 1.1.1.1 | कोई नहीं |
| `cloudflare-security` | 1.1.1.2 | मैलवेयर ब्लॉक करता है |
| `cloudflare-family` | 1.1.1.3 | मैलवेयर + वयस्क सामग्री ब्लॉक करता है |
| `google` | 8.8.8.8 | कोई नहीं |
| `quad9` | 9.9.9.9 | मैलवेयर ब्लॉक करता है (Quad9 डिफ़ॉल्ट) |
| `quad9-unfiltered` | 9.9.9.10 | कोई नहीं |
| `adguard` | 94.140.14.14 | विज्ञापन + ट्रैकर ब्लॉक करता है |
| `adguard-family` | 94.140.14.15 | विज्ञापन + ट्रैकर + वयस्क सामग्री |
| `opendns` | 208.67.222.222 | कुछ |

एक IP जो तालिका में नहीं है (जैसे आपके LAN का Pi-hole) केवल cleartext रहता है — कोई DoH सक्षम नहीं होता, क्योंकि foxcage को संबंधित DoH endpoint का पता नहीं होता। उसके लिए URI फ़ॉर्म का उपयोग करें: `--dns https://pi.hole/dns-query` (मान्य cert के साथ) DoH सक्षम करता है और कंटेनर DNS को अकेला छोड़ देता है।

URI फ़ॉर्म कंटेनर का cleartext DNS सेट करना छोड़ देता है, इसलिए कंटेनर के अंदर जो कुछ भी Firefox नहीं है वह अभी भी होस्ट के DNS का उपयोग करता है। यह जानबूझकर किया गया है — `--dns URI` का अर्थ है "Firefox को इस DoH resolver का उपयोग कराएं", बस इतना ही।

`--dns` `network.mode = "host"` के साथ असंगत है, जिसके पास पहले से ही पूर्ण होस्ट नेटवर्क एक्सेस है।

### विज़ुअल cage पहचान

हर नामित cage को मेनू बार में एक accent रंग मिलता है ताकि आप विंडोज़ को एक नज़र में अलग कर सकें। **आपको कुछ भी कॉन्फ़िगर करने की आवश्यकता नहीं है** — रंग cage नाम से निर्धारित रूप से (deterministically) प्राप्त होता है (SHA256-हैश करके hue में, निश्चित saturation और lightness के साथ)। `@banking`, `@work`, `@personal`, `@tmp-research` सभी को बिना किसी प्रयास के अलग, स्थिर रंग मिलते हैं।

डिफ़ॉल्ट (अनाम) cage बिल्ट-इन नारंगी रंग रखता है।

यदि आप स्वतः-प्राप्त रंग को ओवरराइड करना चाहते हैं, तो इसे स्पष्ट रूप से सेट करें:```toml
# ~/.config/foxcage/banking.toml
color = "#dc2626"   # red — overrides the auto-derived colour

यहाँ आपका अनुवाद है:

## स्थापना

### आवश्यक शर्तें

- Python 3.8+
- pip (Python पैकेज मैनेजर)

### चरण-दर-चरण स्थापना

```bash
# रिपॉजिटरी क्लोन करें
git clone https://github.com/example/tool.git
cd tool

# (वैकल्पिक) एक वर्चुअल वातावरण बनाएं
python -m venv venv
source venv/bin/activate  # Linux/macOS पर
# या Windows पर:
# venv\Scripts\activate

# आवश्यक निर्भरताएँ स्थापित करें
pip install -r requirements.txt

# टूल स्थापित करें
pip install -e .

डॉकर के माध्यम से स्थापना

यदि आप डॉकर पसंद करते हैं, तो आप प्रदान की गई डॉकरफाइल का उपयोग कर सकते हैं:

# डॉकर इमेज बनाएं
docker build -t tool-name .

# कंटेनर चलाएं
docker run -it --rm tool-name --help

उपयोग

मूल उपयोग

टूल का उपयोग करने के लिए, बस निम्नलिखित कमांड चलाएँ:

tool-name --target example.com

कमांड-लाइन विकल्प

उदाहरण

एक सरल स्कैन:

tool-name --target https://example.com

परिणामों को फ़ाइल में सहेजना:

tool-name --target https://example.com --output results.json

उन्नत विकल्पों के साथ:

tool-name --target https://example.com --threads 50 --timeout 60 --verbose --proxy http://127.0.0.1:8080

एक साथ कई लक्ष्यों को स्कैन करना:

tool-name --target-list targets.txt --output scan_results.json

विन्यास

टूल को कमांड-लाइन तर्कों या एक विन्यास फ़ाइल के माध्यम से विन्यस्त किया जा सकता है। विन्यास फ़ाइल YAML प्रारूप में है और इसे --config विकल्प के साथ निर्दिष्ट किया जा सकता है।

नमूना विन्यास फ़ाइल

# config.yaml
target: https://example.com
threads: 20
timeout: 45
verbose: true
output: results.json
proxy: http://127.0.0.1:8080
user_agent: "MyCustomAgent/1.0"

पर्यावरण चर

निम्नलिखित पर्यावरण चर भी समर्थित हैं:

आउटपुट प्रारूप

टूल JSON और प्लेन टेक्स्ट दोनों प्रारूपों में परिणाम आउटपुट कर सकता है। डिफ़ॉल्ट आउटपुट प्रारूप JSON है।

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

{
  "target": "https://example.com",
  "scan_started": "2024-01-15T10:30:00Z",
  "scan_completed": "2024-01-15T10:30:45Z",
  "total_findings": 3,
  "findings": [
    {
      "type": "open_port",
      "port": 443,
      "service": "https",
      "severity": "low",
      "description": "HTTPS पोर्ट खुला है"
    },
    {
      "type": "vulnerability",
      "cve_id": "CVE-2024-1234",
      "severity": "high",
      "description": "दूरस्थ कोड निष्पादन की अनुमति देने वाली भेद्यता"
    }
  ]
}

प्लेन टेक्स्ट आउटपुट उदाहरण

[+] लक्ष्य: https://example.com
[+] स्कैन प्रारंभ: 2024-01-15T10:30:00Z
[+] स्कैन पूर्ण: 2024-01-15T10:30:45Z
[+] कुल निष्कर्ष: 3

[+] निष्कर्ष:
  - प्रकार: open_port | पोर्ट: 443 | सेवा: https | गंभीरता: low
  - प्रकार: vulnerability | CVE: CVE-2024-1234 | गंभीरता: high

योगदान

योगदान का स्वागत है! कृपया सुनिश्चित करें कि आप योगदान करने से पहले निम्नलिखित दिशानिर्देशों का पालन करें:

1. रिपॉजिटरी को फोर्क करें
2. अपनी सुविधा शाखा बनाएं (git checkout -b feature/amazing-feature)
3. अपने परिवर्तनों को कमिट करें (git commit -m 'Add some amazing feature')
4. शाखा को पुश करें (git push origin feature/amazing-feature)
5. एक पुल अनुरोध खोलें

विकास सेटअप

# विकास निर्भरताएँ स्थापित करें
pip install -r requirements-dev.txt

# परीक्षण चलाएँ
pytest tests/

# लिंटिंग
flake8 src/

लाइसेंस

यह परियोजना MIT लाइसेंस के तहत लाइसेंस प्राप्त है - विवरण के लिए LICENSE फ़ाइल देखें।

अस्वीकरण

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

संपर्क

प्रश्नों या सुझावों के लिए, कृपया GitHub पर एक मुद्दा खोलें या [email protected] पर ईमेल करें।

चेंजलॉग

v1.0.0 (2024-01-15)

• प्रारंभिक रिलीज़
• बुनियादी स्कैनिंग क्षमताएँ
• JSON और प्लेन टेक्स्ट आउटपुट समर्थन
• विन्यास फ़ाइल समर्थन
• पर्यावरण चर समर्थन

v0.9.0 (2023-12-20)

• बीटा रिलीज़
• प्रारंभिक स्कैनिंग इंजन
• कमांड-लाइन इंटरफ़ेस

**अनुवाद नोट्स:**
- तकनीकी शब्द (जैसे `git clone`, `pip install`, `docker build`, `pytest`, `flake8`, `CVE-2024-1234`, `config.yaml`, `requirements.txt`) को अपरिवर्तित रखा गया है क्योंकि वे कोड/कमांड हैं।
- सभी Markdown संरचना (शीर्षक, तालिकाएँ, कोड ब्लॉक, लिंक) को बिल्कुल वैसा ही संरक्षित किया गया है।
- प्राकृतिक भाषा पाठ (विवरण, निर्देश, अस्वीकरण) का हिंदी में अनुवाद किया गया है।```sh
./foxcage @experiment --color "#10b981" https://example.com   # teal, one-off

Accepts standard CSS hex: #rgb, #rrggbb, या #rrggbbaa (alpha के साथ)। स्वतः-व्युत्पन्न रंग हल्के और गहरे दोनों मेनबार पर दिखाई देने के लिए ट्यून किए गए हैं (lightness 55% पर, saturation 75% पर), इसलिए थीम कारणों से override करने की आवश्यकता नहीं होनी चाहिए।

समय-सीमित cages

--lifetime फ़्लैग (और समतुल्य lifetime config key) एक निर्धारित अवधि के बाद cage को स्वतः बंद कर देता है। फ़ॉर्मेट <number><unit> है, जिसमें unit s, m, या h हो सकता है:```sh ./foxcage @tmp --lifetime 10m https://example.com ./foxcage @work --lifetime 2h

काउंटडाउन तब शुरू होता है जब Firefox वास्तव में केज के अंदर लॉन्च होता है — कंटेनर स्टार्टअप और इमेज-बिल्ड समय आपके बजट में नहीं गिना जाता। केज का मेनू-बार लेबल केज पहचान के साथ काउंटडाउन दिखाता है — जैसे `FoxCage - tmp (a3f2b1) | 9m` — जब एक मिनट से अधिक समय बचा हो तो हर मिनट एक बार अपडेट होता है, और अंतिम मिनट में हर सेकंड एक बार। जब काउंटडाउन शून्य पर पहुँचता है, Firefox स्वयं बंद हो जाता है और कंटेनर बाहर निकल जाता है। यदि आप लाइफटाइम समाप्त होने से पहले स्वयं Firefox बंद करते हैं, तो कुछ भी असामान्य नहीं होता।

प्रत्येक केज के लिए उसके कॉन्फ़िग में एक डिफ़ॉल्ट लाइफटाइम सेट करें:```toml
# ~/.config/foxcage/tmp.toml — every @tmp launch auto-closes after 15 minutes
lifetime = "15m"
private_browsing = true

--lifetime कमांड लाइन पर किसी भी कॉन्फ़िग मान से अधिक प्राथमिकता रखता है।

पूर्ण इमेज रीबिल्ड को बल दें (Firefox और सभी सिस्टम पैकेज फिर से डाउनलोड होते हैं):```sh ./foxcage --rebuild

एक चालू कंटेनर उसी इमेज को बनाए रखता है जिससे उसे शुरू किया गया था, भले ही foxcage इमेज टैग को फिर से बनाए। यदि आप किसी ऐसे cage में टैब खोलने का प्रयास करते हैं जिसकी इमेज को तब से अपडेट किया गया है (`--rebuild`, Firefox अपडेट, या निर्धारित पुनर्निर्माण द्वारा), foxcage एक त्रुटि के साथ मना कर देता है (जो डेस्कटॉप सूचना के रूप में भी दिखाई देती है) और आपसे Firefox को बंद करके फिर से लॉन्च करने के लिए कहता है — जो वर्तमान इमेज पर एक नया कंटेनर शुरू करता है। लाइव cage के साथ `--rebuild` के तहत, foxcage पहले से चेतावनी देता है, बिल्ड करता है, और फिर वही जाँच लागू करता है।

### अपडेट

foxcage हर लॉन्च पर नए ब्राउज़र रिलीज़ की जाँच करता है — Firefox के लिए Mozilla का रिलीज़ API, LibreWolf के लिए GitLab का रिलीज़ एंडपॉइंट। यदि कोई अपडेट उपलब्ध है, तो कंटेनर इमेज स्वचालित रूप से फिर से बनाई जाती है। इमेज को समय-समय पर (डिफ़ॉल्ट रूप से हर 7 दिन में) Debian सुरक्षा अपडेट लेने के लिए भी फिर से बनाया जाता है। ब्राउज़र का अंतर्निहित ऑटो-अपडेटर अक्षम है क्योंकि अपडेट इमेज स्तर पर संभाले जाते हैं।

यदि अपडेट जाँच विफल हो जाती है (कोई नेटवर्क नहीं, API टाइमआउट), एक चेतावनी मुद्रित होती है और मौजूदा इमेज का उपयोग किया जाता है — आप हमेशा ब्राउज़ कर सकते हैं।

अपडेट की आवृत्ति कॉन्फ़िग के शीर्ष स्तर पर रहती है; संस्करण और चैनल पिनिंग प्रति-फोर्क अनुभाग में रहती है:```toml
rebuild_days = 14      # rebuild for base-image updates every 14 days (0 to disable)

[firefox]
channel = "beta"       # track the beta channel instead of stable (firefox only)
version = "149"        # pin to Firefox 149.x (latest patch release)

ESR संस्करण को पिन करने के लिए चैनल की भी आवश्यकता होती है। Mozilla का संस्करण इंडेक्स ESR रिलीज़ को उनके डाउनलोड में मौजूद esr प्रत्यय के बिना सूचीबद्ध करता है, इसलिए डिफ़ॉल्ट चैनल पर एक साधारण version = "140" एक ऐसे रिलीज़ को हल करता है जो मौजूद नहीं है। दोनों सेट करें:```toml [firefox] channel = "esr" version = "140" # → 140.13.0esr

एक पिन जो किसी रिलीज़ से मेल नहीं खाती, अब चुपचाप नवीनतम रिलीज़ पर वापस गिरने के बजाय पिन का नाम बताते हुए एक त्रुटि है। Mozilla के API तक पहुंचने में अस्थायी विफलता अभी भी चेतावनी देती है और मौजूदा इमेज के साथ आगे बढ़ती है, ताकि अस्थिर नेटवर्क कभी भी स्टार्टअप को अवरुद्ध न करे।

सफिक्स्ड पिन पूरी तरह से योग्य होनी चाहिए — `"140.13.0esr"` और `"150.0b9"` काम करते हैं, `"140esr"` और `"150b9"` को कॉन्फ़िग लोड पर अस्वीकार कर दिया जाता है क्योंकि कोई भी रिलीज़ उनसे कभी मेल नहीं खा सकती। यही बात LibreWolf रिवीज़न पर भी लागू होती है: `"146.0.1-1"` काम करता है, `"146-1"` नहीं।

तुरंत पूर्ण रीबिल्ड करने के लिए: `./foxcage --rebuild`

### रद्द की गई साइनिंग कुंजियाँ

foxcage उस ब्राउज़र बिल्ड को स्थापित करने से इनकार करता है जिसके हस्ताक्षर उस साइनिंग सबकी द्वारा किए गए हैं जिसे अपस्ट्रीम प्रोजेक्ट ने **समझौता** (RFC 4880 रद्दीकरण कारण `0x02`) के रूप में रद्द कर दिया है। `gpg --verify` यह अपने आप नहीं करता: यह एक चेतावनी प्रिंट करता है और 0 के साथ बाहर निकलता है, इसलिए अतिरिक्त जांच के बिना एक लीक हुई साइनिंग कुंजी अभी भी छेड़छाड़ किए गए डाउनलोड को प्रमाणित कर देगी।

इनकार इस तरह दिखता है, और स्थापित करने के बजाय बिल्ड को विफल कर देता है:```
foxcage: REFUSING /tmp/SHA512SUMS - signed by 09BEED63F3462A2DFFAB3B875ECB6497C1A20256,
which its owner revoked as compromised.  This build cannot be trusted; wait for
upstream to re-sign this release with a current key.

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

नियमित कुंजी रोटेशन को अलग तरह से संभाला जाता है। एक सबकी जिसे प्रतिस्थापित, सेवानिवृत्त, या बिना किसी कारण के रद्द किया गया है, वह रद्दीकरण से पहले किए गए हस्ताक्षरों को अमान्य नहीं करती है, इसलिए वे रिलीज़ चेतावनी के साथ इंस्टॉल होती हैं। किसी भी रद्दीकरण के बाद दिनांकित हस्ताक्षर, बताए गए कारण चाहे जो भी हो, अस्वीकार कर दिए जाते हैं।

Mozilla का अगस्त 2026 कुंजी रोटेशन। Mozilla ने 2026-08-06 को हस्ताक्षर सबकी 09BEED63…C1A20256 को रद्द कर दिया, जब इसकी एक अनएन्क्रिप्टेड प्रति एक निजी GitHub रिपॉज़िटरी में कमिट कर दी गई थी, और इसे 827E6586…76767AA3 से बदल दिया। पुरानी सबकी से हस्ताक्षरित Firefox रिलीज़ — 2025-03-13 और 2026-08-06 के बीच की हर चीज़, जिसमें लेखन के समय वर्तमान ESR (140.13.0esr) और उस विंडो में कोई भी version पिन शामिल है — उपरोक्त जाँच द्वारा अस्वीकार कर दी जाती हैं। रिलीज़ और बीटा चैनल प्रभावित नहीं हैं। foxcage कुंजियाँ keys.openpgp.org से लाता है, न कि keyserver.ubuntu.com से, क्योंकि बाद वाला रोटेशन के बाद दिनों तक न तो प्रतिस्थापन सबकी और न ही रद्दीकरण प्रदान करता था; एक पुराना कीसर्वर बिल्ड को पूरी तरह से तोड़ने के साथ-साथ रद्दीकरण जाँच को चुपचाप एक नो-ऑप में बदल देता।

Firefox फ़ोर्क (LibreWolf)

foxcage अपस्ट्रीम Firefox के स्थान पर एक गोपनीयता-केंद्रित Firefox फ़ोर्क चला सकता है:```toml fork = "librewolf" # default is "firefox"

[librewolf] version = "146.0.1-1" # optional pin; partial pins ("146", "146.0.1") also work

या प्रति-लॉन्च CLI के माध्यम से:```sh
foxcage @tmp --fork librewolf https://example.com

LibreWolf: गोपनीयता-कठोर Firefox फोर्क — सख्त ट्रैकिंग सुरक्षा, DoH, RFP, टेलीमेट्री डिफ़ॉल्ट रूप से बंद। GitLab (librewolf-community/browser/bsys6) से हस्ताक्षरित Linux tarball, LibreWolf Maintainers कुंजी 662E 3CDD 6FE3 2900 2D0C A5BB 4033 9DD8 2B12 EF16 के विरुद्ध GPG-सत्यापित, एक सहयोगी .sha256sum क्रॉस-चेक के साथ, Firefox के समान निरस्तीकरण नियमों के अंतर्गत। LibreWolf का बंडल किया गया librewolf.cfg संरक्षित है; foxcage अपनी स्वयं की प्राथमिकताएँ ओवरराइट करने के बजाय उसके ऊपर जोड़ता है। मेंटेनर्स ने 2026-04-25 को बिना कारण बताए अपनी साइनिंग सबकुंजी घुमाई; वर्तमान tarballs उस तिथि से पहले हस्ताक्षरित थे, इसलिए वे अस्वीकार किए जाने के बजाय चेतावनी के साथ इंस्टॉल होते हैं।

चैनल केवल Firefox-विशिष्ट है: firefox.channel = "beta" | "esr" तब अस्वीकार किया जाता है जब fork "firefox" के अलावा कुछ और हो। LibreWolf का एक ही रिलीज़ ट्रैक है।

fork स्विच करना (config या --fork के माध्यम से) Containerfile हैश बदल देता है, जो अगले लॉन्च पर पुनर्निर्माण को ट्रिगर करता है — किसी मैनुअल --rebuild की आवश्यकता नहीं।

प्रोफ़ाइल संगतता

प्रत्येक फोर्क के लिए एक समर्पित प्रोफ़ाइल का उपयोग करें। सबसे सुरक्षित डिफ़ॉल्ट यह है कि foxcage को अपनी स्वयं की प्रोफ़ाइल प्रदान करने दें (config से profile हटाएँ), या profile को ऐसी निर्देशिका पर इंगित करें जिसे आप होस्ट से भी नहीं खोलते।

• LibreWolf: आमतौर पर अपने होस्ट Firefox प्रोफ़ाइल के साथ साझा करना ठीक है — LibreWolf Firefox संस्करणों को कुछ दिनों के भीतर ट्रैक करता है, इसलिए compatibility.ini स्कीमा टकराव दुर्लभ हैं। जोखिम: (1) केवल अनुक्रमिक उपयोग सुरक्षित है (Firefox का लॉक फ़ाइल समवर्ती खोलने को रोकता है); (2) Firefox स्थिर रिलीज़ के बाद की छोटी अवधि में, पहले Firefox फिर LibreWolf चलाने से "नए संस्करण द्वारा उपयोग किया गया" माइग्रेशन डायलॉग ट्रिगर हो सकता है; (3) LibreWolf द्वारा हटाई गई सुविधाएँ (Sync, Pocket, Mozilla खाता) चुपचाप काम नहीं करतीं लेकिन डेटा को भ्रष्ट नहीं करतीं।

नामित केज

अपने स्वयं के config और Firefox प्रोफ़ाइल के साथ अलग-अलग सैंडबॉक्स किए गए इंस्टेंस चलाएँ:```sh ./foxcage @work

यह `~/.config/foxcage/work.toml` लोड करता है और एक अलग इमेज (`foxcage-work`), कंटेनर (`foxcage-work`), और वॉल्यूम (`foxcage-work-profile`) का उपयोग करता है। नामित केज के लिए कॉन्फ़िग फ़ाइल का मौजूद होना आवश्यक है। केज के नामों में केवल अक्षर, अंक, हाइफ़न और अंडरस्कोर हो सकते हैं।

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

कॉन्फ़िग फ़ाइलें `$XDG_CONFIG_HOME/foxcage/` में रहती हैं (डिफ़ॉल्ट `~/.config/foxcage/` है)।

- `config.toml` — डिफ़ॉल्ट केज (वैकल्पिक, इसके बिना उचित डिफ़ॉल्ट मान)
- `<name>.toml` — नामित केज, `@<name>` के साथ लोड किया जाता है (आवश्यक)

अज्ञात कॉन्फ़िग कुंजियों को त्रुटि के साथ अस्वीकार कर दिया जाता है। सभी उपलब्ध विकल्पों और डिफ़ॉल्ट मानों के लिए `config.toml.example` देखें।

### उदाहरण config.toml```toml
# Bind-mount a host Firefox profile directory into the cage
profile       = "~/.mozilla/firefox/xxxxxxxx.default-release"

# Allow downloading files to ~/Downloads
downloads_dir = "~/Downloads"

# Extensions pre-installed into the cage (addons.mozilla.org short name,
# listing URL, or add-on ID). Most useful in tmp.toml.
# extensions = ["ublock-origin"]

# Shared memory size for Firefox IPC (default: 256m)
# shm_size = "256m"

# Pass through webcam devices (/dev/video*)
# webcam = true

# Pass through host CUPS socket for locally-connected printers (e.g. USB)
# local_printers = true

# Pass through FIDO2/U2F security key devices (/dev/hidraw*)
# security_keys = true

# Always open Firefox in private browsing mode
# private_browsing = true

# Auto-close the cage after a duration (<int> with unit s, m, or h)
# lifetime = "30m"

# Accent colour for the menu-bar label.  Named cages get a colour derived
# from the name automatically; set this to override it.
# color = "#4a90e2"

# Browser fork: "firefox" (default) or "librewolf"
# fork = "librewolf"

# Full image rebuild interval in days for base-image updates (default: 7, 0 to disable)
# rebuild_days = 7

[firefox]
# Firefox release channel: "release" (default), "beta", "esr".
# Only valid when fork = "firefox".
# channel = "release"

# Pin to a specific Firefox version (overrides channel).
# Partial versions like "149" or "149.0" resolve to the latest patch release.
# Suffixed versions must be fully qualified ("140.13.0esr", "150.0b9"); to
# follow the ESR line by major version, pair a numeric pin with
# channel = "esr" above.
# version = "149.0.2"

[librewolf]
# Pin to a specific LibreWolf version. Tags are "<firefox-version>-<rev>",
# e.g. "146.0.1-1". Partial pins like "146" or "146.0.1" also work.
# version = "146.0.1-1"

[network]
# "host" for full host networking (needed if the cage has to reach services
# on the host's localhost), or omit for isolated pasta (default)
# mode = "host"

# DNS server (isolated mode only, default: host DNS)
# dns = "1.1.1.1"

# Disable IPv6 in the cage (isolated mode only)
# ipv4_only = true

[mounts]
# Additional bind mounts into the container. Supported forms:
#   "~/Documents"                     — same path in container
#   "~/Documents:~/Documents"         — ~ expanded on both sides
#   "~/Documents:/home/user/Documents" — explicit container path
# Append :ro for read-only, e.g. "~/Documents:ro"
# nosuid,noexec are always enforced on bind mounts; an explicit "exec" or
# "suid" is rejected rather than silently dropped.
# Host paths must be absolute or start with "~/".
bind = [
    "~/Documents:ro",
]

[init]
# Commands to run at image build time (as root). Changes trigger a rebuild.
# build = ["apt-get update && apt-get install -y --no-install-recommends vim"]

# Commands to run at container startup as root, before Firefox.
# root = ["chown user:user /some/path"]

# Commands to run at container startup as your user, before Firefox.
# user = ["mkdir -p ~/custom-dir"]

होस्ट Firefox प्रोफ़ाइल

केज के साथ होस्ट Firefox प्रोफ़ाइल साझा करने के लिए, profile को प्रोफ़ाइल निर्देशिका पर सेट करें। होस्ट पर Firefox में about:profiles पर जाकर अपना प्रोफ़ाइल पथ खोजें — या यदि आप चाहते हैं कि केज होस्ट पर बनी रहने वाली एक साफ प्रोफ़ाइल के साथ शुरू हो, तो बस एक नई खाली निर्देशिका की ओर इशारा करें।```toml profile = "~/.mozilla/firefox/xxxxxxxx.default-release"

केवल यह एक निर्देशिका पिंजरे में bind-mounted होती है। `~/.mozilla/firefox/` के अंतर्गत सहोदर प्रोफाइल और `profiles.ini` रजिस्ट्री उजागर नहीं होती हैं — एक समझौता किया गया पिंजरा उनके साथ छेड़छाड़ नहीं कर सकता।

यदि `profile` सेट नहीं है, तो एक नामित Podman वॉल्यूम Firefox प्रोफाइल को संग्रहीत करता है (नीचे "क्या स्थायी रहता है" देखें)। यदि वही प्रोफाइल पहले से होस्ट पर Firefox में खुला है, तो Firefox का प्रति-प्रोफाइल लॉक फ़ाइल टकराव का कारण बनेगा — प्रति पिंजरे एक समर्पित प्रोफाइल का उपयोग करें।

### नेटवर्किंग

डिफ़ॉल्ट रूप से, कंटेनर होस्ट लूपबैक अवरुद्ध और होस्ट DNS के साथ pasta का उपयोग करता है। pasta के लिए podman 4.4 या नया संस्करण आवश्यक है (यह podman 5.0 के बाद से rootless डिफ़ॉल्ट रहा है)।

**होस्ट नेटवर्किंग** नेटवर्क अलगाव को पूरी तरह से हटा देती है। इसका उपयोग तब करें जब पिंजरे को होस्ट के `localhost` पर सेवाओं तक पहुँचने की आवश्यकता हो (जैसे स्थानीय डेव सर्वर, `127.0.0.1` पर एक डेटाबेस):```toml
[network]
mode = "host"

dns को mode = "host" के साथ नहीं जोड़ा जा सकता — होस्ट नेटवर्किंग पहले से ही होस्ट के रिज़ॉल्वर का उपयोग करती है।

होस्ट मोड सिर्फ localhost से अधिक छोड़ देता है। यह केज को होस्ट के नेटवर्क नेमस्पेस में रखता है, और abstract यूनिक्स सॉकेट उस नेमस्पेस तक सीमित होते हैं, फाइलसिस्टम तक नहीं। इसलिए होस्ट मोड में एक केज सीधे होस्ट पर abstract-address सॉकेट तक पहुंच सकता है — जिसमें Xwayland का @/tmp/.X11-unix/X0 भी शामिल है यदि आप X11 या Xwayland चलाते हैं (इनपुट लॉगिंग, भले ही foxcage केवल Wayland-आधारित हो), और unix:abstract=… के साथ कॉन्फ़िगर किया गया सेशन बस, जो फ़िल्टर किए गए D-Bus प्रॉक्सी को बायपास कर सकता है। यह नेटवर्क स्टैक साझा करने में निहित है, ऐसा कुछ नहीं जिसे foxcage फ़िल्टर कर सके। होस्ट मोड का उपयोग तब करें जब आपको इसकी आवश्यकता हो, और एक नामित केज पसंद करें जिसे आप केवल उसी उद्देश्य के लिए लॉन्च करें।

IPv4-केवल केज IPv6 को पूरी तरह से अक्षम कर देते हैं:```toml [network] ipv4_only = true

या `--ipv4-only` फ्लैग (शॉर्ट फॉर्म `-4`, जैसा कि `ssh`/`curl`/pasta में है) के साथ लॉन्च करने पर:```sh
./foxcage @tmp -4 https://example.com

यह पास्ता को IPv4-केवल मोड (-4) में चलाता है, इसलिए कंटेनर में IPv6 स्टैक बिल्कुल नहीं होता है, और साथ ही Firefox में network.dns.disableIPv6 सेट करता है ताकि यह AAAA रिकॉर्ड्स को हल न करे — जो तब मायने रखता है जब DoH सक्षम हो, क्योंकि DoH उत्तर कंटेनर के रिज़ॉल्वर को बायपास करते हैं। ipv4_only को mode = "host" के साथ नहीं जोड़ा जा सकता — होस्ट नेटवर्किंग सीधे होस्ट के नेटवर्क स्टैक का उपयोग करती है, इसलिए इसके बजाय होस्ट पर IPv6 अक्षम करें।

Init कमांड

[init] के माध्यम से बिल्ड समय या कंटेनर स्टार्टअप पर कस्टम कमांड चलाएँ:

• build — इमेज बिल्ड समय पर रूट के रूप में चलता है। पैकेज इंस्टॉल करने या अन्य धीमी सेटअप के लिए उपयोग करें। बिल्ड कमांड में बदलाव स्वचालित रूप से इमेज रीबिल्ड को ट्रिगर करते हैं।
• root — कंटेनर स्टार्टअप पर Firefox से पहले रूट के रूप में चलता है। त्वरित रनटाइम रूट कार्यों (अनुमतियाँ समायोजित करना, कॉन्फ़िग फ़ाइलें लिखना) के लिए उपयोग करें।
• user — कंटेनर स्टार्टअप पर Firefox से पहले आपके उपयोगकर्ता के रूप में चलता है। निर्देशिकाएँ बनाने, उपयोगकर्ता-स्तरीय स्थिति सेट करने के लिए उपयोग करें।```toml [init] build = [ "apt-get update && apt-get install -y --no-install-recommends fonts-noto-cjk", "rm -rf /var/lib/apt/lists/*", ] root = ["chmod 777 /tmp/shared"] user = ["mkdir -p ~/workspace"]

सभी तीन कुंजियाँ शेल कमांड स्ट्रिंग्स की सूचियाँ हैं। यदि कोई भी कमांड विफल हो जाती है, तो कंटेनर Firefox शुरू किए बिना बाहर निकल जाता है।

**सुरक्षा नोट:** जब `init.root` सेट होता है, तो कंटेनर `CAP_SETUID` और `CAP_SETGID` जोड़े जाने के साथ (डिफ़ॉल्ट `CAP_SYS_CHROOT` के ऊपर) root के रूप में शुरू होता है, ताकि वह वापस नियमित उपयोगकर्ता पर आ सके। ये क्षमताएँ केवल root init चरण के दौरान रखी जाती हैं — विशेषाधिकार हटाने के बाद, नियमित-उपयोगकर्ता प्रक्रिया के पास कोई अतिरिक्त क्षमता नहीं होती है। `init.root` के बिना, कंटेनर डिफ़ॉल्ट न्यूनतम क्षमता सेट के साथ चलता है।

## क्या स्थायी रहता है

कॉन्फ़िगरेशन के बिना, एक नामित Podman वॉल्यूम Firefox प्रोफ़ाइल (बुकमार्क, सेटिंग्स, एक्सटेंशन, Widevine DRM प्लगइन) संग्रहीत करता है। बाकी सब कुछ अस्थायी है।

- डिफ़ॉल्ट cage: `foxcage-profile`
- नामित cage: `foxcage-<name>-profile`

नई शुरुआत करने के लिए, वॉल्यूम हटाएँ:```sh
podman volume rm foxcage-profile

यदि profile सेट है, तो होस्ट निर्देशिका सीधे bind-mount होती है और कोई volume नहीं बनाया जाता।

extensions में सूचीबद्ध एक्सटेंशन उस state का हिस्सा नहीं हैं: वे image में रहते हैं और हर लॉन्च पर पुनः इंस्टॉल होते हैं, इसलिए volume को हटाने (या एक ephemeral cage का उपयोग करने, जिसमें कोई volume नहीं होता) से वे नष्ट नहीं होते।

Disk usage

प्रत्येक cage image लगभग 1 GB का होता है। एक rebuild image को retag करता है और पिछले image को एक untagged <none> entry के रूप में पीछे छोड़ देता है, इसलिए foxcage हर सफल build के बाद उस image को हटा देता है जिसे उसने अभी displaced किया है। यह केवल उस विशिष्ट image को हटाता है, और कभी भी उस image को नहीं जिसे एक चालू cage अभी भी उपयोग कर रहा है।

इस व्यवहार के अस्तित्व में आने से पहले orphaned हुए images को पूर्वव्यापी रूप से साफ नहीं किया जाता। उन्हें पुनः प्राप्त करने के लिए:```sh podman images --filter dangling=true # review first podman image prune # then remove

फ़ायरफ़ॉक्स अपडेट हर लॉन्च पर स्वचालित रूप से पहचाने जाते हैं। पूर्ण रीबिल्ड को बाध्य करने के लिए (जैसे कि सिस्टम सुरक्षा अपडेट को तुरंत लागू करने हेतु):```sh
./foxcage --rebuild

थीमिंग

foxcage स्वचालित रूप से होस्ट से निम्नलिखित पास करता है, ताकि कंटेनर में Firefox एक नेटिव एप्लिकेशन जैसा दिखे और महसूस हो:

• फ़ॉन्ट्स। सिस्टम फ़ॉन्ट्स (/usr/share/fonts) और उपयोगकर्ता फ़ॉन्ट्स (~/.local/share/fonts) रीड-ओनली बाइंड-माउंट किए जाते हैं। ~/.config/fontconfig से फ़ॉन्ट कॉन्फ़िगरेशन भी पास किया जाता है।
• GTK थीम और डार्क मोड। GTK_THEME या gsettings के माध्यम से पता लगाया जाता है और कंटेनर में पास किया जाता है। ~/.config/gtk-3.0 और ~/.config/gtk-4.0 से GTK कॉन्फ़िगरेशन रीड-ओनली बाइंड-माउंट किया जाता है।
• टाइमज़ोन। होस्ट का टाइमज़ोन नाम (TZ, /etc/localtime सिमलिंक, या /etc/timezone से पता लगाया गया) कंटेनर में TZ के रूप में पास किया जाता है, और /etc/localtime रीड-ओनली बाइंड-माउंट किया जाता है। दोनों आवश्यक हैं: Firefox JavaScript टाइमज़ोन को ज़ोन से प्राप्त करता है, फ़ाइल सामग्री से नहीं — के बिना, वेबसाइटें समय UTC में दिखाएँगी।

केज लेबल। Firefox मेनू बार "FoxCage" (या नामित केज के लिए "FoxCage - name") प्रदर्शित करता है ताकि आप एक नज़र में बता सकें कि आप एक कंटेनरीकृत सत्र में हैं। मेनू बार एंटरप्राइज़ पॉलिसी के माध्यम से हमेशा दृश्यमान रहता है।

कंटेनर में केवल Adwaita GTK थीम शामिल है। GNOME डेस्कटॉप पर यह बॉक्स से बाहर काम करता है। KDE या अन्य डेस्कटॉप पर, Firefox Adwaita पर वापस आ जाएगा यदि आपका GTK थीम (जैसे Breeze) कंटेनर में स्थापित नहीं है। डार्क मोड का पता लगाना तब भी काम करता है जब तक प्राथमिकता gsettings या GTK_THEME के माध्यम से सेट की गई है।

हार्डवेयर वीडियो डिकोडिंग (VA-API)

कंटेनर का अपना यूज़रलैंड है, इसलिए होस्ट पर स्थापित VA-API ड्राइवर अप्रासंगिक हैं — इमेज अपने स्वयं के ड्राइवर भेजती है। va-driver-all i965-va-driver (पुराना Intel) और mesa-va-drivers (AMD, nouveau) को खींचता है, साथ ही intel-media-va-driver-non-free (Intel Gen8+, iHD ड्राइवर) और libva2/libva-drm2, जिन्हें Firefox रनटाइम पर लोड करता है।

हार्डवेयर डिकोडिंग के लिए /dev/dri पास-थ्रू की आवश्यकता होती है, जो foxcage स्वचालित रूप से करता है जब भी होस्ट के पास यह होता है। कॉन्फ़िगर करने के लिए कुछ भी नहीं है।

Intel ड्राइवर नॉन-फ्री बिल्ड है, इसलिए इमेज Debian के non-free कंपोनेंट को सक्षम करती है। Debian का फ्री intel-media-va-driver एक +dfsg रीपैक है जिसमें गैर-पुनर्वितरण योग्य कोडेक कर्नेल हटा दिए गए हैं, और जो इसमें खो जाता है वह AV1 डिकोड है — वह फ़ॉर्मेट जो YouTube अब डिफ़ॉल्ट रूप से परोसता है। फ्री बिल्ड हर Intel मशीन पर AV1 को सॉफ़्टवेयर पर वापस गिरने देगा।

यह जाँचने के लिए कि यह वास्तव में काम कर रहा है, एक लाइव केज के अंदर vainfo चलाएँ:```bash podman exec foxcage- vainfo

इसे उपयोग में आने वाले ड्राइवर को सूचीबद्ध करना चाहिए (Intel पर `iHD`, AMD पर `radeonsi`) और समर्थित
प्रोफ़ाइल — `VAProfileH264*`, `VAProfileVP9Profile0`, `VAProfileAV1Profile0` इत्यादि।
ब्राउज़र के अंदर से समतुल्य जाँच `about:support` → Media है, जहाँ
Hardware Decoding कॉलम H264, VP8, VP9, HEVC और AV1 के लिए `Supported` पढ़ना चाहिए। जब
कोई वीडियो चल रहा हो, तो होस्ट पर `intel_gpu_top` Video इंजन पर गतिविधि दिखाता है।

हार्डवेयर **एन्कोडिंग** अलग है, और Intel पर यह उसी ड्राइवर से आती है: H264 और
HEVC को उस कॉलम में `Supported` पढ़ना चाहिए, जिसका उपयोग WebRTC वीडियो कॉल में आउटगोइंग
कैमरा स्ट्रीम के लिए करता है और जिसका उपयोग `MediaRecorder` करता है। VP8, VP9 और AV1 एन्कोडिंग
`Unsupported` रहती है — Firefox केवल H264 और HEVC VA-API एन्कोडर को जोड़ता है, चाहे
GPU कितना भी सक्षम क्यों न हो।

ऑडियो कोडेक (AAC, MP3, Opus, Vorbis, FLAC, Wave) हर मशीन पर Hardware
Decoding के अंतर्गत `Unsupported` पढ़ते हैं — किसी भी उपभोक्ता GPU में ऑडियो डिकोड ब्लॉक नहीं होता। वह पंक्ति
गलत कॉन्फ़िगरेशन नहीं है।

यदि `vainfo` `failed to initialize display` रिपोर्ट करता है, तो कंटेनर
`/dev/dri/renderD128` नहीं खोल सकता। सामान्य systemd डेस्कटॉप पर, logind आपके उपयोगकर्ता को उस
डिवाइस पर एक ACL प्रदान करता है, इसलिए इसका आमतौर पर मतलब है कि foxcage ऐसे सत्र से चलाया जा रहा है जो
सीट (SSH, एक अलग TTY) का स्वामी नहीं है।

## DRM (Netflix, Disney+, आदि)

Widevine DRM बॉक्स से बाहर काम करता है। DRM-संरक्षित साइट की पहली यात्रा पर, Firefox Widevine CDM को स्वचालित रूप से डाउनलोड करेगा। इसमें कुछ क्षण लग सकते हैं।

## होस्ट एकीकरण (हमेशा चालू)

foxcage होस्ट के XDG Desktop Portal और नोटिफिकेशन डेमॉन तक Firefox की पहुँच देने के लिए एक फ़िल्टर किया हुआ D-Bus प्रॉक्सी उपयोग करता है। ये सुविधाएँ सुरक्षित हैं क्योंकि सभी पहुँच उपयोगकर्ता-मध्यस्थ है — होस्ट मूल डायलॉग दिखाता है जिनके साथ आपको इंटरैक्ट करना होता है। एक समझौता किया गया ब्राउज़र चुपचाप होस्ट संसाधनों तक नहीं पहुँच सकता।

- **फ़ाइल अपलोड** — होस्ट का मूल फ़ाइल पिकर (आप चुनते हैं कि कौन सी फ़ाइलें साझा करनी हैं)
- **बाहरी लिंक** — `mailto:`, magnet लिंक, आदि होस्ट ऐप चूज़र के माध्यम से खुलते हैं
- **डेस्कटॉप सूचनाएँ** — होस्ट नोटिफिकेशन डेमॉन को अग्रेषित की जाती हैं
- **स्क्रीन साझाकरण** — पोर्टल स्क्रीन पिकर + PipeWire वीडियो स्ट्रीम (होस्ट पर PipeWire की आवश्यकता है)

## डिवाइस पासथ्रू (ऑप्ट-इन)

ये होस्ट डिवाइस को सीधे कंटेनर में पास करते हैं और **डिफ़ॉल्ट रूप से बंद** होते हैं — ऊपर दिए गए पोर्टल सुविधाओं के विपरीत, होस्ट-पक्ष पर कोई पुष्टि नहीं होती। एक समझौता किया गया ब्राउज़र हार्डवेयर का चुपचाप उपयोग कर सकता है।```toml
webcam = true          # /dev/video* — webcam for video calls
local_printers = true  # CUPS socket — USB printers (network printers work by default)
security_keys = true   # /dev/hidraw* — FIDO2/U2F hardware keys

अभी तक समर्थित नहीं

कुछ वेब प्लेटफ़ॉर्म सुविधाएँ होस्ट एकीकरण की कमी के कारण कंटेनर में काम नहीं करती हैं। इन्हें पारदर्शिता के लिए यहाँ सूचीबद्ध किया गया है।

ब्लूटूथ, USB, सीरियल और NFC। Web Bluetooth, WebUSB, Web Serial और WebNFC API को डिवाइस एक्सेस और सिस्टम सेवाओं (BlueZ, udev) की आवश्यकता होती है, जो कंटेनर में उपलब्ध नहीं हैं।

गेमपैड और MIDI। Gamepad API को /dev/input/ एक्सेस की आवश्यकता होती है। Web MIDI को ALSA सीक्वेंसर एक्सेस की आवश्यकता होती है। इनमें से कोई भी पास-थ्रू नहीं किया गया है।

PWA इंस्टॉलेशन। प्रोग्रेसिव वेब ऐप्स को कंटेनर के अंदर से होस्ट डेस्कटॉप पर इंस्टॉल नहीं किया जा सकता।

एक्सेसिबिलिटी। AT-SPI के माध्यम से स्क्रीन रीडर समर्थन अक्षम है (NO_AT_BRIDGE=1) — कंटेनर का होस्ट के एक्सेसिबिलिटी बस से कोई संबंध नहीं है। Web Speech API संश्लेषण कार्य करता है: speech-dispatcher जिसमें espeak-ng इंजन है, केज में स्थापित है और पहले उपयोग पर स्वतः स्पॉन होता है, जिसमें ऑडियो साझा PulseAudio सॉकेट के माध्यम से रूट किया जाता है।

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

अनुशंसित: ओवरले स्टोरेज

रूटलेस Podman vfs स्टोरेज ड्राइवर पर वापस जा सकता है, जो ओवरले माउंट का उपयोग करने के बजाय पूरी इमेज लेयर की प्रतिलिपि बनाता है। यह बिल्ड के बाद कंटेनर स्टार्टअप को बहुत धीमा बना देता है। जाँचें कि आपके पास कौन सा ड्राइवर है:```sh podman info --format '{{.Store.GraphDriverName}} {{.Store.GraphStatus}}'

`overlay` जिसमें `Native Overlay Diff:true` है, वह तेज़ मार्ग है और उसे किसी कॉन्फ़िगरेशन की आवश्यकता नहीं है — कर्नेल 5.13 या उससे नए संस्करण पर ext4/xfs बैकिंग फाइलसिस्टम के साथ, Podman सीधे अनप्रिविलेज्ड overlayfs का उपयोग करता है। यदि आपको यही दिखाई देता है, तो करने के लिए कुछ नहीं है, और `fuse-overlayfs` इंस्टॉल करने से कोई मदद नहीं मिलेगी।

केवल यदि आप `vfs` पर पहुँचते हैं (पुराना कर्नेल, या ऐसा बैकिंग फाइलसिस्टम जो अनप्रिविलेज्ड overlay नहीं कर सकता), तो `fuse-overlayfs` इंस्टॉल करें और `~/.config/containers/storage.conf` में जोड़ें:```toml
[storage]
driver = "overlay"

[storage.options.overlay]
mount_program = "/usr/bin/fuse-overlayfs"

यह एक फॉलबैक है, अपग्रेड नहीं: FUSE हर फाइलसिस्टम ऑपरेशन को यूज़रस्पेस से होकर रूट करता है और नेटिव ओवरले से धीमा है। ऐसे सिस्टम पर mount_program सेट करना जो नेटिव ओवरले सपोर्ट करता है, चीज़ों को बेहतर नहीं, बल्कि बदतर बनाता है।

foxcage को अपना डिफ़ॉल्ट ब्राउज़र बनाना

पहले, सुनिश्चित करें कि foxcage स्क्रिप्ट अपनी स्थायी जगह पर है (जैसे ~/bin/foxcage या /usr/local/bin/foxcage)। इंस्टॉल कमांड स्क्रिप्ट का वर्तमान पथ .desktop फ़ाइल में रिकॉर्ड करता है, इसलिए इसे बाद में स्थानांतरित करने से लॉन्चर टूट जाएगा।

फिर चलाएँ:```sh foxcage --install

यह एक `.desktop` फ़ाइल बनाता है जो स्क्रिप्ट के वर्तमान स्थान की ओर इशारा करती है, foxcage आइकन इंस्टॉल करता है, और डेस्कटॉप तथा आइकन डेटाबेस को रीफ़्रेश करता है। FoxCage को फिर आपके एप्लिकेशन मेनू में दिखाई देना चाहिए।

foxcage को डिफ़ॉल्ट वेब ब्राउज़र के रूप में सेट करने के लिए, ताकि अन्य एप्लिकेशन में क्लिक किए गए लिंक foxcage में खुलें:```sh
xdg-settings set default-web-browser foxcage.desktop

यदि कोई cage पहले से चल रहा है, तो URLs मौजूदा ब्राउज़र में नए टैब के रूप में खुलते हैं।

पूर्ववत करने के लिए:```sh foxcage --uninstall

`StartupNotify=true` `.desktop` फ़ाइल में सेट है, जो कंपोज़िटर को बताता है कि foxcage शुरू होने पर स्पिनर कर्सर दिखाए। जब इमेज बिल्ड की आवश्यकता होती है (जिसमें कई मिनट लग सकते हैं), foxcage एक डेस्कटॉप सूचना भेजता है ताकि आपको पता चले कि Firefox आ रहा है। कोई भी जल्दी-निकास त्रुटि (कॉन्फ़िग टाइपो, लापता निर्भरता, गलत cage नाम) भी डेस्कटॉप सूचना के रूप में दिखाई जाती है, ताकि डेस्कटॉप से लॉन्च करने वाले उपयोगकर्ता तब खाली न देखते रहें जब foxcage बिना टर्मिनल के विफल हो जाता है। दोनों के लिए `notify-send` (Debian/Ubuntu पर `libnotify-bin` से) आवश्यक है — यदि यह स्थापित नहीं है, तो सूचनाएं चुपचाप छोड़ दी जाती हैं और त्रुटि फिर भी stderr पर जाती है।

<details>
<summary>मैन्युअल सेटअप</summary>

यदि आप `.desktop` फ़ाइल मैन्युअल रूप से बनाना पसंद करते हैं, तो `~/.local/share/applications/foxcage.desktop` बनाएं:```ini
[Desktop Entry]
Type=Application
Name=FoxCage
Comment=Firefox in a rootless Podman container
Exec=/path/to/foxcage %u
Icon=foxcage
MimeType=text/html;x-scheme-handler/http;x-scheme-handler/https;
Terminal=false
Categories=Network;WebBrowser;
StartupNotify=true
StartupWMClass=foxcage

/path/to/foxcage को स्क्रिप्ट के वास्तविक पथ से बदलें। इसे पंजीकृत करें:```sh update-desktop-database ~/.local/share/applications

</details>

## परीक्षण चलाना

टेस्ट सूट pytest + pytest-cov का उपयोग करता है, जिन्हें `requirements-dev.txt` में केवल-डेव निर्भरताओं के रूप में घोषित किया गया है।```
pip install -r requirements-dev.txt
pytest

परीक्षण पूरी तरह से हर्मेटिक हैं — कोई पॉडमैन नहीं, कोई नेटवर्क नहीं, pytest के tmp_path से परे कोई वास्तविक फाइलसिस्टम नहीं। सूट 100% लाइन और ब्रांच कवरेज पर गेट करता है (pytest.ini और .coveragerc में कॉन्फ़िगर किया गया); कोई भी अनकवर्ड लाइन, या कंडीशनल का कोई अनटेकन पक्ष, रन को विफल कर देता है। CI हर पुश पर .gitlab-ci.yml के माध्यम से सूट चलाता है।

Acknowledgements

यह प्रोजेक्ट माइक कार्डवेल द्वारा विकसित किया गया था, Claude Code, एंथ्रोपिक के AI कोडिंग टूल की सहायता से।

Support/Appreciate my work

• Bitcoin: 1PQLtWnjUi1itHLG6QCQeHM3Nxua8pRsq1
• Paypal