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

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

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

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

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

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
spamscanner — Spam Scanner एक Node.js एंटी-स्पैम, ईमेल फ़िल्टरिंग और फ़िशिंग रोकथाम उपकरण और सेवा है। @ladjs, @forwardemail, @cabinjs, @breejs और @lassjs के लिए बनाया गया। | Kitploit
उपकरण/GitHubGitHub/spamscanner/spamscanner
स्थैतिक विश्लेषणभेद्यता स्कैनरगतिशील विश्लेषण (सैंडबॉक्सिंग)फिशिंगखतरा खुफियामशीन लर्निंगघटना प्रतिक्रियाएंटी-बॉटईमेल सुरक्षा
GitHubspamscanner/spamscanner

spamscanner

Spam Scanner एक Node.js एंटी-स्पैम, ईमेल फ़िल्टरिंग और फ़िशिंग रोकथाम उपकरण और सेवा है। @ladjs, @forwardemail, @cabinjs, @breejs और @lassjs के लिए बनाया गया।

374388 महीने पहलेKitploit द्वारा समीक्षित

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

सभी देखें →

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

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

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

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

spamscanner

build status code style styled with prettier made with lass license

Spam Scanner सबसे अच्छी एंटी-स्पैम, ईमेल फ़िल्टरिंग, और फ़िशिंग रोकथाम सेवा है।
Spam Scanner एक ड्रॉप-इन रिप्लेसमेंट और SpamAssassin, rspamd, SpamTitan, और अन्य का सबसे अच्छा विकल्प है।

[!NOTE] Spam Scanner को सक्रिय रूप से बनाए रखा जाता है और Forward Email पर प्रोडक्शन में प्रतिदिन लाखों ईमेल की सुरक्षा के लिए उपयोग किया जाता है।

तालिका

  • प्रस्तावना
  • स्थापना
    • npm (अनुशंसित)
    • स्टैंडअलोन बाइनरी (Node.js की आवश्यकता नहीं)
    • ClamAV स्थापना (वैकल्पिक)
  • CLI (कमांड लाइन इंटरफ़ेस)
    • CLI स्थापना
    • कमांड
    • एक्ज़िट कोड
    • CLI उदाहरण
  • Spam Scanner क्यों
    • मुख्य लाभ
  • विशेषताएँ
    • मुख्य पहचान विशेषताएँ
    • Naive Bayes वर्गीकारक
    • फ़िशिंग पहचान
    • वायरस स्कैनिंग
    • एक्ज़ीक्यूटेबल पहचान
    • NSFW छवि पहचान
    • विषाक्तता पहचान
    • मैक्रो पहचान
    • भाषा पहचान
    • पैटर्न पहचान
    • URL विश्लेषण
  • तुलना
    • Spam Scanner बनाम विकल्प
  • वास्तुकला
    • सिस्टम अवलोकन
    • पहचान प्रवाह
    • घटक वास्तुकला
  • आवश्यकताएँ
    • सिस्टम आवश्यकताएँ
    • निर्भरताएँ
  • त्वरित आरंभ
    • मूल उपयोग
    • कॉन्फ़िगरेशन के साथ
    • विशिष्ट सुविधाओं की जाँच
  • API दस्तावेज़ीकरण
    • कंस्ट्रक्टर विकल्प
    • विधियाँ

प्रस्तावना

Spam Scanner एक ऐसा उपकरण और सेवा है जो मौजूदा स्पैम-पहचान समाधानों के साथ असंख्य बाधाओं का सामना करने के बाद बनाई गई है। दूसरे शब्दों में, यह स्पैम के लिए हमारी वर्तमान योजना और बेहतर योजना है।

हमारा लक्ष्य Forward Email पर अपनी सेवा में उपयोग के लिए एक स्केलेबल, प्रदर्शनशील, सरल, बनाए रखने में आसान और शक्तिशाली API का निर्माण और उपयोग करना है, ताकि स्पैम को सीमित किया जा सके और हमारे उपयोगकर्ताओं पर हमलों को रोकने के लिए अन्य उपाय प्रदान किए जा सकें।

शुरुआत में हमने SpamAssassin का उपयोग करने की कोशिश की, और बाद में rspamd का मूल्यांकन किया – लेकिन अंत में हमें पता चला कि सभी मौजूदा समाधान (इनके अलावा भी) अत्यधिक जटिल हैं, आवश्यक सुविधाओं या दस्तावेज़ीकरण की कमी है, कॉन्फ़िगर करने में अविश्वसनीय रूप से कठिन हैं; प्रवेश में उच्च बाधा है, या उनके पास मालिकाना स्टोरेज बैकएंड हैं (जो आपकी सहमति के बिना आपके संदेशों को स्टोर और पढ़ सकते हैं) जो हमारी स्केलेबिलिटी को सीमित करते हैं।

हमारे लिए, हम डेटा और उपयोगकर्ताओं की गोपनीयता और सुरक्षा को महत्व देते हैं – विशेष रूप से हमारी "किसी भी प्रकार के लॉग या मेटाडेटा को संग्रहीत न करने की शून्य-सहिष्णुता नीति" है (इस पर अधिक जानकारी के लिए हमारी गोपनीयता नीति देखें)। इनमें से किसी भी समाधान ने इस गोपनीयता नीति का सम्मान नहीं किया (आवश्यक स्पैम-पहचान कार्यक्षमता को हटाए बिना), इसलिए हमें अपना स्वयं का उपकरण बनाना पड़ा – इस प्रकार "Spam Scanner" का जन्म हुआ।

स्थापना

npm (अनुशंसित)```bash

npm install spamscanner

root@kitploit:~
CLI उपयोग के लिए:```bash
# Install globally
npm install -g spamscanner

# Or use npx without installing
npx spamscanner scan email.eml

स्वतंत्र बाइनरी (Node.js की आवश्यकता नहीं)

अपने प्लेटफ़ॉर्म के लिए पूर्व-निर्मित बाइनरी डाउनलोड करें। ये स्व-निहित निष्पादन योग्य फ़ाइलें हैं जिन्हें Node.js की आवश्यकता नहीं है।

डाउनलोड लिंक और प्लेटफ़ॉर्म-विशिष्ट निर्देशों के लिए CLI स्थापना देखें।

ClamAV स्थापना (वैकल्पिक)

macOS```bash

brew install clamav freshclam

root@kitploit:~
#### Ubuntu/Debian```bash
sudo apt-get update
sudo apt-get install clamav clamav-daemon
sudo freshclam
sudo systemctl start clamav-daemon

CentOS/RHEL```bash

sudo yum install clamav clamav-update sudo freshclam

root@kitploit:~
> \[!TIP]
> विस्तृत स्थापना निर्देशों के लिए [ClamAV कॉन्फ़िगरेशन गाइड](https://github.com/spamscanner/spamscanner/blob/master/docs/clamav.md) देखें।

---


## CLI (कमांड लाइन इंटरफ़ेस)

SpamScanner ईमेल को सीधे टर्मिनल से स्कैन करने या मेल सर्वरों के साथ एकीकृत करने के लिए एक कमांड-लाइन इंटरफ़ेस प्रदान करता है।

### CLI स्थापना

SpamScanner को npm के माध्यम से या एक स्टैंडअलोन बाइनरी के रूप में स्थापित किया जा सकता है। स्टैंडअलोन बाइनरी में Node.js और सभी निर्भरताएँ शामिल हैं, इसलिए किसी अतिरिक्त रनटाइम की आवश्यकता नहीं है।

#### npm के माध्यम से स्थापित करें (Node.js आवश्यक)```bash
# Install globally
npm install -g spamscanner

# Or use npx without installing
npx spamscanner --help

स्टैंडअलोन बाइनरी इंस्टॉल करें

macOS```bash

Download manually for Apple Silicon (M1/M2/M3)

curl -fsSL https://github.com/spamscanner/spamscanner/releases/latest/download/spamscanner-darwin-arm64 -o /usr/local/bin/spamscanner chmod +x /usr/local/bin/spamscanner

root@kitploit:~
Please provide the Markdown content to translate.```bash
# Download manually for Intel Mac
curl -fsSL https://github.com/spamscanner/spamscanner/releases/latest/download/spamscanner-darwin-x64 -o /usr/local/bin/spamscanner
chmod +x /usr/local/bin/spamscanner
Linux```bash

Download and install to /usr/local/bin

sudo curl -fsSL https://github.com/spamscanner/spamscanner/releases/latest/download/spamscanner-linux-x64 -o /usr/local/bin/spamscanner sudo chmod +x /usr/local/bin/spamscanner

Add to PATH if not already: export PATH="$HOME/.local/bin:$PATH"

root@kitploit:~
INPUT:```bash
# Or install to user directory (no sudo required)
mkdir -p ~/.local/bin
curl -fsSL https://github.com/spamscanner/spamscanner/releases/latest/download/spamscanner-linux-x64 -o ~/.local/bin/spamscanner
chmod +x ~/.local/bin/spamscanner
# Add to PATH if not already: export PATH="$HOME/.local/bin:$PATH"
विंडोज़```powershell

Using PowerShell (run as Administrator)

Invoke-WebRequest -Uri "https://github.com/spamscanner/spamscanner/releases/latest/download/spamscanner-win-x64.exe" -OutFile "C:\Program Files\spamscanner\spamscanner.exe"

Add to PATH via System Properties > Environment Variables

root@kitploit:~
llama.cpp Apple Silicon MacBook पर LLM मॉडल चलाने का एक न्यूनतम उदाहरण प्रदान करता है।```powershell
# Or download to current directory
Invoke-WebRequest -Uri "https://github.com/spamscanner/spamscanner/releases/latest/download/spamscanner-win-x64.exe" -OutFile ".\spamscanner.exe"
# Add to PATH via System Properties > Environment Variables
स्थापना सत्यापित करें```bash

Check version

spamscanner version

Check for updates

spamscanner update

root@kitploit:~
#### Automatic Updates

SpamScanner CLI स्वचालित रूप से हर 24 घंटे में एक बार अपडेट की जाँच करता है और यदि कोई नया संस्करण उपलब्ध होता है तो एक सूचना प्रदर्शित करता है। आप मैन्युअल रूप से भी अपडेट की जाँच कर सकते हैं:```bash
# Check for updates
spamscanner update

