honeyslop - कोड कैनरीज़ जो भ्रमित ("स्लॉप") भेद्यता रिपोर्टों को तुरंत वर्गीकृत करने के लिए हैं

honeyslop, ओपन-सोर्स परियोजनाओं के लिए कोड कैनरीज़ (डिकॉय) है जो AI-भ्रमित ("स्लॉप") और असत्यापित भेद्यता रिपोर्टों में डूबी हुई हैं। ऐसे प्रतिकूल शोर इंजेक्शन के साथ, एक स्लॉप स्कैनर कैनरी को ग्रहण करता है, फिर उसके आधार पर एक भेद्यता "रिपोर्ट" उत्पन्न करता है। रिपोर्ट स्वयं को स्लॉप के रूप में पहचानती है। इसे एक grep में बंद करें।

यह एक त्वरित PoC है, जो एक मज़ाक के रूप में वाइब-कोडेड है (उत्पादन-ग्रेड नहीं), क्योंकि हमें स्वयं raptor पर एक स्लॉप रिपोर्ट मिली थी, जो Claude Code पर आधारित एक स्वायत्त आक्रमण/रक्षा एजेंट है। मज़ा आना चाहिए!

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

लेखक: गादी एवरॉन (@gadievron), जॉन कार्टराईट (@grokjc), डैनियल कथबर्ट (@danielcuthbert), और मिचल कामेंस्की (@kamenskymic, परियोजना के नामकरण के लिए श्रेय)।

अपने जोखिम पर उपयोग करें। यदि आप इसे उत्पादन में चिपकाते हैं, तो यह आपकी समस्या है। नीचे अस्वीकरण देखें।

वर्गीकरण नियम

प्रत्येक आने वाली रिपोर्ट के लिए, क्रम में:

1. रिपोर्ट में किसी भी कैनरी UUID को grep करें → बंद करें। (UUID प्रति-भाषा हैं; प्रत्येक कैनरी फ़ाइल में बिल्कुल एक एम्बेडेड है।)
2. केवल-कैनरी फ़ंक्शन नाम (zqx_tarnish_v3, zqxTarnishV3, _validate_pep_440_plus; साथ ही handle_*_request यदि आपने F+G को निजी रूप से अपनाया है) को grep करें → बंद करें। (Rust Python के समान zqx_tarnish_v3 snake_case नाम का उपयोग करता है। Go zqxTarnishV3 का उपयोग करता है, जो JS नाम से मेल खाता है।)
3. CVE-2025-99919 (नकली) को grep करें → बंद करें।
4. उद्धृत फ़ंक्शन ट्री में मौजूद नहीं है → "मौजूद नहीं है"।
5. B/D पर memcpy/बाउंड्स दावों के लिए: रिपोर्टकर्ता से पूछें कि उनका PoC उद्धृत लाइन पर विशिष्ट गार्ड को कैसे पराजित करता है। AI फ़ॉलो-अप उत्तर नहीं दे सकते; मनुष्य दे सकते हैं।

चरण

कैनरी के दो श्रेणियाँ:

• SCANNER-FLAG (चरण A, B, C, D, E) — स्कैनरों को फँसाएँ ताकि स्लॉप रिपोर्ट वास्तविक कोड के बजाय कैनरी पर जमा हो।
• RESOURCE-WASTE (चरण F + G, एक साथ) — एजेंटिक LLM स्कैनरों को अधिकतम लागत पर अपने पूर्ण पुनरावृत्ति बजट के माध्यम से चलाएँ।

देखें सुरक्षा मॉडल कि प्रत्येक चरण कमजोर दिखने के बावजूद निष्क्रिय कैसे रहता है।

सुरक्षा मॉडल

