valid_email_checker 0.1.0

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

@@ -0,0 +1,144 @@
+// 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 super::gmail::GmailError;
+use super::headless::HeadlessError;
+use super::outlook::microsoft365::Microsoft365Error;
+use super::parser;
+use super::yahoo::YahooError;
+use crate::util::ser_with_display::ser_with_display;
+use async_smtp::error::Error as AsyncSmtpError;
+use serde::Serialize;
+use std::time::Duration;
+use thiserror::Error;
+
+/// Error occurred connecting to this email server via SMTP.
+#[derive(Debug, Error, Serialize)]
+#[serde(tag = "type", content = "message")]
+pub enum SmtpError {
+	/// Error when verifying a Yahoo email via HTTP requests.
+	#[error("Yahoo error: {0}")]
+	YahooError(YahooError),
+	/// Error when verifying a Gmail email via a HTTP request.
+	#[error("Gmail error: {0}")]
+	GmailError(GmailError),
+	/// Error when verifying a Hotmail email via headless browser.
+	#[error("Headless verification error: {0}")]
+	HeadlessError(HeadlessError),
+	/// Error when verifying a Microsoft 365 email via HTTP request.
+	#[error("Microsoft 365 API error: {0}")]
+	Microsoft365Error(Microsoft365Error),
+	/// Error from async-smtp crate.
+	#[error("SMTP error: {0}")]
+	#[serde(serialize_with = "ser_with_display")]
+	AsyncSmtpError(AsyncSmtpError),
+	/// I/O error.
+	#[error("I/O error: {0}")]
+	#[serde(serialize_with = "ser_with_display")]
+	IOError(std::io::Error),
+	/// Timeout error.
+	#[error("Timeout error: {0:?}")]
+	Timeout(Duration),
+	/// SOCKS5 proxy error.
+	#[error("SOCKS5 error: {0}")]
+	#[serde(serialize_with = "ser_with_display")]
+	Socks5(fast_socks5::SocksError),
+	/// Anyhow error.
+	/// This is a catch-all error type for any error that can't be categorized
+	/// into the above types.
+	#[error("Anyhow error: {0}")]
+	#[serde(serialize_with = "ser_with_display")]
+	AnyhowError(anyhow::Error),
+}
+
+impl From<YahooError> for SmtpError {
+	fn from(e: YahooError) -> Self {
+		SmtpError::YahooError(e)
+	}
+}
+
+impl From<GmailError> for SmtpError {
+	fn from(e: GmailError) -> Self {
+		SmtpError::GmailError(e)
+	}
+}
+
+impl From<HeadlessError> for SmtpError {
+	fn from(e: HeadlessError) -> Self {
+		SmtpError::HeadlessError(e)
+	}
+}
+
+impl From<Microsoft365Error> for SmtpError {
+	fn from(e: Microsoft365Error) -> Self {
+		SmtpError::Microsoft365Error(e)
+	}
+}
+
+impl From<AsyncSmtpError> for SmtpError {
+	fn from(e: AsyncSmtpError) -> Self {
+		SmtpError::AsyncSmtpError(e)
+	}
+}
+
+impl From<std::io::Error> for SmtpError {
+	fn from(e: std::io::Error) -> Self {
+		SmtpError::IOError(e)
+	}
+}
+
+impl From<fast_socks5::SocksError> for SmtpError {
+	fn from(e: fast_socks5::SocksError) -> Self {
+		SmtpError::Socks5(e)
+	}
+}
+
+impl From<anyhow::Error> for SmtpError {
+	fn from(e: anyhow::Error) -> Self {
+		SmtpError::AnyhowError(e)
+	}
+}
+
+impl SmtpError {
+	/// Get a human-understandable description of the error, in form of an enum
+	/// SmtpErrorDesc. This only parses the following known errors:
+	/// - IP blacklisted
+	/// - IP needs reverse DNS
+	pub fn get_description(&self) -> Option<SmtpErrorDesc> {
+		match self {
+			SmtpError::AsyncSmtpError(_) => {
+				if parser::is_err_ip_blacklisted(self) {
+					Some(SmtpErrorDesc::IpBlacklisted)
+				} else if parser::is_err_needs_rdns(self) {
+					Some(SmtpErrorDesc::NeedsRDNS)
+				} else {
+					None
+				}
+			}
+			_ => None,
+		}
+	}
+}
+
+#[derive(Debug, Serialize)]
+/// SmtpErrorDesc describes a description of which category the error belongs
+/// to.
+pub enum SmtpErrorDesc {
+	/// The IP is blacklisted.
+	IpBlacklisted,
+	/// The IP needs a reverse DNS entry.
+	NeedsRDNS,
+}

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