# Disable automatic update checks
spamscanner scan email.eml --no-update-check

नवीनतम संस्करण में अपडेट करने के लिए, बस अपने प्लेटफॉर्म के लिए इंस्टॉलेशन कमांड को फिर से चलाएँ या npm का उपयोग करें:```bash

Update via npm

npm update -g spamscanner

Or re-download the binary (macOS/Linux)

curl -fsSL https://github.com/spamscanner/spamscanner/releases/latest/download/spamscanner-$(uname -s | tr '[:upper:]' '[:lower:]')-$(uname -m | sed 's/x86_64/x64/' | sed 's/aarch64/arm64/') -o /usr/local/bin/spamscanner chmod +x /usr/local/bin/spamscanner

root@kitploit:~
### कमांड्स

| कमांड                       | विवरण                        |
| ------------------------- | ----------------------------- |
| `spamscanner scan <file>` | एक ईमेल फ़ाइल स्कैन करें        |
| `spamscanner scan -`      | stdin से ईमेल स्कैन करें        |
| `spamscanner server`      | TCP सर्वर मोड प्रारंभ करें       |
| `spamscanner help`        | सहायता संदेश दिखाएँ            |
| `spamscanner version`     | संस्करण संख्या दिखाएँ          |
| `spamscanner update`      | अपडेट की जाँच करें             |

#### सामान्य विकल्प

| विकल्प              | विवरण                                         |
| ------------------- | ---------------------------------------------- |
| `-h, --help`        | सहायता दिखाएँ                                 |
| `-v, --version`     | संस्करण दिखाएँ                                |
| `-j, --json`        | परिणाम JSON के रूप में आउटपुट करें             |
| `--verbose`         | विस्तृत आउटपुट दिखाएँ                         |
| `--debug`           | डीबग मोड सक्षम करें                            |
| `--timeout <ms>`    | मिलीसेकंड में स्कैन टाइमआउट (डिफ़ॉल्ट: 30000)  |
| `--no-update-check` | स्वचालित अपडेट जाँच अक्षम करें                 |

#### स्पैम पहचान विकल्प

SpamScanner एकाधिक पहचान विधियों के आधार पर एक स्पैम स्कोर की गणना करता है। आप कॉन्फ़िगर कर सकते हैं कि कौन सी जाँचें शामिल हैं और स्कोर भार को अनुकूलित कर सकते हैं।

| विकल्प                | विवरण                                                   |
| --------------------- | -------------------------------------------------------- |
| `--threshold <score>` | स्पैम स्कोर सीमा (डिफ़ॉल्ट: 5.0)                        |
| `--check-classifier`  | स्कोरिंग में बायेसियन क्लासिफायर शामिल करें (डिफ़ॉल्ट)   |
| `--check-phishing`    | स्कोरिंग में फ़िशिंग पहचान शामिल करें (डिफ़ॉल्ट)        |
| `--check-executables` | स्कोरिंग में एक्ज़ीक्यूटेबल पहचान शामिल करें (डिफ़ॉल्ट)  |
| `--check-macros`      | स्कोरिंग में मैक्रो पहचान शामिल करें (डिफ़ॉल्ट)          |
| `--check-virus`       | स्कोरिंग में वायरस पहचान शामिल करें (डिफ़ॉल्ट)          |
| `--check-nsfw`        | स्कोरिंग में NSFW पहचान शामिल करें (अक्षम)              |
| `--check-toxicity`    | स्कोरिंग में विषाक्तता पहचान शामिल करें (अक्षम)         |
| `--no-classifier`     | बायेसियन क्लासिफायर स्कोरिंग अक्षम करें                |
| `--no-phishing`       | फ़िशिंग स्कोरिंग अक्षम करें                             |
| `--no-executables`    | एक्ज़ीक्यूटेबल स्कोरिंग अक्षम करें                     |
| `--no-macros`         | मैक्रो स्कोरिंग अक्षम करें                              |
| `--no-virus`          | वायरस स्कोरिंग अक्षम करें                               |

#### स्कोर भार

प्रत्येक पहचान प्रकार कुल स्पैम स्कोर में कितना योगदान देता है, इसे अनुकूलित करें:

| विकल्प                   | विवरण                                      |
| ------------------------ | ------------------------------------------- |
| `--score-classifier <n>` | क्लासिफायर स्पैम स्कोर भार (डिफ़ॉल्ट: 5.0) |
| `--score-phishing <n>`   | प्रति मुद्दा फ़िशिंग स्कोर (डिफ़ॉल्ट: 5.0) |
| `--score-executable <n>` | प्रति फ़ाइल एक्ज़ीक्यूटेबल स्कोर (डिफ़ॉल्ट: 10.0) |
| `--score-macro <n>`      | प्रति पहचान मैक्रो स्कोर (डिफ़ॉल्ट: 5.0)  |
| `--score-virus <n>`      | प्रति पहचान वायरस स्कोर (डिफ़ॉल्ट: 100.0) |
| `--score-nsfw <n>`       | प्रति पहचान NSFW स्कोर (डिफ़ॉल्ट: 3.0)    |
| `--score-toxicity <n>`   | प्रति पहचान विषाक्तता स्कोर (डिफ़ॉल्ट: 3.0) |

#### हैडर विकल्प

मेल सर्वर एकीकरण के लिए, SpamScanner ईमेल में X-Spam हैडर जोड़ सकता है ([SpamAssassin](https://github.com/apache/spamassassin) और [Stalwart](https://github.com/stalwartlabs/stalwart) के समान):

| विकल्प                | विवरण                                           |
| --------------------- | ------------------------------------------------ |
| `--add-headers`       | आउटपुट में X-Spam-* हैडर जोड़ें                  |
| `--prepend-subject`   | यदि स्पैम पाया जाता है तो विषय में [SPAM] जोड़ें |
| `--subject-tag <tag>` | कस्टम विषय टैग (डिफ़ॉल्ट: [SPAM])                |

**जोड़े गए X-Spam हैडर:**

| हैडर          | विवरण                                                                 |
| --------------- | ---------------------------------------------------------------------- |
| `X-Spam-Status` | हाँ/नहीं, स्कोर=X.X आवश्यक=Y.Y परीक्षण=TEST1,TEST2,... संस्करण=X.X.X |
| `X-Spam-Score`  | संख्यात्मक स्पैम स्कोर (जैसे, `7.5`)                                   |
| `X-Spam-Flag`   | `YES` या `NO`                                                          |
| `X-Spam-Tests`  | ट्रिगर किए गए परीक्षणों की अल्पविराम से अलग की गई सूची                |

#### स्कैनर कॉन्फ़िगरेशन विकल्प

ये विकल्प अंतर्निहित SpamScanner इंजन को कॉन्फ़िगर करते हैं:

| विकल्प                     | विवरण                                                   |
| -------------------------- | -------------------------------------------------------- |
| `--languages <list>`       | अल्पविराम से अलग किए गए भाषा कोड (डिफ़ॉल्ट: सभी भाषाएँ) |
| `--mixed-language`         | ईमेल में मिश्रित भाषा पहचान सक्षम करें                   |
| `--no-macro-detection`     | अटैचमेंट में मैक्रो पहचान अक्षम करें                     |
| `--no-pattern-recognition` | उन्नत पैटर्न पहचान अक्षम करें                            |
| `--strict-idn`             | सख्त IDN/होमोग्राफ पहचान सक्षम करें                     |
| `--nsfw-threshold <n>`     | NSFW पहचान सीमा 0.0-1.0 (डिफ़ॉल्ट: 0.6)                |
| `--toxicity-threshold <n>` | विषाक्तता पहचान सीमा 0.0-1.0 (डिफ़ॉल्ट: 0.7)            |
| `--clamscan-path <path>`   | clamscan बाइनरी का पथ (डिफ़ॉल्ट: /usr/bin/clamscan)    |
| `--clamdscan-path <path>`  | clamdscan बाइनरी का पथ (डिफ़ॉल्ट: /usr/bin/clamdscan)  |

##### समर्थित भाषाएँ

`--languages` विकल्प के साथ ISO 639-1 भाषा कोड का उपयोग करें। सभी भाषाओं को सक्षम करने के लिए एक खाली स्ट्रिंग या `all` पास करें (डिफ़ॉल्ट)।

| कोड | भाषा          | कोड | भाषा      | कोड | भाषा      |
| ---- | --------------- | ---- | ---------- | ---- | ---------- |
| `en` | अंग्रेज़ी         | `fr` | फ़्रेंच     | `es` | स्पेनिश    |
| `de` | जर्मन          | `it` | इतालवी    | `pt` | पुर्तगाली |
| `ru` | रूसी         | `ja` | जापानी   | `ko` | कोरियाई     |
| `zh` | चीनी         | `ar` | अरबी     | `hi` | हिंदी      |
| `bn` | बंगाली         | `ur` | उर्दू       | `tr` | तुर्की    |
| `pl` | पोलिश          | `nl` | डच      | `sv` | स्वीडिश    |
| `no` | नॉर्वेजियन       | `da` | डेनिश      | `fi` | फ़िनिश    |
| `hu` | हंगेरियन       | `cs` | चेक      | `sk` | स्लोवाक     |
| `sl` | स्लोवेनियन       | `hr` | क्रोएशियन   | `sr` | सर्बियन    |
| `bg` | बल्गेरियन       | `ro` | रोमानियन   | `el` | ग्रीक      |
| `he` | हिब्रू          | `th` | थाई       | `vi` | वियतनामी |
| `id` | इंडोनेशियाई      | `ms` | मलय      | `tl` | तागालोग    |
| `uk` | यूक्रेनी       | `be` | बेलारूसी | `lt` | लिथुआनियाई |
| `lv` | लातवियाई         | `et` | एस्टोनियाई   | `ca` | कैटलन    |
| `eu` | बास्क          | `gl` | गैलिशियन | `ga` | आयरिश      |
| `gd` | स्कॉटिश गेलिक | `cy` | वेल्श      | `is` | आइसलैंडिक  |
| `mt` | माल्टीज़         | `af` | अफ्रीकी  | `sw` | स्वाहिली    |
| `am` | अम्हारिक         | `ha` | हौसा      | `yo` | योरूबा     |
| `ig` | इग्बो            | `so` | सोमाली     | `om` | ओरोमो      |
| `ti` | तिग्रीन्या        | `mg` | मालागासी   | `ny` | चिचेवा   |
| `sn` | शोना           | `xh` | खोसा      | `zu` | ज़ुलू       |
| `st` | दक्षिणी सोथो  | `tn` | त्स्वाना     |      |            |

#### सर्वर विकल्प

| विकल्प          | विवरण                             |
| --------------- | --------------------------------- |
| `--port <port>` | TCP सर्वर पोर्ट (डिफ़ॉल्ट: 7830)    |
| `--host <host>` | TCP सर्वर होस्ट (डिफ़ॉल्ट: 127.0.0.1) |

### निकास कोड

| कोड | अर्थ                      |
| ---- | ------------------------- |
| `0`  | साफ़ (स्पैम नहीं)         |
| `1`  | स्पैम पाया गया            |
| `2`  | त्रुटि हुई                 |

### CLI उदाहरण```bash
# Scan a file
spamscanner scan email.eml