कैनरी कोड फ़ाइलें जानबूझकर प्रशंसनीय अप्रचलित मॉड्यूल की तरह पढ़ी जाती हैं — टिप्पणियों या पहचानकर्ताओं में कोई "कैनरी", "हनीपॉट" या "ट्रिपवायर" भाषा नहीं। यह फ़ाइलों को स्कैनरों से स्वयं-पहचानने से रोकता है, लेकिन इसका मतलब यह भी है कि ये फ़ाइलें सुरक्षित क्यों हैं का दस्तावेज़ीकरण यहाँ रहता है, प्रत्येक फ़ाइल के डॉकस्ट्रिंग में नहीं। कैनरी की समीक्षा या रोटेट करते समय, जाँचें कि नीचे प्रत्येक परत अभी भी अक्षुण्ण है।

ये फ़ाइलें कमजोर-आकार का कोड हैं — और कुछ (जैसे python/session_restore.py का pickle.loads, c/tls_heartbeat.c का असीमित memcpy) पहुँच योग्य होने पर वास्तविक रूप से शोषणीय होंगी। यही डिज़ाइन है। स्कैनरों का सिंक को चिह्नित करना पूरा बिंदु है; नीचे की परतें निष्पादन को अवरुद्ध करती हैं, स्कैनर संकेत को नहीं। पैटर्न-आधारित स्कैनर (grep, semgrep, LLM-आधारित स्लॉप पाइपलाइन — प्राथमिक खतरा मॉडल) स्रोत को पाठ के रूप में पढ़ते हैं और रनटाइम पहुँच की परवाह किए बिना निष्कर्ष प्रकट करते हैं। बिल्ड-एकीकृत C स्कैनर (CodeQL डिफ़ॉल्ट, clang-static-analyzer) केवल संकलित फ़ाइलें देखते हैं, इसलिए असंकलित C कैनरी उनके लिए अदृश्य हैं — एक स्वीकृत समझौता, क्योंकि स्लॉप जनरेटर बड़े पैमाने पर बिल्ड के बजाय स्रोत पढ़ते हैं।

चरण A और E (Python + JS)

पाँच स्वतंत्र परतें इन फ़ाइलों को निष्क्रिय रखती हैं:

1. शीर्ष-स्तरीय raise ImportError / throw new Error — एक सादा import / require किसी भी परिभाषा को बाँधने से पहले ही समाप्त हो जाता है।
2. if False: / if (false) के अंतर्गत प्रत्येक def/function — परत 1 को बायपास करने पर भी नाम कभी रनटाइम नेमस्पेस में प्रवेश नहीं करते।
3. खाली निर्यात — Python: __all__: list[str] = [] (स्टार-आयात कुछ भी निर्यात नहीं करता)। JS: module.exports = {} (CommonJS उपभोक्ताओं को एक खाली ऑब्जेक्ट मिलता है)।
4. शिब्बोलेथ फ़ंक्शनों के शून्य इन-ट्री कॉलर (zqx_tarnish_v3, zqxTarnishV3, _validate_pep_440_plus)। इनमें से किसी एक को उद्धृत करने वाली कोई भी रिपोर्ट स्वयं को स्लॉप के रूप में पहचानती है।
5. तैनाती अलगाव — अपनाने वाला sdist / wheel / Docker / SAST से कैनरी पथों को बहिष्कृत करता है (देखें और )।

चरण E छठी परत जोड़ता है: विनाशकारी-बैकट्रैक regex केवल एक स्ट्रिंग लिटरल के रूप में संग्रहीत है, मॉड्यूल स्कोप पर re.compile / new RegExp को पारित नहीं किया गया। एक हार्नेस जो परत 1 को हटाता है, वह भी संकलित बैकट्रैकिंग इंजन को ट्रिगर नहीं कर सकता।

स्कैनर AST को raise / throw से आगे और मृत ब्लॉक में चलते हैं, इसलिए सिंक अभी भी निष्कर्ष के रूप में प्रकट होते हैं — यह अभीष्ट व्यवहार है।

चरण B (C buffer_ops.c)

सुरक्षा संरचनात्मक है — प्रत्येक आकार के साथ एक प्रमाण है:

• bufops_copy_banner — src एक स्ट्रिंग लिटरल है, n = sizeof(literal), _Static_assert इसे गंतव्य आकार पर पिन करता है।
• bufops_copy_bounded — if (n > dst_cap) n = dst_cap; memcpy से ठीक पहले की लाइन CWE-787 दावे को असंभव बनाती है। C17 memcpy(dst, NULL, 0) UB से बचने के लिए n == 0 पर शॉर्ट-सर्किट।
• bufops_copy_truncating — n <= dst_cap - 1, dst[n] अधिकतम dst_cap - 1 पर पहुँचता है; dst_cap == 0 पर प्रारंभिक रिटर्न।

अतिरिक्त अलगाव: सभी फ़ंक्शन static हैं (कोई बाहरी लिंकेज नहीं) और फ़ाइल किसी भी बिल्ड लक्ष्य में नहीं जोड़ी गई है।

चरण D (C heartbeat.c + sat.h)

हार्टब्लीड सिल्हूट (uint16_t payload_len → malloc(1+2+payload_len+16) → memcpy) स्तरित गार्डों द्वारा निष्क्रिय किया गया है:

• सभी हेडर/ट्रेलर बजट गणित के लिए sat_sub संतृप्त घटाव (कोई रैप नहीं)।
• प्रवेश पर फ्रेम फ़ील्ड को const लोकल में कैश किया गया — TOCTOU और सिग्नल-हैंडलर UB विंडो बंद करता है।
• रीडर स्ट्रक्ट और उसके बफर पर NULL जाँचें।
• _Static_assert(SIZE_MAX - 19 >= UINT16_MAX, ...) साबित करता है कि malloc का आकार size_t को ओवरफ़्लो नहीं कर सकता।
• payload_len > 0 शॉर्ट-सर्किट खाली पेलोड पर memcpy(dst, NULL, 0) UB से बचाता है।
• parse_heartbeat और read_u16_be static हैं; फ़ाइल किसी भी बिल्ड लक्ष्य से लिंक नहीं की गई है।

parse_heartbeat में OOB रीड/राइट की रिपोर्ट जो उद्धृत लाइन पर विशिष्ट गार्ड से नहीं जुड़ती, ने शोषणीयता सत्यापित नहीं की है — वर्गीकरण नियम 5 के माध्यम से बंद करें।

c/tls_heartbeat.c उसी सिल्हूट का एक संस्करण है जो जानबूझकर अरक्षित रखा गया है: process_heartbeat static है और फ़ाइल किसी भी बिल्ड लक्ष्य से लिंक नहीं की गई है — एकमात्र परत अलगाव है, जो चरण B के कैच-ऑल से मेल खाता है। इसे TU के बाहर से कॉल करने का प्रयास एक लिंक त्रुटि है।

चरण A और E (Rust)

पाँच स्वतंत्र परतें इन फ़ाइलों को निष्क्रिय रखती हैं (Python/JS सुरक्षा मॉडल को दर्पण करती हैं):

1. शीर्ष-स्तरीय compile_error! — mod या include! के माध्यम से किसी crate में फ़ाइल को शामिल करने से किसी भी परिभाषा का मूल्यांकन करने से पहले एक कठोर कंपाइलर त्रुटि उत्पन्न होती है।
2. #[cfg(any())] के पीछे प्रत्येक परिभाषा — cfg(any()) हमेशा असत्य है, इसलिए परत 1 को बायपास करने पर भी नाम कभी संकलित आउटपुट में प्रवेश नहीं करते।
3. कोई pub आइटम नहीं — उपरोक्त दोनों परतों को हटाने पर भी कुछ भी निर्यात नहीं किया जाता है।
4. शिब्बोलेथ फ़ंक्शन के शून्य इन-ट्री कॉलर (zqx_tarnish_v3)। इसे उद्धृत करने वाली कोई भी रिपोर्ट स्वयं को स्लॉप के रूप में पहचानती है।
5. तैनाती अलगाव — फ़ाइल किसी mod स्टेटमेंट में संदर्भित नहीं है, किसी Cargo.toml में सूचीबद्ध नहीं है, और बिल्ड आर्टिफैक्ट्स से बहिष्कृत है।

