valid_email_checker 0.1.0

data/ext/valid_email_checker/vendor/check-if-email-exists/README.md

@@ -0,0 +1,175 @@
+[![Crate](https://img.shields.io/crates/v/check-if-email-exists.svg)](https://crates.io/crates/check-if-email-exists)
+[![Docs](https://docs.rs/check-if-email-exists/badge.svg)](https://docs.rs/check-if-email-exists)
+[![Docker](https://img.shields.io/docker/v/reacherhq/backend?color=0db7ed&label=docker&sort=date)](https://hub.docker.com/r/reacherhq/backend)
+[![Actions Status](https://github.com/reacherhq/check-if-email-exists/workflows/pr/badge.svg)](https://github.com/reacherhq/check-if-email-exists/actions)
+
+<br /><br />
+
+<p align="center"><img align="center" src="https://storage.googleapis.com/saasify-uploads-prod/696e287ad79f0e0352bc201b36d701849f7d55e7.svg" height="96" alt="reacher" /></p>
+<h1 align="center">check-if-email-exists</h1>
+<h4 align="center">Check if an email address exists without sending any email.<br/>Comes with a <a href="./backend">⚙️ HTTP backend</a>.</h4>
+
+<br /><br /><br />
+
+## 👉 Live Demo: https://reacher.email
+
+<img src="https://storage.googleapis.com/saasify-uploads-prod/696e287ad79f0e0352bc201b36d701849f7d55e7.svg" height="68" align="left" />
+
+This is open-source, but I also offer a **SaaS** solution that has `check-if-email-exists` packaged in a nice friendly web interface. If you are interested, find out more at [No2Bounce.com](https://no2bounce.com/?ref=github). If you have any questions, you can contact me at amaury@reacher.email.
+
+<br />
+
+## Get Started
+
+3 non-SaaS ways to get started with `check-if-email-exists`.
+
+### 1. ⚙️ HTTP backend using Docker (popular method 🥇) [[Full docs](./backend/README.md)]
+
+This option allows you to run a HTTP backend using Docker 🐳, on a cloud instance or your own server. Please note that outbound port 25 must be open.
+
+```bash
+docker run -p 8080:8080 reacherhq/backend:latest
+```
+
+Then send a `POST http://localhost:8080/v0/check_email` request with the following body:
+
+```js
+{
+    "to_email": "someone@gmail.com",
+    "proxy": {                        // (optional) SOCK5 proxy to run the verification through, default is empty
+        "host": "my-proxy.io",
+        "port": 1080,
+        "username": "me",             // (optional) Proxy username
+        "password": "pass"            // (optional) Proxy password
+    }
+}
+```
+**Note regarding proxy servers**
+It is possible to operate Reacher with your own IP addresses. But if you wish to process more than very small volumes you will need SMTP proxy servers. For SMTP proxy servers please use [proxy25.com](https://proxy25.com/?ref=github)
+
+### 2. Download the CLI [[Full docs](./cli/README.md)]
+
+> Note: The CLI binary doesn't connect to any backend, it checks the email directly from your computer.
+
+Head to the [releases page](https://github.com/reacherhq/check-if-email-exists/releases) and download the binary for your platform.
+
+```bash
+> $ check_if_email_exists --help
+check_if_email_exists 0.9.1
+Check if an email address exists without sending an email.
+
+USAGE:
+    check_if_email_exists [FLAGS] [OPTIONS] [TO_EMAIL]
+```
+
+Check out the [dedicated README.md](./cli/README.md) for all options and flags.
+
+### 3. Programmatic Usage [[Full docs](https://docs.rs/check-if-email-exists)]
+
+In your own Rust project, you can add `check-if-email-exists` in your `Cargo.toml`:
+
+```toml
+[dependencies]
+check-if-email-exists = "0.9"
+```
+
+And use it in your code as follows:
+
+```rust
+use check_if_email_exists::{check_email, CheckEmailInput, CheckEmailInputProxy};
+
+async fn check() {
+    // Let's say we want to test the deliverability of someone@gmail.com.
+    let mut input = CheckEmailInput::new(vec!["someone@gmail.com".into()]);
+
+    // Verify this email, using async/await syntax.
+    let result = check_email(&input).await;
+
+    // `result` is a `Vec<CheckEmailOutput>`, where the CheckEmailOutput
+    // struct contains all information about our email.
+    println!("{:?}", result);
+}
+```
+
+The reference docs are hosted on [docs.rs](https://docs.rs/check-if-email-exists).
+
+## ✈️ JSON Output
+
+The output will be a JSON with the below format, the fields should be self-explanatory. For `someone@gmail.com` (note that it is disabled by Gmail), here's the exact output:
+
+```json
+{
+	"input": "someone@gmail.com",
+	"is_reachable": "invalid",
+	"misc": {
+		"is_disposable": false,
+		"is_role_account": false,
+		"is_b2c": true
+	},
+	"mx": {
+		"accepts_mail": true,
+		"records": [
+			"alt3.gmail-smtp-in.l.google.com.",
+			"gmail-smtp-in.l.google.com.",
+			"alt1.gmail-smtp-in.l.google.com.",
+			"alt4.gmail-smtp-in.l.google.com.",
+			"alt2.gmail-smtp-in.l.google.com."
+		]
+	},
+	"smtp": {
+		"can_connect_smtp": true,
+		"has_full_inbox": false,
+		"is_catch_all": false,
+		"is_deliverable": false,
+		"is_disabled": true
+	},
+	"syntax": {
+		"domain": "gmail.com",
+		"is_valid_syntax": true,
+		"username": "someone",
+		"suggestion": null
+	}
+}
+```
+
+## What Does This Tool Check?
+
+| Included? | Feature                                       | Description                                                                                                                     | JSON field                                                                |
+| --------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| ✅        | **Email reachability**                        | How confident are we in sending an email to this address? Can be one of `safe`, `risky`, `invalid` or `unknown`.                | `is_reachable`                                                            |
+| ✅        | **Syntax validation**                         | Is the address syntactically valid?                                                                                             | `syntax.is_valid_syntax`                                                  |
+| ✅        | **DNS records validation**                    | Does the domain of the email address have valid MX DNS records?                                                                 | `mx.accepts_mail`                                                         |
+| ✅        | **Disposable email address (DEA) validation** | Is the address provided by a known [disposable email address](https://en.wikipedia.org/wiki/Disposable_email_address) provider? | `misc.is_disposable`                                                      |
+| ✅        | **SMTP server validation**                    | Can the mail exchanger of the email address domain be contacted successfully?                                                   | `smtp.can_connect_smtp`                                                   |
+| ✅        | **Email deliverability**                      | Is an email sent to this address deliverable?                                                                                   | `smtp.is_deliverable`                                                     |
+| ✅        | **Mailbox disabled**                          | Has this email address been disabled by the email provider?                                                                     | `smtp.is_disabled`                                                        |
+| ✅        | **Full inbox**                                | Is the inbox of this mailbox full?                                                                                              | `smtp.has_full_inbox`                                                     |
+| ✅        | **Catch-all address**                         | Is this email address a [catch-all](https://debounce.io/blog/help/what-is-a-catch-all-or-accept-all/) address?                  | `smtp.is_catch_all`                                                       |
+| ✅        | **Role account validation**                   | Is the email address a well-known role account?                                                                                 | `misc.is_role_account`                                                    |
+| ✅        | **Gravatar Url**                              | The url of the [Gravatar](https://gravatar.com/) email address profile picture                                                  | `misc.gravatar_url`                                                       |
+| ✅        | **Have I Been Pwned?**                        | Has this email been compromised in a [data breach](https://haveibeenpwned.com/)?                                                | `misc.haveibeenpwned`                                                     |
+| 🔜        | **Free email provider check**                 | Is the email address bound to a known free email provider?                                                                      | [Issue #89](https://github.com/reacherhq/check-if-email-exists/issues/89) |
+| 🔜        | **Syntax validation, provider-specific**      | According to the syntactic rules of the target mail provider, is the address syntactically valid?                               | [Issue #90](https://github.com/reacherhq/check-if-email-exists/issues/90) |
+| 🔜        | **Honeypot detection**                        | Does email address under test hide a [honeypot](https://en.wikipedia.org/wiki/Spamtrap)?                                        | [Issue #91](https://github.com/reacherhq/check-if-email-exists/issues/91) |
+
+## 🤔 Why?
+
+Many online services (https://hunter.io, https://verify-email.org, https://email-checker.net) offer this service for a paid fee. Here is an open-source alternative to those tools.
+
+## License
+
+`check-if-email-exists`'s source code is provided under a **dual license model**.
+
+### Commercial license
+
+If you want to use `check-if-email-exists` to develop commercial sites, tools, and applications, the Commercial License is the appropriate license. With this option, your source code is kept proprietary. Purchase a `check-if-email-exists` Commercial License at https://reacher.email/pricing.
+
+### Open source license
+
+If you are creating an open-source application under a license compatible with the GNU Affero GPL License v3, you may use `check-if-email-exists` under the terms of the [AGPL-3.0](./LICENSE.AGPL).
+
+[➡️ Read more](https://docs.reacher.email/self-hosting/licensing) about Reacher's license.
+
+## 🔨 Build From Source
+
+Build the [CLI from source](./cli/README.md#build-from-source) or the [HTTP backend from source](./backend/README.md#build-from-source).

data/ext/valid_email_checker/vendor/check-if-email-exists/src/haveibeenpwned.rs

@@ -0,0 +1,70 @@
+// check-if-email-exists
+// Copyright (C) 2018-2023 Reacher
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::LOG_TARGET;
+use reqwest::Client;
+
+const MAIN_API_URL: &str = "https://haveibeenpwned.com/api/v3/";
+
+/// Check if the email has been found in any breach or paste using the
+/// HaveIBeenPwned API.
+/// This function will return the number of times the email has been found in
+/// any breach.
+pub async fn check_haveibeenpwned(to_email: &str, api_key: Option<String>) -> Option<bool> {
+	let client = Client::new();
+	let url = format!(
+		"{}breachedaccount/{}?truncateResponse=false",
+		MAIN_API_URL, to_email
+	);
+
+	let request = client
+		.get(&url)
+		.header("User-Agent", "reacher")
+		.header("hibp-api-key", api_key.unwrap_or_default())
+		.send()
+		.await;
+
+	match request {
+		Ok(response) => {
+			if response.status().is_success() {
+				let breaches: Vec<serde_json::Value> = response.json().await.unwrap_or_default();
+				tracing::debug!(
+					target: LOG_TARGET,
+					breach_count=breaches.len(),
+					"HaveIBeenPwned check completed"
+				);
+				Some(!breaches.is_empty())
+			} else if response.status() == reqwest::StatusCode::NOT_FOUND {
+				Some(false)
+			} else {
+				tracing::error!(
+					target: LOG_TARGET,
+					status = %response.status(),
+					"Error checking HaveIBeenPwned"
+				);
+				None
+			}
+		}
+		Err(e) => {
+			tracing::error!(
+				target: LOG_TARGET,
+				error=?e,
+				"Error checking HaveIBeenPwned"
+			);
+			None
+		}
+	}
+}

data/ext/valid_email_checker/vendor/check-if-email-exists/src/lib.rs

@@ -0,0 +1,281 @@
+// check-if-email-exists
+// Copyright (C) 2018-2023 Reacher
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+//! `check-if-email-exists` lets you check if an email address exists without
+//! sending any email.
+//!
+//! Under the hood, it connects to the email address's SMTP server, and,
+//! analyzing the server's responses against some SMTP commands, finds out
+//! information about the email address, such as:
+//! - Email deliverability: Is an email sent to this address deliverable?
+//! - Syntax validation. Is the address syntactically valid?
+//! - DNS records validation. Does the domain of the email address have valid
+//!   MX DNS records?
+//! - Disposable email address (DEA) validation. Is the address provided by a
+//!   known disposable email address provider?
+//! - SMTP server validation. Can the mail exchanger of the email address
+//!   domain be contacted successfully?
+//! - Mailbox disabled. Has this email address been disabled by the email
+//!   provider?
+//! - Full inbox. Is the inbox of this mailbox full?
+//! - Catch-all address. Is this email address a catch-all address?
+//!
+//! ```rust
+//! use check_if_email_exists::{check_email, CheckEmailInputBuilder, CheckEmailInputProxy};
+//! use check_if_email_exists::smtp::verif_method::{VerifMethod, VerifMethodSmtpConfig, GmailVerifMethod};
+//! use std::collections::HashMap;
+//!
+//! async fn check() {
+//!     // Let's say we want to test the deliverability of someone@gmail.com.
+//!
+//!     // We can tweak how we want to verify the email address, though using
+//!     // the default values is usually enough. However, if you want to use a
+//!     // proxy, you can do so like this:
+//!     let mut proxies = HashMap::new();
+//!     proxies.insert("proxy1".to_string(), CheckEmailInputProxy {
+//!         host: "my-proxy.io".to_string(),             // Use a SOCKS5 proxy to verify the email
+//!         port: 1080,
+//!         username: None,                              // You can also set it non-empty
+//!         password: None,
+//!         timeout_ms: None,
+//!     });
+//!     let verif_method = VerifMethod {
+//!         proxies,
+//!         gmail: GmailVerifMethod::Smtp(VerifMethodSmtpConfig {
+//!            from_email: "me@example.org".to_string(), // Used in the `MAIL FROM:` command
+//!            hello_name: "example.org".to_string(),    // Used in the `EHLO` command
+//!            smtp_port: 587,                           // Use port 587 instead of 25
+//!            proxy: Some("proxy1".to_string()),        // Use the proxy we defined above
+//!            ..Default::default()
+//!         }),
+//!         ..Default::default()
+//!     };
+//!
+//!     let input = CheckEmailInputBuilder::default()
+//!         .to_email("someone@gmail.com".into())
+//!         .verif_method(verif_method)
+//!         .build()
+//!         .unwrap();
+//!
+//!     // Verify this input, using async/await syntax.
+//!     let result = check_email(&input).await;
+//!
+//!     // `result` is a `Vec<CheckEmailOutput>`, where the CheckEmailOutput
+//!     // struct contains all information about one email.
+//!     println!("{:?}", result);
+//! }
+//! ```
+
+mod haveibeenpwned;
+pub mod misc;
+pub mod mx;
+mod rules;
+pub mod smtp;
+pub mod syntax;
+mod util;
+
+use misc::{check_misc, MiscDetails};
+use mx::check_mx;
+use rustls::crypto::ring;
+use smtp::{check_smtp, SmtpDetails, SmtpError};
+pub use smtp::{is_gmail, is_hotmail, is_hotmail_b2b, is_hotmail_b2c, is_yahoo};
+use std::sync::Once;
+use std::time::{Duration, SystemTime};
+use syntax::{check_syntax, get_similar_mail_provider};
+pub use util::input_output::*;
+#[cfg(feature = "sentry")]
+pub use util::sentry::*;
+
+/// The target where to log check-if-email-exists logs.
+pub const LOG_TARGET: &str = "reacher";
+
+static INIT: Once = Once::new();
+
+/// check-if-email-exists uses rustls for its TLS connections. This function
+/// initializes the default crypto provider for rustls.
+pub fn initialize_crypto_provider() {
+	INIT.call_once(|| {
+		ring::default_provider().install_default().unwrap();
+	});
+}
+
+/// Given an email's misc and smtp details, calculate an estimate of our
+/// confidence on how reachable the email is.
+///
+/// Maybe we can switch to a points-based system?
+/// ref: https://github.com/reacherhq/check-if-email-exists/issues/935
+fn calculate_reachable(misc: &MiscDetails, smtp: &Result<SmtpDetails, SmtpError>) -> Reachable {
+	if let Ok(smtp) = smtp {
+		if misc.is_disposable || misc.is_role_account || smtp.is_catch_all || smtp.has_full_inbox {
+			return Reachable::Risky;
+		}
+
+		if !smtp.is_deliverable || !smtp.can_connect_smtp || smtp.is_disabled {
+			return Reachable::Invalid;
+		}
+
+		Reachable::Safe
+	} else {
+		Reachable::Unknown
+	}
+}
+
+/// The main function of this library: verify a single email. Performs, in the
+/// following order, 4 types of verifications:
+/// - syntax check: verify the email is well-formed,
+/// - MX checks: verify the domain is configured to receive email,
+/// - SMTP checks: connect to the SMTP server and verify the email is
+///   deliverable,
+/// - misc checks: metadata about the email provider.
+///
+/// Returns a `CheckEmailOutput` output, whose `is_reachable` field is one of
+/// `Safe`, `Invalid`, `Risky` or `Unknown`.
+pub async fn check_email(input: &CheckEmailInput) -> CheckEmailOutput {
+	initialize_crypto_provider();
+	let start_time = SystemTime::now();
+	let to_email = &input.to_email;
+
+	tracing::debug!(
+		target: LOG_TARGET,
+		email=%to_email,
+		"Checking email"
+	);
+	let mut my_syntax = check_syntax(to_email.as_ref());
+	if !my_syntax.is_valid_syntax {
+		return CheckEmailOutput {
+			input: to_email.to_string(),
+			is_reachable: Reachable::Invalid,
+			syntax: my_syntax,
+			..Default::default()
+		};
+	}
+
+	tracing::debug!(
+		target: LOG_TARGET,
+		email=%to_email,
+		syntax=?my_syntax,
+		"Found syntax validation"
+	);
+
+	let my_mx = match check_mx(&my_syntax).await {
+		Ok(m) => m,
+		e => {
+			get_similar_mail_provider(&mut my_syntax);
+
+			// This happens when there's an internal error while checking MX
+			// records. Should happen fairly rarely.
+			return CheckEmailOutput {
+				input: to_email.to_string(),
+				is_reachable: Reachable::Unknown,
+				mx: e,
+				syntax: my_syntax,
+				..Default::default()
+			};
+		}
+	};
+
+	// Return if we didn't find any MX records.
+	if my_mx.lookup.is_err() {
+		get_similar_mail_provider(&mut my_syntax);
+
+		return CheckEmailOutput {
+			input: to_email.to_string(),
+			is_reachable: Reachable::Invalid,
+			mx: Ok(my_mx),
+			syntax: my_syntax,
+			..Default::default()
+		};
+	}
+
+	let mx_hosts: Vec<String> = my_mx
+		.lookup
+		.as_ref()
+		.expect("If lookup is error, we already returned. qed.")
+		.iter()
+		.map(|host| host.to_string())
+		.collect();
+
+	tracing::debug!(
+		target: LOG_TARGET,
+		email=%to_email,
+		mx_hosts=?mx_hosts,
+		"Found MX hosts"
+	);
+
+	let my_misc = check_misc(
+		&my_syntax,
+		input.check_gravatar,
+		input.haveibeenpwned_api_key.clone(),
+	)
+	.await;
+
+	tracing::debug!(
+		target: LOG_TARGET,
+		email=%to_email,
+		misc=?my_misc,
+		"Found misc details"
+	);
+
+	// From the list of MX records, we choose the one with the lowest priority.
+	let mx_records = my_mx
+		.lookup
+		.as_ref()
+		.expect("If lookup is error, we already returned. qed.")
+		.iter()
+		.min_by_key(|a| a.preference())
+		.expect("There should be at least one MX record after filtering.");
+	let host = mx_records;
+
+	let (my_smtp, smtp_debug) = check_smtp(
+		my_syntax
+			.address
+			.as_ref()
+			.expect("We already checked that the email has valid format. qed."),
+		host.exchange(),
+		my_syntax.domain.as_ref(),
+		input,
+	)
+	.await;
+
+	if my_smtp.is_err() {
+		get_similar_mail_provider(&mut my_syntax);
+	}
+
+	let end_time = SystemTime::now();
+
+	let output = CheckEmailOutput {
+		input: to_email.to_string(),
+		is_reachable: calculate_reachable(&my_misc, &my_smtp),
+		misc: Ok(my_misc),
+		mx: Ok(my_mx),
+		smtp: my_smtp,
+		syntax: my_syntax,
+		debug: DebugDetails {
+			start_time: start_time.into(),
+			end_time: end_time.into(),
+			duration: end_time
+				.duration_since(start_time)
+				.unwrap_or(Duration::from_secs(0)),
+			smtp: smtp_debug,
+			backend_name: input.backend_name.clone(),
+		},
+	};
+
+	#[cfg(feature = "sentry")]
+	log_unknown_errors(&output, &input.backend_name);
+
+	output
+}