# Scan from stdin (for Postfix integration)
cat email.eml | spamscanner scan -

# Scan with JSON output (includes score and tests)
spamscanner scan email.eml --json

# Scan with verbose output
spamscanner scan email.eml --verbose

# Scan with custom spam threshold
spamscanner scan email.eml --threshold 3.0

# Scan with only classifier and phishing checks
spamscanner scan email.eml --no-executables --no-macros --no-virus

# Scan and add X-Spam headers (for mail server integration)
spamscanner scan email.eml --add-headers

# Scan, add headers, and prepend [SPAM] to subject
spamscanner scan email.eml --add-headers --prepend-subject

# Scan with custom subject tag
spamscanner scan email.eml --add-headers --prepend-subject --subject-tag "[JUNK]"

# Enable NSFW and toxicity checks with custom weights
spamscanner scan email.eml --check-nsfw --check-toxicity --score-nsfw 5.0

# Start TCP server on custom port
spamscanner server --port 8080

# Start TCP server with custom threshold
spamscanner server --port 8080 --threshold 3.0

# Scan with specific language support (English, Spanish, French only)
spamscanner scan email.eml --languages en,es,fr

# Scan with mixed language detection enabled
spamscanner scan email.eml --mixed-language

# Scan with strict IDN/homograph detection
spamscanner scan email.eml --strict-idn

# Scan with custom NSFW threshold (more sensitive)
spamscanner scan email.eml --check-nsfw --nsfw-threshold 0.3

# Scan with custom ClamAV paths
spamscanner scan email.eml --clamscan-path /opt/clamav/bin/clamscan

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

{ "isSpam": true, "score": 7.5, "threshold": 5.0, "tests": ["BAYES_SPAM(5.0)", "PHISHING_DETECTED(2.5)"], "message": "Spam", "results": { "classification": { "category": "spam", "probability": 0.95 }, "phishing": [{ "type": "suspicious_link", "url": "http://example.com" }] }, "headers": { "X-Spam-Status": "Yes, score=7.5 required=5.0 tests=BAYES_SPAM(5.0),PHISHING_DETECTED(2.5) version=6.0.1", "X-Spam-Score": "7.5", "X-Spam-Flag": "YES", "X-Spam-Tests": "BAYES_SPAM(5.0), PHISHING_DETECTED(2.5)" } }

root@kitploit:~
---

## स्पैम स्कैनर क्यों?

> \[!TIP]
> स्पैम स्कैनर एकमात्र आधुनिक, गोपनीयता-केंद्रित, Node.js-आधारित स्पैम डिटेक्शन समाधान है जिसमें AI-संचालित सुविधाएँ हैं।

### मुख्य लाभ

* **🔒 गोपनीयता-प्रथम** - शून्य लॉगिंग, शून्य मेटाडेटा भंडारण
* **🚀 आधुनिक** - Node.js 18+, ES मॉड्यूल और नवीनतम AI मॉडल के साथ निर्मित
* **🎯 सटीक** - Naive Bayes क्लासिफायर के साथ 88%+ डिटेक्शन सटीकता
* **⚡ तेज़** - ईमेल को 3 सेकंड से कम में स्कैन करता है (मॉडल कैशिंग के साथ)
* **🛡️ व्यापक** - 10+ डिटेक्शन विधियाँ (वायरस, फिशिंग, NSFW, विषाक्तता, मैक्रो, आदि)
* **🌍 बहुभाषी** - स्वचालित डिटेक्शन के साथ 40+ भाषाओं का समर्थन
* **🔧 उपयोग में आसान** - सरल API, व्यापक दस्तावेज़ीकरण, TypeScript समर्थन
* **📊 युद्ध-परीक्षित** - फॉरवर्ड ईमेल पर उत्पादन में उपयोग

---


## सुविधाएँ

स्पैम स्कैनर में आधुनिक, आवश्यक और उच्च-प्रदर्शन वाली सुविधाएँ शामिल हैं जो स्पैम, फिशिंग और निष्पादन योग्य हमलों को कम करने में मदद करती हैं।

### मुख्य डिटेक्शन सुविधाएँ