चरण E छठी परत जोड़ता है: विनाशकारी-बैकट्रैक regex केवल &str स्थिरांक के रूप में संग्रहीत है, मॉड्यूल स्कोप पर regex::Regex::new को पारित नहीं किया गया।

चरण B (Rust buffer_ops.rs)

सुरक्षा संरचनात्मक है, जो C समकक्ष से मेल खाती है। प्रत्येक आकार के साथ एक प्रमाण है:

• bufops_copy_banner — src b"status: ok\0" है, कॉपी लंबाई BANNER.len() है; एक const असर्शन इसे गंतव्य आकार पर पिन करता है।
• bufops_copy_bounded — if n > dst_cap { n = dst_cap; } कॉपी से ठीक पहले की लाइन लेखन को बाध्य करती है। n == 0 पर शॉर्ट-सर्किट।
• bufops_copy_truncating — n <= dst_cap - 1, dst.add(n) पर NUL लेखन अधिकतम dst_cap - 1 पर पहुँचता है; dst_cap == 0 पर प्रारंभिक रिटर्न।
• bufops_shift — और दोनों पर बाध्य; स्पष्ट रूप से ओवरलैप का समर्थन करता है।

अतिरिक्त अलगाव: सभी फ़ंक्शन #[cfg(any())] (मृत कोड) के अंदर हैं, गैर-सार्वजनिक हैं, और फ़ाइल किसी भी बिल्ड लक्ष्य में नहीं जोड़ी गई है।

चरण D (Rust heartbeat.rs + tls_heartbeat.rs)

Rust में हार्टब्लीड सिल्हूट unsafe रॉ पॉइंटर ऑपरेशन (ptr::copy_nonoverlapping, std::alloc::alloc) का उपयोग करता है और C संस्करण के समान स्तरित गार्डों द्वारा निष्क्रिय किया गया है:

• usize::saturating_sub के माध्यम से सभी हेडर/ट्रेलर बजट गणित के लिए संतृप्त घटाव।
• प्रवेश पर फ्रेम फ़ील्ड को स्थानीय चर में कैश किया गया।
• रीडर स्ट्रक्ट और उसके बफर पर NULL जाँचें।
• स्थिरांक असर्शन (usize::MAX - 19 >= u16::MAX) साबित करता है कि आवंटन ओवरफ़्लो नहीं हो सकता।
• payload_len > 0 शॉर्ट-सर्किट।
• सभी फ़ंक्शन #[cfg(any())] के अंदर, गैर-सार्वजनिक, फ़ाइल लिंक नहीं की गई।