@@ -0,0 +1,99 @@
+// 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 super::SmtpDetails;
+use crate::EmailAddress;
+use crate::LOG_TARGET;
+use crate::{
+	smtp::http_api::create_client,
+	util::{input_output::CheckEmailInput, ser_with_display::ser_with_display},
+};
+use reqwest::Error as ReqwestError;
+use serde::Serialize;
+use thiserror::Error;
+
+const GLXU_PAGE: &str = "https://mail.google.com/mail/gxlu";
+
+/// Possible errors when checking Gmail email addresses.
+#[derive(Debug, Error, Serialize)]
+pub enum GmailError {
+	/// Error when serializing or deserializing HTTP requests and responses.
+	#[serde(serialize_with = "ser_with_display")]
+	#[error("Error serializing or deserializing HTTP requests and responses: {0}")]
+	ReqwestError(ReqwestError),
+}
+
+impl From<ReqwestError> for GmailError {
+	fn from(error: ReqwestError) -> Self {
+		GmailError::ReqwestError(error)
+	}
+}
+
+#[allow(dead_code)]
+/// Use HTTP request to verify if a Gmail email address exists.
+/// See: <https://blog.0day.rocks/abusing-gmail-to-get-previously-unlisted-e-mail-addresses-41544b62b2>
+///
+/// This method doesn't work anymore, as Google has patched the vulnerability,
+/// but it's kept here for historical reasons.
+#[deprecated]
+pub async fn check_gmail_via_api(
+	to_email: &EmailAddress,
+	input: &CheckEmailInput,
+) -> Result<SmtpDetails, GmailError> {
+	let response = create_client(input, "gmail")?
+		.head(GLXU_PAGE)
+		.query(&[("email", to_email)])
+		.send()
+		.await?;
+
+	let email_exists = response.headers().contains_key("Set-Cookie");
+
+	tracing::debug!(
+		target: LOG_TARGET,
+		email = %to_email,
+		response = ?response,
+		"Gmail API response"
+	);
+
+	Ok(SmtpDetails {
+		can_connect_smtp: true,
+		is_deliverable: email_exists,
+		..Default::default()
+	})
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::CheckEmailInputBuilder;
+	use std::str::FromStr;
+
+	#[tokio::test]
+	#[ignore] // ref: https://github.com/reacherhq/check-if-email-exists/issues/1431
+	async fn should_return_is_deliverable_true() {
+		let to_email = EmailAddress::from_str("someone@gmail.com").unwrap();
+		let input = CheckEmailInputBuilder::default()
+			.to_email("someone@gmail.com".to_owned())
+			.build()
+			.unwrap();
+
+		#[allow(deprecated)]
+		let smtp_details = check_gmail_via_api(&to_email, &input).await;
+
+		assert!(smtp_details.is_ok());
+		assert!(smtp_details.unwrap().is_deliverable);
+	}
+}

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