| Feature                                               | Description                                                        | Status       |
| ----------------------------------------------------- | ------------------------------------------------------------------ | ------------ |
| **[Naive Bayes Classifier](#naive-bayes-classifier)** | 100K+ ईमेल पर प्रशिक्षित मशीन लर्निंग स्पैम वर्गीकरण               | ✅ उत्पादन |
| **[Phishing Detection](#phishing-detection)**         | IDN होमोग्राफ डिटेक्शन, कंफ्यूज़ेबल्स, संदिग्ध लिंक विश्लेषण     | ✅ उत्पादन |
| **[Virus Scanning](#virus-scanning)**                 | अटैचमेंट स्कैनिंग के लिए ClamAV एकीकरण                         | ✅ उत्पादन |
| **[Executable Detection](#executable-detection)**     | 195+ खतरनाक फ़ाइल एक्सटेंशन + मैजिक नंबर सत्यापन का पता लगाता है | ✅ उत्पादन |
| **[NSFW Image Detection](#nsfw-image-detection)**     | TensorFlow.js-संचालित छवि सामग्री विश्लेषण                       | ✅ उत्पादन |
| **[Toxicity Detection](#toxicity-detection)**         | AI-संचालित विषाक्त भाषा डिटेक्शन (धमकी, अपमान, उत्पीड़न)     | ✅ उत्पादन |
| **[Macro Detection](#macro-detection)**               | अटैचमेंट में VBA, PowerShell, JavaScript, बैच स्क्रिप्ट डिटेक्शन | ✅ उत्पादन |
| **[Language Detection](#language-detection)**         | 40+ भाषाओं के लिए हाइब्रिड franc/lande डिटेक्शन                     | ✅ उत्पादन |
| **[Pattern Recognition](#pattern-recognition)**       | क्रेडिट कार्ड, फ़ोन नंबर, IP, बिटकॉइन पते, आदि।          | ✅ उत्पादन |
| **[URL Analysis](#url-analysis)**                     | TLD पार्सिंग, Cloudflare ब्लॉकिंग डिटेक्शन, संदिग्ध डोमेन     | ✅ उत्पादन |

### Naive Bayes Classifier

हमारा Naive Bayesian क्लासिफायर इस [repository](https://github.com/spamscanner/spamscanner/blob/HEAD/classifier.json), npm पैकेज में उपलब्ध है, और बार-बार अपडेट किया जाता है क्योंकि यह [Forward Email](https://forwardemail.net) से अपस्ट्रीम, अज्ञात, SHA-256 हैशेड डेटा प्राप्त करता है।

* **प्रशिक्षण डेटा**: 100,000+ स्पैम और हैम ईमेल
* **सटीकता**: 88%+ वर्गीकरण सटीकता
* **भाषाएँ**: भाषा-विशिष्ट टोकनाइज़ेशन के साथ 40+ भाषाओं का समर्थन
* **स्टेमिंग**: अंग्रेजी के लिए Porter Stemmer, 15+ अन्य भाषाओं के लिए Snowball
* **गोपनीयता**: सभी प्रशिक्षण डेटा को गुमनाम और SHA-256 हैश किया गया है

### Phishing Detection

एकाधिक तकनीकों का उपयोग करके उन्नत फिशिंग डिटेक्शन:

* **IDN Homograph Detection**: समान दिखने वाले डोमेन का पता लगाता है (जैसे, सिरिलिक "а" का उपयोग करके `аpple.com`)
* **Confusables Integration**: वर्ण प्रतिस्थापन का पता लगाने के लिए Unicode कंफ्यूज़ेबल्स डेटाबेस का उपयोग करता है
* **TLD Analysis**: TLD को मान्य करता है और संदिग्ध डोमेन पैटर्न का पता लगाता है
* **Link Analysis**: मिलान न होने वाले डिस्प्ले टेक्स्ट और वास्तविक URL की जाँच करता है
* **Cloudflare Detection**: Cloudflare द्वारा ब्लॉक किए गए डोमेन की पहचान करता है

### Virus Scanning

व्यापक वायरस डिटेक्शन के लिए ClamAV के साथ एकीकरण:

* **रियल-टाइम स्कैनिंग**: सभी ईमेल अटैचमेंट को स्कैन करता है
* **बफ़र सपोर्ट**: फ़ाइल I/O के बिना प्रत्यक्ष बफ़र स्कैनिंग
* **टाइमआउट सुरक्षा**: कॉन्फ़िगरेबल स्कैन टाइमआउट
* **वायरस डेटाबेस**: ClamAV के नियमित रूप से अपडेट किए जाने वाले वायरस परिभाषाओं का उपयोग करता है

### Executable Detection

खतरनाक निष्पादन योग्य फ़ाइलों का पता लगाता है:

* **195+ फ़ाइल एक्सटेंशन**: exe, dll, bat, vbs, ps1, scr, pif, cmd, com, आदि।
* **मैजिक नंबर सत्यापन**: फ़ाइल सामग्री द्वारा नाम बदले गए निष्पादन योग्य का पता लगाता है
* **Office मैक्रो**: मैक्रो-सक्षम Office दस्तावेज़ों का पता लगाता है (docm, xlsm, pptm)
* **लीगेसी Office**: लीगेसी Office प्रारूपों (doc, xls, ppt) को उच्च-जोखिम के रूप में चिह्नित करता है
* **PDF JavaScript**: PDF फ़ाइलों में दुर्भावनापूर्ण JavaScript का पता लगाता है
* **आर्काइव डिटेक्शन**: उन आर्काइव (zip, rar, 7z) को चिह्नित करता है जो निष्पादन योग्य छुपा सकते हैं

### NSFW Image Detection

TensorFlow.js का उपयोग कर AI-संचालित छवि सामग्री विश्लेषण:

* **श्रेणियाँ**: पोर्न, हेंताई, सेक्सी, न्यूट्रल, ड्रॉइंग
* **मॉडल**: NSFWJS मॉडल 60K+ छवियों पर प्रशिक्षित
* **थ्रेशोल्ड**: कॉन्फ़िगरेबल डिटेक्शन थ्रेशोल्ड (डिफ़ॉल्ट: 0.7)
* **प्रदर्शन**: तेज़ अनुवर्ती स्कैन के लिए मॉडल कैशिंग
* **प्रारूप**: JPEG, PNG, GIF, WebP, BMP का समर्थन करता है

### Toxicity Detection

TensorFlow.js Toxicity मॉडल का उपयोग कर विषाक्त भाषा का पता लगाता है:

* **श्रेणियाँ**: पहचान हमला, अपमान, अश्लीलता, गंभीर विषाक्तता, यौन स्पष्टता, धमकी
* **थ्रेशोल्ड**: कॉन्फ़िगरेबल विषाक्तता थ्रेशोल्ड (डिफ़ॉल्ट: 0.7)
* **भाषाएँ**: अंग्रेजी के लिए अनुकूलित, अन्य भाषाओं का समर्थन करता है
* **प्रदर्शन**: तेज़ अनुवर्ती स्कैन के लिए मॉडल कैशिंग

### Macro Detection

ईमेल सामग्री और अटैचमेंट में दुर्भावनापूर्ण मैक्रो का पता लगाता है:

* **VBA Macros**: विज़ुअल बेसिक फॉर एप्लिकेशन कोड का पता लगाता है
* **PowerShell**: PowerShell स्क्रिप्ट और कमांड का पता लगाता है
* **JavaScript**: ईमेल में JavaScript कोड का पता लगाता है
* **बैच स्क्रिप्ट**: विंडोज बैच फ़ाइलों का पता लगाता है
* **Office दस्तावेज़**: docm, xlsm, pptm, xlam, dotm, xltm, potm स्कैन करता है
* **PDF JavaScript**: PDF अटैचमेंट में JavaScript का पता लगाता है

### Language Detection

franc और lande का उपयोग कर हाइब्रिड भाषा डिटेक्शन:

* **40+ भाषाएँ**: सभी प्रमुख विश्व भाषाओं का समर्थन करता है
* **स्वचालित डिटेक्शन**: ईमेल सामग्री से भाषा का पता लगाता है
* **फ़ॉलबैक सिस्टम**: जब franc "undetermined" लौटाता है तो lande का उपयोग करता है
* **मिश्रित भाषा समर्थन**: वैकल्पिक मिश्रित भाषा डिटेक्शन
* **भाषा फ़िल्टरिंग**: केवल समर्थित भाषाओं के लिए परिणाम फ़िल्टर करें

### Pattern Recognition

ईमेल सामग्री में विभिन्न पैटर्न का पता लगाता है:

* **क्रेडिट कार्ड**: Visa, MasterCard, Amex, Discover, आदि।
* **फ़ोन नंबर**: अंतर्राष्ट्रीय फ़ोन नंबर प्रारूप
* **ईमेल पते**: RFC-अनुरूप ईमेल डिटेक्शन
* **IP पते**: IPv4 और IPv6 पते
* **URL**: पूर्ण URL निष्कर्षण और विश्लेषण
* **बिटकॉइन पते**: क्रिप्टोकरेंसी वॉलेट पते
* **MAC पते**: नेटवर्क हार्डवेयर पते
* **हेक्स रंग**: रंग कोड (#RRGGBB)
* **फ़्लोटिंग पॉइंट संख्याएँ**: दशमलव संख्याएँ
* **दिनांक**: एकाधिक दिनांक प्रारूप (MM/DD/YYYY, YYYY-MM-DD, आदि)
* **फ़ाइल पथ**: विंडोज और यूनिक्स फ़ाइल पथ

### URL Analysis

व्यापक URL विश्लेषण और सत्यापन:

* **TLD पार्सिंग**: सटीक TLD निष्कर्षण के लिए tldts का उपयोग करता है
* **डोमेन विश्लेषण**: डोमेन, सबडोमेन, सार्वजनिक प्रत्यय निकालता है
* **IP डिटेक्शन**: IP-आधारित URL की पहचान करता है
* **Cloudflare जाँच**: Cloudflare-ब्लॉक किए गए डोमेन का पता लगाता है
* **URL सामान्यीकरण**: सुसंगत विश्लेषण के लिए URL को सामान्य करता है
* **संदिग्ध पैटर्न डिटेक्शन**: फिशिंग URL पैटर्न की पहचान करता है

---


## तुलना

### स्पैम स्कैनर बनाम विकल्प

| Feature                       | Spam Scanner |  SpamAssassin |     rspamd    |  ClamAV |
| ----------------------------- | :----------: | :-----------: | :-----------: | :-----: |
| **लाइसेंस**                   |    BSL 1.1   |   Apache 2.0  |   Apache 2.0  |  GPLv2  |
| **भाषा**                      |    Node.js   |      Perl     |       C       |    C    |
| **आधुनिक आर्किटेक्चर**        |     हाँ      |      नहीं     |     आंशिक    |   नहीं  |
| **उपयोग में आसान**            |     हाँ      |      नहीं     |      नहीं     |   हाँ   |
| **गोपनीयता-केंद्रित**          |     हाँ      |     आंशिक    |     आंशिक    |   हाँ   |
| **Naive Bayes Classifier**    |     हाँ      |      हाँ      |      हाँ      |   नहीं  |
| **वायरस स्कैनिंग**            |     हाँ      |      हाँ      |      हाँ      |   हाँ   |
| **फिशिंग डिटेक्शन**           |     हाँ      |      हाँ      |      हाँ      |   नहीं  |
| **IDN होमोग्राफ डिटेक्शन**    |     हाँ      |      नहीं     |      हाँ      |   नहीं  |
| **NSFW इमेज डिटेक्शन**        |     हाँ      |      नहीं     |      नहीं     |   नहीं  |
| **टॉक्सिसिटी डिटेक्शन**       |     हाँ      |      नहीं     |      नहीं     |   नहीं  |
| **मैक्रो डिटेक्शन**           |     हाँ      |      हाँ      |      हाँ      |   हाँ   |
| **भाषा डिटेक्शन**             |   हाँ (40+)  | हाँ (सीमित) | हाँ (सीमित) |   नहीं  |
| **पैटर्न पहचान**              |     हाँ      |      हाँ      |      हाँ      |   नहीं  |
| **निष्पादन योग्य डिटेक्शन**   |  हाँ (195+)  |      हाँ      |      हाँ      |   हाँ   |
| **मैजिक नंबर सत्यापन**       |     हाँ      |      नहीं     |      नहीं     |   हाँ   |
| **PDF JavaScript डिटेक्शन**   |     हाँ      |      नहीं     |      नहीं     | आंशिक |
| **आर्काइव डिटेक्शन**         |     हाँ      |      हाँ      |      हाँ      |   हाँ   |
| **प्रदर्शन मीट्रिक्स**         |     हाँ      |      नहीं     |      हाँ      |   नहीं  |
| **TypeScript समर्थन**          |     हाँ      |      नहीं     |      नहीं     |   नहीं  |
| **सक्रिय विकास**              |     हाँ      |      हाँ      |      हाँ      |   हाँ   |
| **उत्पादन के लिए तैयार**      |     हाँ      |      हाँ      |      हाँ      |   हाँ   |

> \[!NOTE]
> **SpamAssassin का विकल्प**: स्पैम स्कैनर AI-संचालित सुविधाओं और बेहतर गोपनीयता के साथ SpamAssassin का एक आधुनिक, Node.js-आधारित विकल्प प्रदान करता है।
>
> **rspamd का विकल्प**: स्पैम स्कैनर तुलनीय डिटेक्शन सटीकता के साथ rspamd की तुलना में आसान कॉन्फ़िगरेशन और बेहतर दस्तावेज़ीकरण प्रदान करता है।
>
> **ClamAV का विकल्प**: जबकि स्पैम स्कैनर वायरस स्कैनिंग के लिए ClamAV का उपयोग करता है, यह व्यापक स्पैम और फिशिंग डिटेक्शन प्रदान करता है जो ClamAV प्रदान नहीं करता है।

---


## आर्किटेक्चर

### सिस्टम अवलोकन```mermaid
graph TB
    A[Email Input] --> B{Spam Scanner}
    B --> C[Preprocessing]
    C --> D[Language Detection]
    D --> E[Tokenization]
    E --> F[Naive Bayes Classification]

    B --> G[Phishing Detection]
    G --> G1[IDN Homograph Check]
    G --> G2[Confusables Analysis]
    G --> G3[URL Analysis]

    B --> H[Attachment Scanning]
    H --> H1[Virus Scan]
    H --> H2[Executable Check]
    H --> H3[Macro Detection]
    H --> H4[NSFW Detection]

    B --> I[Content Analysis]
    I --> I1[Toxicity Detection]
    I --> I2[Pattern Recognition]

    F --> J[Result Aggregation]
    G --> J
    H --> J
    I --> J

    J --> K{Is Spam?}
    K -->|Yes| L[Spam Result]
    K -->|No| M[Ham Result]

पहचान प्रवाह```mermaid

sequenceDiagram participant Client participant Scanner participant Classifier participant ClamAV participant TensorFlow

root@kitploit:~
Client->>Scanner: scan(email)
Scanner->>Scanner: Parse Email
Scanner->>Scanner: Extract URLs
Scanner->>Scanner: Detect Language

par Parallel Detection
    Scanner->>Classifier: Classify Tokens
    Scanner->>ClamAV: Scan Attachments
    Scanner->>TensorFlow: Detect NSFW
    Scanner->>TensorFlow: Detect Toxicity
    Scanner->>Scanner: Check Phishing
    Scanner->>Scanner: Check Macros
end

Scanner->>Scanner: Aggregate Results
Scanner->>Client: Return Result
root@kitploit:~
### घटक आर्किटेक्चर```mermaid
graph LR
    A[Spam Scanner] --> B[Core Engine]
    A --> C[Classifiers]
    A --> D[Detectors]
    A --> E[Analyzers]

    B --> B1[Email Parser]
    B --> B2[Tokenizer]
    B --> B3[Preprocessor]

    C --> C1[Naive Bayes]
    C --> C2[TensorFlow NSFW]
    C --> C3[TensorFlow Toxicity]

    D --> D1[Phishing Detector]
    D --> D2[Virus Scanner]
    D --> D3[Macro Detector]
    D --> D4[Executable Detector]

    E --> E1[Language Analyzer]
    E --> E2[URL Analyzer]
    E --> E3[Pattern Analyzer]

आवश्यकताएँ

[!WARNING] वायरस स्कैनिंग के लिए ClamAV आवश्यक है। यदि आपने इसे स्थापित नहीं किया है, तो वायरस स्कैनिंग अक्षम हो जाएगी।

सिस्टम आवश्यकताएँ

  • Node.js: >= 18.0.0
  • ClamAV: नवीनतम संस्करण (वायरस स्कैनिंग के लिए)
  • Memory: 2GB+ RAM अनुशंसित (TensorFlow मॉडल के लिए)
  • Disk Space: 500MB+ (मॉडल और वायरस परिभाषाओं के लिए)

निर्भरताएँ

  • @tensorflow/tfjs-node: NSFW और विषाक्तता का पता लगाने के लिए
  • @ladjs/naivebayes: स्पैम वर्गीकरण के लिए
  • clamscan: वायरस स्कैनिंग के लिए
  • mailparser: ईमेल पार्सिंग के लिए
  • natural: NLP और टोकनाइज़ेशन के लिए
  • tldts: TLD पार्सिंग के लिए
  • confusables: यूनिकोड भ्रामक का पता लगाने के लिए

त्वरित प्रारंभ

मूल उपयोग```js

import SpamScanner from 'spamscanner';

const scanner = new SpamScanner();

// Raw email string or Buffer const email = ` From: [email protected] To: [email protected] Subject: Test Email

This is a test email. `;

const result = await scanner.scan(email);

console.log(result); // { // isSpam: false, // message: 'Ham', // results: { ... }, // ... // }

root@kitploit:~
### कॉन्फ़िगरेशन के साथ```js
import SpamScanner from 'spamscanner';

const scanner = new SpamScanner({
  // Enable performance metrics
  enablePerformanceMetrics: true,

  // Filter to supported languages
  supportedLanguages: ['en', 'es', 'fr', 'de'],

  // Enable macro detection
  enableMacroDetection: true,

  // Set scan timeout
  timeout: 30000,

  // Custom ClamAV configuration
  clamscan: {
    preference: 'clamdscan',
    clamdscanPath: '/usr/bin/clamdscan',
  },
});

const result = await scanner.scan(email);

विशिष्ट सुविधाओं की जाँच```js

// Check if email is spam if (result.isSpam) { console.log('Spam detected!'); console.log('Reason:', result.message); }

// Check for viruses if (result.results.viruses && result.results.viruses.length > 0) { console.log('Viruses found:', result.results.viruses); }

// Check for phishing if (result.results.phishing && result.results.phishing.length > 0) { console.log('Phishing detected:', result.results.phishing); }

// Check for executables if (result.results.executables && result.results.executables.length > 0) { console.log('Executables found:', result.results.executables); }

// Check for NSFW content if (result.results.nsfw && result.results.nsfw.length > 0) { console.log('NSFW content detected:', result.results.nsfw); }

// Check for toxic language if (result.results.toxicity && result.results.toxicity.length > 0) { console.log('Toxic language detected:', result.results.toxicity); }

root@kitploit:~
---


## API दस्तावेज़ीकरण

### कंस्ट्रक्टर विकल्प

#### `new SpamScanner(options)`

एक नया स्पैम स्कैनर उदाहरण बनाता है।

##### विकल्प

| विकल्प                             | प्रकार         | डिफ़ॉल्ट   | विवरण                                                                   |
| ---------------------------------- | -------------- | --------- | ----------------------------------------------------------------------------- |
| `enableMacroDetection`             | `boolean`      | `true`    | ईमेल और अटैचमेंट में मैक्रो पहचान सक्षम करें                              |
| `enablePerformanceMetrics`         | `boolean`      | `false`   | प्रदर्शन मेट्रिक्स को ट्रैक और वापस करें                                          |
| `timeout`                          | `number`       | `30000`   | स्कैन (वायरस, URL जांच) के लिए मिलीसेकंड में टाइमआउट                         |
| `supportedLanguages`               | `string[]`     | `['en']`  | समर्थित भाषा कोड की सरणी। खाली सरणी `[]` = सभी भाषाएँ समर्थित हैं |
| `enableMixedLanguageDetection`     | `boolean`      | `false`   | ईमेल में मिश्रित भाषाओं का पता लगाना सक्षम करें                                 |
| `enableAdvancedPatternRecognition` | `boolean`      | `true`    | उन्नत पैटर्न पहचान सक्षम करें (क्रेडिट कार्ड, फ़ोन, आदि)              |
| `toxicityThreshold`                | `number`       | `0.7`     | विषाक्तता पहचान के लिए थ्रेसहोल्ड (0.0-1.0, अधिक = कठोर)              |
| `nsfwThreshold`                    | `number`       | `0.6`     | NSFW पहचान के लिए थ्रेसहोल्ड (0.0-1.0, अधिक = कठोर)                  |
| `debug`                            | `boolean`      | `false`   | डीबग लॉगिंग सक्षम करें                                                          |
| `logger`                           | `object`       | `console` | कस्टम लॉगर ऑब्जेक्ट (`log`, `error`, `warn` विधियाँ होनी चाहिए)               |
| `clamscan`                         | `object`       | नीचे देखें | ClamAV कॉन्फ़िगरेशन विकल्प                                                  |
| `classifier`                       | `object`       | `null`    | कस्टम नाइव बेज़ क्लासिफ़ायर डेटा                                            |
| `replacements`                     | `Map\|object`  | `null`    | प्रीप्रोसेसिंग के लिए कस्टम टेक्स्ट रिप्लेसमेंट                             |

##### ClamAV विकल्प (`clamscan`)

| विकल्प               | प्रकार           | डिफ़ॉल्ट                | विवरण                                      |
| -------------------- | -------------- | ---------------------- | ------------------------------------------------ |
| `removeInfected`     | `boolean`      | `false`                | संक्रमित फ़ाइलें हटाएं                            |
| `quarantineInfected` | `boolean`      | `false`                | संक्रमित फ़ाइलों को क्वारंटाइन करें                        |
| `scanLog`            | `string\|null` | `null`                 | स्कैन लॉग फ़ाइल का पथ                            |
| `debugMode`          | `boolean`      | `false`                | ClamAV डीबग मोड सक्षम करें                         |
| `fileList`           | `string\|null` | `null`                 | फ़ाइल सूची का पथ                                |
| `scanRecursively`    | `boolean`      | `true`                 | निर्देशिकाओं को पुनरावर्ती रूप से स्कैन करें                     |
| `clamscanPath`       | `string`       | `'/usr/bin/clamscan'`  | clamscan बाइनरी का पथ                          |
| `clamdscanPath`      | `string`       | `'/usr/bin/clamdscan'` | clamdscan बाइनरी का पथ                         |
| `preference`         | `string`       | `'clamdscan'`          | पसंदीदा स्कैनर: `'clamdscan'` या `'clamscan'` |

##### उदाहरण

```javascript
const scanner = new SpamScanner({
  enableMacroDetection: true,
  enablePerformanceMetrics: true,
  timeout: 60000,
  supportedLanguages: ['en', 'es', 'fr'],
  enableMixedLanguageDetection: true,
  enableAdvancedPatternRecognition: true,
  toxicityThreshold: 0.8,
  nsfwThreshold: 0.5,
  debug: true,
  clamscan: {
    removeInfected: true,
    scanRecursively: true,
    preference: 'clamdscan'
  }
});
``````js
const scanner = new SpamScanner({
  enableMacroDetection: true,
  enablePerformanceMetrics: true,
  timeout: 60000,
  supportedLanguages: ['en', 'es', 'fr', 'de', 'ja', 'zh'],
  enableMixedLanguageDetection: false,
  enableAdvancedPatternRecognition: true,
  debug: false,
  logger: console,
  clamscan: {
    preference: 'clamdscan',
    clamdscanPath: '/usr/bin/clamdscan',
    scanRecursively: true,
    debugMode: false,
  },
});

विधियाँ

scanner.scan(source)

ईमेल को स्पैम, वायरस, फ़िशिंग और अन्य खतरों के लिए स्कैन करता है।

पैरामीटर
  • source (string | Buffer) - रॉ ईमेल सामग्री (RFC 822 प्रारूप)
रिटर्न

Promise<object> - स्कैन परिणाम ऑब्जेक्ट (देखें परिणाम ऑब्जेक्ट)

उदाहरण```js

const result = await scanner.scan(emailString);

root@kitploit:~
##### एज केस

* **खाली ईमेल**: खाली परिणामों के साथ `isSpam: false` लौटाता है
* **अमान्य ईमेल प्रारूप**: पार्स करने का प्रयास करता है, आंशिक परिणाम लौटा सकता है
* **समय समाप्ति**: यदि स्कैन `timeout` विकल्प से अधिक हो जाता है तो आंशिक परिणाम लौटाता है
* **ClamAV अनुपलब्ध**: वायरस स्कैनिंग छोड़ देता है, अन्य जाँचों के साथ जारी रखता है
* **TensorFlow मॉडल लोडिंग**: पहले स्कैन में 30+ सेकंड लग सकते हैं, बाद के स्कैन तेज़ होते हैं (मॉडल कैश्ड)

---

#### `scanner.getTokensAndMailFromSource(source)`

ईमेल को पार्स करता है और वर्गीकरण के लिए टोकन निकालता है।

##### पैरामीटर

* `source` (`string` | `Buffer`) - रॉ ईमेल सामग्री

##### रिटर्न

`Promise<object>` - `tokens` (सरणी) और `mail` (पार्स किया गया ईमेल ऑब्जेक्ट) वाला ऑब्जेक्ट

##### उदाहरण```js
const {tokens, mail} = await scanner.getTokensAndMailFromSource(emailString);
console.log('Tokens:', tokens);
console.log('Subject:', mail.subject);

scanner.getClassification(tokens)

Naive Bayes वर्गीकरणकर्ता का उपयोग करके टोकन को स्पैम या हैम के रूप में वर्गीकृत करता है।

पैरामीटर
  • tokens (string[]) - ईमेल से टोकन की सरणी
वापसी मान
  • Promise<object> - category और probability के साथ वर्गीकरण परिणाम
उदाहरण```js

const classification = await scanner.getClassification(tokens); console.log('Category:', classification.category); // 'spam' or 'ham' console.log('Probability:', classification.probability); // 0.0 - 1.0

root@kitploit:~
---

#### `scanner.getPhishingResults(mail)`

ईमेल में फ़िशिंग प्रयासों का पता लगाता है।

##### पैरामीटर

* `mail` (`object`) - `mailparser` से पार्स किया गया ईमेल ऑब्जेक्ट

##### रिटर्न

`Promise<array>` - फ़िशिंग पहचान परिणामों की सरणी

##### उदाहरण```js
const phishing = await scanner.getPhishingResults(mail);
// [
//   {
//     type: 'idn_homograph',
//     domain: 'аpple.com',
//     message: 'IDN homograph attack detected'
//   }
// ]

scanner.getExecutableResults(mail)

ईमेल अटैचमेंट में निष्पादन योग्य फ़ाइलों का पता लगाता है।

पैरामीटर
  • mail (object) - mailparser से पार्स किया गया ईमेल ऑब्जेक्ट
वापसी मान

Promise<array> - निष्पादन योग्य पता लगाने के परिणामों की एक सरणी

उदाहरण
root@kitploit:~
const executables = await scanner.getExecutableResults(mail);
// [
//   {
//     filename: 'malware.exe',
//     type: 'executable',
//     extension: 'exe',
//     risk: 'high'
//   }
// ]
```
---

#### `scanner.getVirusResults(mail)`

ClamAV का उपयोग करके ईमेल अटैचमेंट्स में वायरस के लिए स्कैन करता है।

##### पैरामीटर

* `mail` (`object`) - `mailparser` से पार्स किया गया ईमेल ऑब्जेक्ट

##### रिटर्न

`Promise<array>` - वायरस डिटेक्शन परिणामों की सरणी

##### उदाहरण```js
const viruses = await scanner.getVirusResults(mail);
// [
//   {
//     filename: 'infected.pdf',
//     virus: ['Trojan.PDF.Generic'],
//     type: 'virus'
//   }
// ]
```
---

#### `scanner.getMacroResults(mail)`

ईमेल सामग्री और अनुलग्नकों में मैक्रो का पता लगाता है।

##### पैरामीटर

* `mail` (`object`) - `mailparser` से पार्स किया गया ईमेल ऑब्जेक्ट

##### रिटर्न

`Promise<array>` - मैक्रो पहचान परिणामों की सरणी

##### उदाहरण```js
const macros = await scanner.getMacroResults(mail);
// [
//   {
//     type: 'vba_macro',
//     message: 'VBA macro detected in email content'
//   }
// ]
```
---

#### `scanner.getNSFWResults(mail)`

TensorFlow\.js का उपयोग करके छवि अनुलग्नकों में NSFW सामग्री का पता लगाता है।

##### पैरामीटर

* `mail` (`object`) - `mailparser` से पार्स किया गया ईमेल ऑब्जेक्ट

##### रिटर्न

`Promise<array>` - NSFW पहचान परिणामों की सरणी

##### उदाहरण```js
const nsfw = await scanner.getNSFWResults(mail);
// [
//   {
//     type: 'nsfw',
//     filename: 'image.jpg',
//     category: 'Porn',
//     probability: 0.85,
//     description: 'NSFW image detected: Porn (85.0%)'
//   }
// ]
```
---

#### `scanner.getToxicityResults(mail)`

TensorFlow\.js का उपयोग करके ईमेल सामग्री में विषाक्त भाषा का पता लगाता है।

##### पैरामीटर

* `mail` (`object`) - `mailparser` से पार्स किया गया ईमेल ऑब्जेक्ट

##### वापसी

`Promise<array>` - विषाक्तता पहचान परिणामों की सरणी

##### उदाहरण```js
const toxicity = await scanner.getToxicityResults(mail);
// [
//   {
//     type: 'toxicity',
//     category: 'threat',
//     probability: 0.92,
//     description: 'Toxic content detected: threat (92.0%)'
//   },
//   {
//     type: 'toxicity',
//     category: 'insult',
//     probability: 0.78,
//     description: 'Toxic content detected: insult (78.0%)'
//   }
// ]
```
---

#### `scanner.getTokens(str, locale, isHTML)`

वर्गीकरण के लिए पाठ को टोकन में विभाजित करता है।

##### पैरामीटर

* `str` (`string`) - टोकन करने के लिए पाठ
* `locale` (`string`) - भाषा कोड (जैसे, "en", "es", "fr")
* `isHTML` (`boolean`) - क्या पाठ में HTML है (डिफ़ॉल्ट: `false`)

##### वापसी मान

`Promise<string[]>` - टोकनों की सरणी

##### उदाहरण```js
const tokens = await scanner.getTokens('Hello world', 'en', false);
// ['hello', 'world']
```
---

#### `scanner.parseLocale(locale)`

भाषा कोड को मानक प्रारूप में सामान्यीकृत करता है।

##### पैरामीटर

* `locale` (`string`) - भाषा कोड या लोकेल स्ट्रिंग

##### वापसी मान

`string` - सामान्यीकृत भाषा कोड

##### उदाहरण```js
const normalized = scanner.parseLocale('en-US');
// 'en'
```
---

#### `scanner.detectLanguageHybrid(text)`

हाइब्रिड फ्रैंक/लांडे दृष्टिकोण का उपयोग करके भाषा का पता लगाता है।

##### पैरामीटर

* `text` (`string`) - विश्लेषण करने के लिए पाठ

##### रिटर्न

`Promise<string>` - पता लगाई गई भाषा कोड

##### उदाहरण

```javascript
// Example code remains unchanged
``````js
const language = await scanner.detectLanguageHybrid('Bonjour le monde');
// 'fr'
```
---

#### `scanner.extractAllUrls(mail, originalSource)`

ईमेल से सभी URL निकालता है।

##### पैरामीटर

* `mail` (`object`) - पार्स किया गया ईमेल ऑब्जेक्ट
* `originalSource` (`string`) - मूल ईमेल स्रोत

##### वापसी मान

`string[]` - URL की सरणी

##### उदाहरण```js
const urls = scanner.extractAllUrls(mail, emailString);
// ['https://example.com', 'http://test.com']
```
---

#### `scanner.parseUrlWithTldts(url)`

सटीक TLD निष्कर्षण के लिए tldts का उपयोग करके URL को पार्स करता है।

##### पैरामीटर

* `url` (`string`) - पार्स करने के लिए URL

##### वापसी मान

`object` - पार्स किए गए URL के घटक

##### उदाहरण

```javascript

``````js
const parsed = scanner.parseUrlWithTldts('https://subdomain.example.co.uk/path');
// {
//   domain: 'example.co.uk',
//   subdomain: 'subdomain',
//   hostname: 'subdomain.example.co.uk',
//   publicSuffix: 'co.uk',
//   isIp: false
// }
```
---

### परिणाम ऑब्जेक्ट

`scan()` विधि एक व्यापक परिणाम ऑब्जेक्ट लौटाती है:```js
{
  // Overall spam classification
  isSpam: boolean,
  message: string, // 'Ham' or 'Spam: <reasons>'

  // Detection results
  results: {
    // Classification details
    classification: {
      category: 'spam' | 'ham',
      probability: number
    },

    // Phishing detection
    phishing: [
      {
        type: 'idn_homograph' | 'suspicious_link' | 'confusables',
        domain: string,
        message: string
      }
    ],

    // Executable detection
    executables: [
      {
        filename: string,
        type: 'executable' | 'office_document' | 'legacy_office' | 'pdf_javascript' | 'archive',
        extension: string,
        risk: 'high' | 'medium' | 'low'
      }
    ],

    // Macro detection
    macros: [
      {
        type: 'vba_macro' | 'powershell' | 'javascript' | 'batch',
        message: string
      }
    ],

    // Arbitrary results (custom detections)
    arbitrary: [],

    // Virus scanning
    viruses: [
      {
        filename: string,
        virus: string[],
        type: 'virus'
      }
    ],

    // Pattern recognition
    patterns: {
      credit_cards: number,
      phone_numbers: number,
      emails: number,
      ips: number,
      urls: number,
      bitcoin: number,
      dates: number,
      file_paths: number
    },

    // IDN homograph attack detection
    idnHomographAttack: [],

    // Toxicity detection (array of results)
    toxicity: [
      {
        type: 'toxicity',
        category: 'identity_attack' | 'insult' | 'obscene' | 'severe_toxicity' | 'sexual_explicit' | 'threat',
        probability: number,
        description: string
      }
    ],

    // NSFW detection (array of results)
    nsfw: [
      {
        type: 'nsfw',
        filename: string,
        category: 'Porn' | 'Hentai' | 'Sexy' | 'Neutral' | 'Drawing',
        probability: number,
        description: string
      }
    ]
  },

  // All URLs extracted from email
  links: string[],

  // Tokens extracted from email
  tokens: string[],

  // Email metadata
  mail: {
    from: object,
    to: object[],
    subject: string,
    text: string,
    html: string,
    attachments: object[],
    headers: object
  },

  // Performance metrics (if enabled)
  metrics: {
    totalTime: number, // milliseconds
    classificationTime: number,
    phishingTime: number,
    executableTime: number,
    macroTime: number,
    virusTime: number,
    patternTime: number,
    idnTime: number,
    memoryUsage: object
  }
}
```
---

## उन्नत उपयोग

### कस्टम वर्गीकारक```js
import SpamScanner from 'spamscanner';
import NaiveBayes from '@ladjs/naivebayes';

// Train custom classifier
const classifier = new NaiveBayes();
classifier.learn('buy viagra now', 'spam');
classifier.learn('hello friend', 'ham');

const scanner = new SpamScanner({
  classifier: classifier.toJson()
});
```
### कस्टम टेक्स्ट प्रतिस्थापन```js
const scanner = new SpamScanner({
  replacements: new Map([
    ['u', 'you'],
    ['ur', 'your'],
    ['r', 'are'],
    ['b4', 'before']
  ])
});
```
### भाषा फ़िल्टरिंग```js
// Only accept English, Spanish, and French emails
const scanner = new SpamScanner({
  supportedLanguages: ['en', 'es', 'fr']
});

// Accept all languages
const scanner2 = new SpamScanner({
  supportedLanguages: []
});
```
### प्रदर्शन निगरानी```js
const scanner = new SpamScanner({
  enablePerformanceMetrics: true
});

const result = await scanner.scan(email);

console.log('Total scan time:', result.metrics.totalTime, 'ms');
console.log('Classification time:', result.metrics.classificationTime, 'ms');
console.log('Virus scan time:', result.metrics.virusScanTime, 'ms');
```
### चयनात्मक सुविधा अक्षम करना```js
// Disable macro detection for performance
const scanner = new SpamScanner({
  enableMacroDetection: false
});

// Disable advanced pattern recognition
const scanner2 = new SpamScanner({
  enableAdvancedPatternRecognition: false
});
```
### कस्टम टाइमआउट```js
// Set 60-second timeout for slow scans
const scanner = new SpamScanner({
  timeout: 60000
});
```
### कस्टम लॉगर```js
import winston from 'winston';

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'spam-scanner.log' })
  ]
});

const scanner = new SpamScanner({
  debug: true,
  logger: logger
});
```
---

## ARF (Abuse Reporting Format)

SpamScanner में ISP और ईमेल प्रदाताओं से ईमेल फीडबैक रिपोर्ट प्रबंधित करने के लिए एक मूल [ARF (Abuse Reporting Format)](https://www.rfc-editor.org/rfc/rfc5965.html) पार्सर शामिल है।

### ARF रिपोर्ट्स का पार्सिंग```js
import {ArfParser} from 'spamscanner/arf';
import fs from 'node:fs';

// Read an ARF report email
const arfEmail = fs.readFileSync('feedback_report.eml');

// Parse the ARF report
const report = await ArfParser.parse(arfEmail);

console.log('Feedback Type:', report.feedbackType);
console.log('Source IP:', report.sourceIp);
console.log('Original Sender:', report.originalMailFrom);
console.log('Original Recipients:', report.originalRcptTo);
```
#### सुरक्षित पार्सिंग```js
// Use tryParse for safe parsing (returns null if not ARF)
const report = await ArfParser.tryParse(emailContent);

if (report) {
  console.log('ARF report detected:', report.feedbackType);
} else {
  console.log('Not an ARF report');
}
```
### ARF रिपोर्ट्स बनाना```js
import {ArfParser} from 'spamscanner/arf';

const arfMessage = ArfParser.create({
  feedbackType: 'abuse',
  userAgent: 'MyMailServer/1.0',
  from: '[email protected]',
  to: '[email protected]',
  originalMessage: originalEmailContent,
  humanReadable: 'This email was reported as spam by our users.',
  sourceIp: '192.168.1.100',
  originalMailFrom: '[email protected]',
  originalRcptTo: ['[email protected]'],
  arrivalDate: new Date(),
  reportingMta: 'mail.yourdomain.com',
});

// Send arfMessage to the abuse address
```
### ARF परिणाम ऑब्जेक्ट

| गुण | प्रकार | विवरण |
| ------------------ | ---------- | ----------------------------------------------------------------------------- |
| `isArf` | `boolean` | क्या यह एक मान्य ARF संदेश है |
| `feedbackType` | `string` | प्रकार: `abuse`, `fraud`, `virus`, `other`, `not-spam`, `auth-failure`, `dmarc` |
| `userAgent` | `string` | उपयोगकर्ता एजेंट जिसने रिपोर्ट उत्पन्न की |
| `version` | `string` | ARF संस्करण (सामान्यतः "1") |
| `sourceIp` | `string` | मूल संदेश का स्रोत IP |
| `originalMailFrom` | `string` | मूल MAIL FROM पता |
| `originalRcptTo` | `string[]` | मूल RCPT TO पते |
| `arrivalDate` | `Date` | जब मूल संदेश आया |
| `reportingMta` | `object` | रिपोर्टिंग MTA जानकारी (`{type, name}`) |
| `incidents` | `number` | रिपोर्ट की गई घटनाओं की संख्या |
| `humanReadable` | `string` | मानव-पठनीय विवरण |
| `originalMessage` | `string` | मूल रिपोर्ट किया गया संदेश |
| `originalHeaders` | `object` | मूल संदेश से पार्स किए गए हेडर |

---


## मेल सर्वर एकीकरण

SpamScanner को [Postfix](https://www.postfix.org/) और [Dovecot](https://www.dovecot.org/) जैसे लोकप्रिय मेल सर्वरों के साथ सामग्री फ़िल्टर के रूप में एकीकृत किया जा सकता है।

### Postfix एकीकरण

#### पाइप सामग्री फ़िल्टर का उपयोग करना

यह अधिकांश Postfix सेटअप के लिए अनुशंसित विधि है।

1. **एक समर्पित उपयोगकर्ता बनाएं** (सुरक्षा के लिए अनुशंसित):```bash
sudo useradd -r -s /bin/false spamscanner
```
2. **`/etc/postfix/master.cf` को संपादित करें**:```cf
# SpamScanner content filter
spamscanner unix - n n - - pipe
  flags=Rq user=spamscanner argv=/usr/local/bin/spamscanner scan -
```
3. **`/etc/postfix/main.cf` संपादित करें**:```cf
content_filter = spamscanner:dummy
```
4. **Postfix को पुनः लोड करें**:```bash
sudo postfix reload
```
पोस्टफिक्स अब सभी आने वाले ईमेल को SpamScanner पर भेजेगा। यदि SpamScanner कोड 1 (स्पैम) के साथ बाहर निकलता है, तो पोस्टफिक्स संदेश को अस्वीकार कर देगा।

### डवकॉट एकीकरण

#### सीव और पाइप का उपयोग करना

1. **पिजनहोल सीव सक्षम करें** (सुनिश्चित करें कि `dovecot-pigeonhole` स्थापित है)

2. **एक सीव स्क्रिप्ट बनाएँ** (`/var/lib/dovecot/sieve/default.sieve`):```sieve
require ["vnd.dovecot.pipe"];

# Scan all incoming mail
if header :contains "X-Spam-Flag" "NO" {
  pipe "/usr/local/bin/spamscanner-sieve-helper";
}
```
3. **एक सहायक स्क्रिप्ट बनाएँ** (`/usr/local/bin/spamscanner-sieve-helper`):```bash
#!/bin/bash
EMAIL=$(cat)
RESULT=$(echo "$EMAIL" | /usr/local/bin/spamscanner scan -)
if [[ $? -eq 1 ]]; then
  echo "X-Spam-Flag: YES" | cat - <(echo "$EMAIL")
else
  echo "$EMAIL"
fi
```
### TCP Server Mode

उच्च-मात्रा वातावरण के लिए, SpamScanner को एक स्थायी TCP सर्वर के रूप में चलाएँ:```bash
# Start the server
spamscanner server --port 7830 --host 127.0.0.1
```
#### Systemd Service

`/etc/systemd/system/spamscanner.service` बनाएं:```ini
[Unit]
Description=SpamScanner TCP Server
After=network.target

[Service]
Type=simple
User=spamscanner
ExecStart=/usr/local/bin/spamscanner server --port 7830
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
```
सक्षम करें और प्रारंभ करें:```bash
sudo systemctl enable spamscanner
sudo systemctl start spamscanner
```
#### क्लाइंट उदाहरण```bash
# Send email to TCP server and get JSON response
cat email.eml | nc localhost 7830
```
---


## प्रदर्शन

### बेंचमार्क

| स्कैन प्रकार                   | पहला स्कैन   | बाद के स्कैन | नोट्स                    |
| --------------------------- | ------------ | ---------------- | ------------------------ |
| **छोटा ईमेल** (< 10KB)    | 2-3s         | 200-500ms        | कोई अटैचमेंट नहीं           |
| **मध्यम ईमेल** (10-100KB) | 3-5s         | 500ms-1s         | 1-2 अटैचमेंट          |
| **बड़ा ईमेल** (100KB-1MB) | 5-10s        | 1-3s             | एकाधिक अटैचमेंट     |
| **NSFW पहचान के साथ**     | +30s (पहला) | +100-200ms       | TensorFlow मॉडल लोड हो रहा है |
| **विषाक्तता पहचान के साथ** | +30s (पहला) | +100-200ms       | TensorFlow मॉडल लोड हो रहा है |

> \[!NOTE]
> TensorFlow मॉडल (NSFW/toxicity) के साथ पहले स्कैन में मॉडल लोडिंग के कारण 30+ सेकंड लगते हैं। बाद के स्कैन तेज़ होते हैं क्योंकि मॉडल मेमोरी में कैश हो जाते हैं।

### अनुकूलन युक्तियाँ

1. **मॉडल कैशिंग**: TensorFlow मॉडल को कैश करने के लिए स्कैनर इंस्टेंस को चालू रखें
2. **अप्रयुक्त सुविधाएँ अक्षम करें**: यदि आवश्यक न हो तो मैक्रो डिटेक्शन या पैटर्न पहचान बंद करें
3. **टाइमआउट समायोजित करें**: कई अटैचमेंट वाले बड़े ईमेल के लिए टाइमआउट बढ़ाएँ
4. **clamdscan का उपयोग करें**: तेज़ वायरस स्कैनिंग के लिए `clamdscan` को `clamscan` पर प्राथमिकता दें
5. **भाषाएँ सीमित करें**: अनावश्यक भाषा पहचान को छोड़ने के लिए `supportedLanguages` निर्दिष्ट करें

### मेमोरी उपयोग

* **आधार**: 50-100MB
* **TensorFlow मॉडल के साथ**: 500MB-1GB
* **प्रति स्कैन**: 10-50MB (अस्थायी)

---


## योगदान

हम योगदान का स्वागत करते हैं! कृपया विवरण के लिए हमारा [योगदान गाइड](https://github.com/spamscanner/spamscanner/blob/HEAD/CONTRIBUTING.md) देखें।

### विकास सेटअप```bash
# Clone repository
git clone https://github.com/spamscanner/spamscanner.git
cd spamscanner

# Install dependencies
pnpm install

# Run tests
npm test

# Run tests with coverage
npm run test-coverage

# Build
pnpm run build
```
### परीक्षण चलाना```bash
# All tests
npm test

# Specific test file
node --test test/test.js

# With coverage
npm run test-coverage
```
---


## लाइसेंस

[Business Source License 1.1](https://github.com/spamscanner/spamscanner/blob/HEAD/LICENSE) © [Forward Email](https://forwardemail.net)


## सहायता

* **दस्तावेज़ीकरण**: <https://spamscanner.net>
* **समस्याएं**: [GitHub Issues](https://github.com/spamscanner/spamscanner/issues)
* **ईमेल**: <mailto:[email protected]>

---


## स्वीकृतियां

* [Forward Email](https://forwardemail.net) - उत्पादन उपयोग और परीक्षण
* [TensorFlow.js](https://www.tensorflow.org/js) - NSFW और विषाक्तता पहचान
* [ClamAV](https://www.clamav.net/) - वायरस स्कैनिंग
* [Natural](https://github.com/NaturalNode/natural) - NLP और टोकनाइज़ेशन
* [tldts](https://github.com/remusao/tldts) - TLD पार्सिंग
* [confusables](https://github.com/gc/confusables) - यूनिकोड भ्रमित करने वाले का पता लगाना

---

> ❤️ के साथ [Forward Email](https://forwardemail.net) टीम द्वारा बनाया गया


##

<a href="#"><img src="https://assets.kitploit.com/production/public/readmes/4904/e6398bce5b0e513bf1a4158badcdf2272601446c988cff3fb07c3bf740012814.png" alt="#" /></a>
टूल डाउनलोड करें
परिणाम ऑब्जेक्ट
  • उन्नत उपयोग
    • कस्टम वर्गीकारक
    • कस्टम टेक्स्ट प्रतिस्थापन
    • भाषा फ़िल्टरिंग
    • प्रदर्शन निगरानी
    • चयनात्मक सुविधा अक्षम करना
    • कस्टम टाइमआउट
    • कस्टम लॉगर
  • ARF (अब्यूज़ रिपोर्टिंग फ़ॉर्मेट)
    • ARF रिपोर्ट पार्स करना
    • ARF रिपोर्ट बनाना
    • ARF परिणाम ऑब्जेक्ट
  • मेल सर्वर एकीकरण
    • Postfix एकीकरण
    • Dovecot एकीकरण
    • TCP सर्वर मोड
  • प्रदर्शन
    • बेंचमार्क
    • अनुकूलन युक्तियाँ
    • मेमोरी उपयोग
  • योगदान
    • विकास सेटअप
    • परीक्षण चलाना
  • लाइसेंस
  • समर्थन
  • आभार