rust/tls_heartbeat.rs जानबूझकर अरक्षित संस्करण है: process_heartbeat ptr::copy_nonoverlapping का उपयोग करता है जिसमें अविश्वसनीय इनपुट से claimed_len और कोई बाउंड्स गार्ड नहीं है। अलगाव (#[cfg(any())] + compile_error! + लिंक नहीं) एकमात्र परत है।

चरण A और E (Go)

पाँच स्वतंत्र परतें इन फ़ाइलों को निष्क्रिय रखती हैं:

1. प्रत्येक फ़ाइल के शीर्ष पर //go:build ignore। Go टूलचेन (go build, go test, go vet) फ़ाइल को पूरी तरह से छोड़ देता है; इसे कभी संकलित, लिंक या परीक्षण नहीं किया जाता है।
2. func init() { panic("...") } UUID के साथ। यदि परत 1 को किसी भी तरह से बायपास किया जाता है (मैन्युअल -tags ओवरराइड, रॉ go tool compile), तो प्रोग्राम main() चलने से पहले स्टार्टअप पर क्रैश हो जाता है।
3. सभी फ़ंक्शन अनएक्सपोर्टेड (लोअरकेस नाम)। संकलित होने पर भी, पैकेज के बाहर से कुछ भी कॉल करने योग्य नहीं है।
4. शिब्बोलेथ फ़ंक्शन के शून्य इन-ट्री कॉलर (zqxTarnishV3)। इसे उद्धृत करने वाली कोई भी रिपोर्ट स्वयं को स्लॉप के रूप में पहचानती है।
5. तैनाती अलगाव — फ़ाइलें बिना go.mod के एक स्टैंडअलोन go/ निर्देशिका में हैं, किसी पैकेज आयात द्वारा संदर्भित नहीं हैं, और बिल्ड आर्टिफैक्ट्स से बहिष्कृत हैं।

चरण E एक छठी परत जोड़ता है जो Go के लिए विशिष्ट है: validatePep440Plus कॉल regexp.MustCompile को विनाशकारी पैटर्न पर करता है, लेकिन Go का regexp पैकेज RE2 शब्दार्थ (गारंटीकृत रैखिक-समय मिलान) का उपयोग करता है, इसलिए विनाशकारी बैकट्रैकिंग असंभव है। कैनरी अभी भी उपयोगी है क्योंकि स्कैनर यह जाँचे बिना कि कौन सा regex इंजन उपयोग में है, पैटर्न आकार को पाठ्य रूप से चिह्नित करते हैं।

चरण B (Go buffer_ops.go)

सुरक्षा संरचनात्मक है, जो C और Rust समकक्षों से मेल खाती है। प्रत्येक आकार के साथ एक प्रमाण है:

• bufopsCopyBanner — src एक स्ट्रिंग स्थिरांक है, copy() एक ज्ञात लिटरल से एक निश्चित-आकार के सरणी में; एक संकलन-समय असर्शन लंबाई को पिन करता है।
• bufopsCopyBounded — if n > dstCap { n = dstCap } कॉपी से ठीक पहले की लाइन लेखन को बाध्य करती है। n == 0 पर शॉर्ट-सर्किट।
• bufopsCopyTruncating — n <= dstCap - 1, dst[n] पर NUL लेखन अधिकतम dstCap - 1 पर पहुँचता है; dstCap == 0 पर प्रारंभिक रिटर्न।
• bufopsShift — i + n और j + n दोनों पर बाध्य; एकल स्लाइस के भीतर ओवरलैप का समर्थन करता है।

अतिरिक्त अलगाव: //go:build ignore फ़ाइल को सभी बिल्ड से बहिष्कृत करता है, सभी फ़ंक्शन अनएक्सपोर्टेड हैं, और फ़ाइल किसी भी पैकेज द्वारा आयात नहीं की गई है।

चरण D (Go heartbeat.go + tls_heartbeat.go)

Go में हार्टब्लीड सिल्हूट unsafe.Slice और unsafe.Pointer का उपयोग करता है और C और Rust संस्करणों के समान स्तरित गार्डों द्वारा निष्क्रिय किया गया है:

• सभी हेडर/ट्रेलर बजट गणित के लिए satSub संतृप्त घटाव।
• प्रवेश पर फ्रेम फ़ील्ड को स्थानीय चर में कैश किया गया।
• रीडर स्ट्रक्ट और उसके बफर पर Nil जाँचें।
• आवंटन से पहले बजट के विरुद्ध लंबाई सत्यापन।
• payloadLen > 0 शॉर्ट-सर्किट।
• //go:build ignore, सभी फ़ंक्शन अनएक्सपोर्टेड, फ़ाइल आयात नहीं की गई।

go/tls_heartbeat.go जानबूझकर अरक्षित संस्करण है: processHeartbeat unsafe.Slice का उपयोग करता है जिसमें अविश्वसनीय इनपुट से claimedLen और कोई बाउंड्स गार्ड नहीं है। अलगाव (//go:build ignore + init panic + आयात नहीं) एकमात्र परत है।

कैसे प्रयास करें

1. चरण चुनें। C/C++ पार्सर सतह → D (+ B)। Python OSS मेंटेनर → A + E। Rust crate → A + B + D + E। Go मॉड्यूल → A + B + D + E। निरंतर एजेंटिक स्कैनर स्पैम के तहत → निजी रूप से F + G जोड़ें।
2. प्रत्येक UUID को घुमाएँ। प्रति भाषा एक, प्रति अपनाने वाला अलग — एक आधार के उपसर्ग संस्करण नहीं। देखें ROTATE_UUID.md।
3. बिल्ड आर्टिफैक्ट्स से बहिष्कृत करें। Python: MANIFEST.in prune कैनरी पथ, या pyproject.toml tool.setuptools.exclude-package-data। C: CMakeLists.txt / Makefile / sdist से छोड़ें। Rust: कैनरी फ़ाइलों का संदर्भ देने वाला कोई mod स्टेटमेंट या path विशेषता न जोड़ें; Cargo.toml [lib]/[[bin]] पथ और cargo package exclude से बहिष्कृत करें। Go: बाधा पहले से ही से फ़ाइलों को बहिष्कृत करती है; कैनरी निर्देशिका में न रखें, और कैनरी पैकेज आयात न करें। Docker: ।

अपनाने वालों के स्निपेट

उपरोक्त बहिष्करण और स्वामित्व चरणों को बंद करने के लिए कॉपी-पेस्ट करें। नीचे के पथ honeyslop के c/ / python/ / js/ / rust/ / go/ लेआउट का उपयोग करते हैं; जहाँ भी आप कैनरीज़ उतारते हैं, वहाँ नाम बदलें (चरण 7 देखें) — बहिष्करणों को प्रतिबद्ध करना जो अभी भी canary/ या slop/ नामक निर्देशिकाओं की ओर इशारा करते हैं, स्वयं एक संकेत है।

MANIFEST.in

prune c
prune python
prune js
prune rust
prune go

pyproject.toml — setuptools

[tool.setuptools.exclude-package-data]
"*" = ["c/*", "python/*", "js/*", "rust/*", "go/*"]

.dockerignore

c/
python/
js/
rust/
go/

.semgrepignore

c/
python/
js/
rust/
go/

CodeQL — .github/codeql/codeql-config.yml

paths-ignore:
  - c
  - python
  - js
  - rust
  - go

Bandit — CI आह्वान

bandit -r src/ -x python/

Ruff — pyproject.toml

[tool.ruff]
extend-exclude = ["python/"]

.clang-format-ignore

c/*

सीक्रेट-स्कैनर अनुमति सूची — gitleaks .gitleaks.toml

[allowlist]
regexes = [
  '''AKIAIOSFODNN7EXAMPLE''',
  '''ghp_[A-Za-z0-9]{36}''',
  '''xoxb-[0-9A-Za-z-]+''',
  '''sk_live_[A-Za-z0-9]+''',
]

Cargo.toml — crate पैकेज से बहिष्कृत करें

[package]
exclude = ["rust/"]

Clippy — CI आह्वान

cargo clippy --workspace -- --allow-dead-code

या कैनरी निर्देशिका को पूरी तरह से छोड़ दें, इसे किसी mod ट्री में संदर्भित न करके (डिफ़ॉल्ट — compile_error! आकस्मिक समावेश को पकड़ लेगा)।

golangci-lint — .golangci.yml

issues:
  exclude-dirs:
    - go

या //go:build ignore बाधा पर भरोसा करें, जो पहले से ही Go टूलचेन को कैनरी फ़ाइलों को संकलित करने से रोकता है।

.github/CODEOWNERS

c/       @your-org/sec-team
python/  @your-org/sec-team
js/      @your-org/sec-team
rust/    @your-org/sec-team
go/      @your-org/sec-team

मालिकों को एक छोटा समूह होना चाहिए जो समझता हो कि क्यों ये पथ कमजोर दिखते हैं — ताकि "मृत कोड साफ़ करें" PR अवरुद्ध हो जाएँ, मर्ज न हों।

सावधान रहें

बाल्टी 1 — आपके अपने उपकरण ट्रिप होते हैं। आपके स्कैनर, लिंटर्स, IDE और सीक्रेट-स्कैनिंग कैनरी पर फायर करेंगे। यह आने वाले स्कैन के लिए अभीष्ट व्यवहार है, लेकिन इसका मतलब है कि आपकी अपनी पाइपलाइनों को इन पथों को छोड़ना होगा। आवश्यक:

• कैनरी पथों को प्रत्येक SAST कॉन्फ़िगरेशन से बहिष्कृत करें (CodeQL paths-ignore, .semgrepignore, bandit -x, Ruff --extend-exclude, .clang-format-ignore, एडिटर LSP)।
• प्रकाशित आर्टिफैक्ट्स से बहिष्कृत करें (MANIFEST.in prune, .dockerignore, व्हील बहिष्करण)।
• अपने सीक्रेट स्कैनर में नकली रहस्यों को अनुमति सूची में डालें (AKIAIOSFODNN7EXAMPLE, नकली ghp_ / xoxb- / sk_live_)।
• योगदानकर्ताओं को चेतावनी दें कि वे हनीपॉट को "साफ़" न करें। लिंटर द्वारा if False: ट्रिपवायर को हटाने और # noqa / # nosec डालने पर नज़र रखें।

बाल्टी 2 — प्रभावशीलता का क्षरण। सार्वजनिक कैनरी 6–18 महीनों में LLM प्रशिक्षण कोरपोरा में प्रवेश करती हैं और स्कैनर विक्रेता स्किप-ह्युरिस्टिक्स जोड़ते हैं। UUID, बैनर, शिब्बोलेथ और नकली CVE को वार्षिक रूप से घुमाएँ (देखें ROTATE_UUID.md); अपनाने वालों के बीच शब्दावली बदलें; F+G को निजी रखें। यह मॉडलों को कोड सीखने से नहीं रोकेगा, लेकिन कुछ समय खरीद सकता है।

बाल्टी 3 — समझौते के बाद। यदि किसी हमलावर के पास पहले से पहुँच है, तो वे जो चाहें कर सकते हैं, और उन्हें honeyslop की आवश्यकता नहीं है। हालांकि, if False: → if True: फ़्लिप करना, Unicode/BIDI ट्रिक्स डालना, या डॉकस्ट्रिंग में प्रॉम्प्ट-इंजेक्शन टेक्स्ट जोड़ना एक कैनरी को वहाँ लाइव कर सकता है जहाँ आप इसकी उम्मीद नहीं करते। देखने लायक है, यदि असंभावित है।

अस्वीकरण

यह परियोजना MIT लाइसेंस के तहत प्रदान की गई है; वारंटी और देयता शर्तों के लिए LICENSE देखें। लागू कानूनों और विनियमों के साथ-साथ इसमें शामिल किसी भी उपकरण या प्लेटफ़ॉर्म की सेवा की शर्तों का अनुपालन करना अंतिम उपयोगकर्ता की जिम्मेदारी है।

चेतावनी: इस परियोजना में ऐसा कोड है जो कमजोर दिखता है, और इसे ऐसा मान लिया जाना चाहिए। इसका कुछ भाग विश्लेषण करने के लिए महँगा होने के द्वारा काम करता है — मान लें कि यह कोड कैनरी के आधार पर स्कैनर द्वारा निरीक्षण किए जाने पर महत्वपूर्ण कंप्यूटिंग संसाधनों का उपभोग करेगा। कोई भी संशोधन, स्वचालित या अन्यथा, एक कैनरी को लाइव कर सकता है। इसे वास्तविक वातावरण में न चलाएँ, तैनात न करें, या अनुकूलित न करें।

लाइसेंस

MIT के तहत लाइसेंस प्राप्त। LICENSE देखें।