@@ -0,0 +1,82 @@
+// 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::{util::ser_with_display::ser_with_display, WebdriverConfig};
+use fantoccini::{
+	error::{CmdError, NewSessionError},
+	Client, ClientBuilder,
+};
+use serde::Serialize;
+use serde_json::Map;
+use thiserror::Error;
+
+#[derive(Debug, Error, Serialize)]
+pub enum HeadlessError {
+	#[serde(serialize_with = "ser_with_display")]
+	#[error("Fantoccini error: {0}")]
+	Fantoccini(#[from] std::io::Error),
+	#[serde(serialize_with = "ser_with_display")]
+	#[error("Cmd error: {0}")]
+	Cmd(#[from] CmdError),
+	#[serde(serialize_with = "ser_with_display")]
+	#[error("New session error: {0}")]
+	NewSession(#[from] NewSessionError),
+}
+
+pub async fn create_headless_client(
+	webdriver: &str,
+	webdriver_config: &WebdriverConfig,
+) -> Result<Client, HeadlessError> {
+	let mut opts = serde_json::json!({
+		"args": [
+			"--headless=new", "--disable-gpu", "--disable-dev-shm-usage",
+			// Running in a Docker container, I run into the following error:
+			// Failed to move to new namespace: PID namespaces supported, Network namespace supported, but failed: errno = Operation not permitted
+			// In searching around I found a few different workarounds:
+			// - Enable namespaces: https://github.com/jessfraz/dockerfiles/issues/65#issuecomment-266532289
+			// - Run it with a custom seccomp: https://github.com/jessfraz/dockerfiles/issues/65#issuecomment-217214671
+			// - Run with --no-sandbox: https://github.com/karma-runner/karma-chrome-launcher/issues/125#issuecomment-312668593
+			// For now I went with the --no-sandbox.
+			//
+			// TODO Look into security implications...
+			"--no-sandbox",
+			// From https://github.com/chromium-for-lambda/chromium-binaries/tree/b23e11c2f2859b177fd08fe50a0826c17652d846?tab=readme-ov-file#installation-via-a-lambda-layer
+			"--use-gl=angle", "--use-angle=swiftshader", "--single-process", "--no-zygote",
+			// Disable anything that might consume memory
+			"--window-size=800x600",
+			"--disable-extensions",
+			"--disable-software-rasterizer",
+			"--disable-dev-shm-usage",
+			"--disable-background-networking",
+			"--js-flags=\"--max-old-space-size=256\"",
+		]
+	});
+
+	if let Some(binary) = &webdriver_config.binary {
+		opts["binary"] = serde_json::json!(binary);
+	}
+
+	let mut caps = Map::new();
+	caps.insert("goog:chromeOptions".to_string(), opts);
+
+	// Connect to WebDriver instance that is listening on `webdriver`
+	let c = ClientBuilder::rustls()?
+		.capabilities(caps)
+		.connect(webdriver)
+		.await?;
+
+	Ok(c)
+}

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

@@ -0,0 +1,27 @@
+// 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::util::input_output::CheckEmailInput;
+use reqwest::Error as ReqwestError;
+
+/// Helper function to create a reqwest client, with optional proxy.
+pub fn create_client(
+	_input: &CheckEmailInput,
+	_api_name: &str,
+) -> Result<reqwest::Client, ReqwestError> {
+	// TODO: Allow proxying for HTTP API requests.
+	Ok(reqwest::Client::new())
+}

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

@@ -0,0 +1,234 @@
+// 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/>.
+
+mod connect;
+mod error;
+mod gmail;
+mod headless;
+mod http_api;
+mod outlook;
+mod parser;
+pub mod verif_method;
+mod yahoo;
+
+use crate::util::input_output::CheckEmailInput;
+use crate::EmailAddress;
+use connect::check_smtp_with_retry;
+use hickory_proto::rr::Name;
+use serde::{Deserialize, Serialize};
+use std::default::Default;
+use verif_method::{
+	EmailProvider, EverythingElseVerifMethod, GmailVerifMethod, HotmailB2BVerifMethod,
+	HotmailB2CVerifMethod, VerifMethodSmtp, VerifMethodSmtpConfig, YahooVerifMethod,
+};
+
+pub use crate::mx::{is_gmail, is_hotmail, is_hotmail_b2b, is_hotmail_b2c, is_yahoo};
+pub use error::*;
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct SmtpDebugVerifMethodSmtp {
+	/// The host we connected to via SMTP.
+	pub host: String,
+	/// The proxy used for the SMTP connection.
+	pub verif_method: VerifMethodSmtpConfig,
+}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(tag = "type")]
+pub enum SmtpDebugVerifMethod {
+	/// Email verification was done via SMTP.
+	Smtp(SmtpDebugVerifMethodSmtp),
+	/// Email verification was done via an HTTP API.
+	Api,
+	/// Email verification was done via a headless browser.
+	Headless,
+	/// Email verification was skipped.
+	#[default]
+	Skipped,
+}
+
+/// Details that we gathered from connecting to this email via SMTP
+#[derive(Debug, Default, Deserialize, Serialize)]
+pub struct SmtpDetails {
+	/// Are we able to connect to the SMTP server?
+	pub can_connect_smtp: bool,
+	/// Is this email account's inbox full?
+	pub has_full_inbox: bool,
+	/// Does this domain have a catch-all email address?
+	pub is_catch_all: bool,
+	/// Can we send an email to this address?
+	pub is_deliverable: bool,
+	/// Is the email blocked or disabled by the provider?
+	pub is_disabled: bool,
+}
+
+/// Debug information on how the SMTP verification went.
+#[derive(Debug, Default, Deserialize, Serialize)]
+pub struct SmtpDebug {
+	/// The verification method used for the email.
+	pub verif_method: SmtpDebugVerifMethod,
+}
+
+/// Get all email details we can from one single `EmailAddress`, without
+/// retries.
+pub async fn check_smtp(
+	to_email: &EmailAddress,
+	host: &Name,
+	domain: &str,
+	input: &CheckEmailInput,
+) -> (Result<SmtpDetails, SmtpError>, SmtpDebug) {
+	let host_str = host.to_string();
+	let to_email_str = to_email.to_string();
+	let email_provider = EmailProvider::from_mx_host(&host_str);
+
+	// Handle all non-SMTP verifications first, and return early. For the rest,
+	// we'll use SMTP, and return the config.
+	let smtp_verif_method_config = match &email_provider {
+		EmailProvider::HotmailB2C => match &input.verif_method.hotmailb2c {
+			HotmailB2CVerifMethod::Headless => {
+				return (
+					outlook::headless::check_password_recovery(
+						&to_email_str,
+						&input.webdriver_addr,
+						&input.webdriver_config,
+					)
+					.await
+					.map_err(Into::into),
+					SmtpDebug {
+						verif_method: SmtpDebugVerifMethod::Headless,
+					},
+				);
+			}
+			HotmailB2CVerifMethod::Smtp(c) => c,
+		},
+		EmailProvider::Yahoo => match &input.verif_method.yahoo {
+			YahooVerifMethod::Api => {
+				return (
+					yahoo::check_api(&to_email_str, input)
+						.await
+						.map_err(Into::into),
+					SmtpDebug {
+						verif_method: SmtpDebugVerifMethod::Api,
+					},
+				);
+			}
+			YahooVerifMethod::Headless => {
+				return (
+					yahoo::check_headless(
+						&to_email_str,
+						&input.webdriver_addr,
+						&input.webdriver_config,
+					)
+					.await
+					.map_err(Into::into),
+					SmtpDebug {
+						verif_method: SmtpDebugVerifMethod::Headless,
+					},
+				);
+			}
+			YahooVerifMethod::Smtp(c) => c,
+		},
+		EmailProvider::Gmail => match &input.verif_method.gmail {
+			GmailVerifMethod::Smtp(c) => c,
+		},
+		EmailProvider::HotmailB2B => match &input.verif_method.hotmailb2b {
+			HotmailB2BVerifMethod::Smtp(c) => c,
+		},
+		EmailProvider::Mimecast => match &input.verif_method.mimecast {
+			verif_method::MimecastVerifMethod::Smtp(c) => c,
+		},
+		EmailProvider::Proofpoint => match &input.verif_method.proofpoint {
+			verif_method::ProofpointVerifMethod::Smtp(c) => c,
+		},
+		EmailProvider::EverythingElse => match &input.verif_method.everything_else {
+			EverythingElseVerifMethod::Smtp(c) => c,
+		},
+	}
+	.clone();
+
+	// TODO: There's surely a way to not clone here.
+	let verif_method = VerifMethodSmtp::new(
+		smtp_verif_method_config.clone(),
+		input.verif_method.get_proxy(email_provider).cloned(),
+	);
+
+	(
+		check_smtp_with_retry(
+			to_email,
+			&host_str,
+			domain,
+			&verif_method,
+			verif_method.config.retries,
+		)
+		.await,
+		SmtpDebug {
+			verif_method: SmtpDebugVerifMethod::Smtp(SmtpDebugVerifMethodSmtp {
+				host: host_str,
+				verif_method: smtp_verif_method_config,
+			}),
+		},
+	)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::smtp::verif_method::GmailVerifMethod;
+	use crate::smtp::verif_method::VerifMethod;
+	use crate::smtp::verif_method::VerifMethodSmtpConfig;
+	use crate::CheckEmailInputBuilder;
+	use crate::EmailAddress;
+	use hickory_proto::rr::Name;
+	use std::{str::FromStr, time::Duration};
+	use tokio::runtime::Runtime;
+
+	#[test]
+	fn should_timeout() {
+		let runtime = Runtime::new().unwrap();
+
+		let to_email = EmailAddress::from_str("foo@gmail.com").unwrap();
+		let host = Name::from_str("alt4.aspmx.l.google.com.").unwrap();
+		let input = CheckEmailInputBuilder::default()
+			.to_email("foo@gmail.com".into())
+			.verif_method(VerifMethod {
+				gmail: GmailVerifMethod::Smtp(VerifMethodSmtpConfig {
+					smtp_timeout: Some(Duration::from_millis(1)),
+					retries: 1,
+					..Default::default()
+				}),
+				..Default::default()
+			})
+			.build()
+			.unwrap();
+
+		let (res, smtp_debug) = runtime.block_on(check_smtp(&to_email, &host, "gmail.com", &input));
+		match smtp_debug.verif_method {
+			SmtpDebugVerifMethod::Smtp(SmtpDebugVerifMethodSmtp { host, verif_method }) => {
+				assert_eq!(host, "alt4.aspmx.l.google.com.");
+				assert_eq!(verif_method.smtp_port, 25);
+				assert_eq!(verif_method.smtp_timeout, Some(Duration::from_millis(1)));
+				assert_eq!(verif_method.retries, 1);
+				assert_eq!(verif_method.proxy, None);
+			}
+			_ => panic!("Expected SmtpDebugVerifMethod::Smtp"),
+		}
+
+		match res {
+			Err(SmtpError::Timeout(_)) => (), // ErrorKind == Timeout
+			_ => panic!("check_smtp did not time out"),
+		}
+	}
+}