valid_email_checker 0.1.0

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

@@ -0,0 +1,188 @@
+// 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 std::pin::Pin;
+use std::vec;
+use std::{thread::sleep, time::Duration};
+
+use fantoccini::error::CmdError;
+use fantoccini::Locator;
+use futures::future::select_ok;
+use futures::{Future, TryFutureExt};
+
+use crate::smtp::headless::{create_headless_client, HeadlessError};
+use crate::WebdriverConfig;
+use crate::{smtp::SmtpDetails, LOG_TARGET};
+
+/// Check if a Hotmail/Outlook email exists by connecting to the password
+/// recovery page https://account.live.com/password/reset using a headless
+/// browser. Make sure you have a WebDriver server running locally before
+/// running this, or this will error.
+pub async fn check_headless(
+	to_email: &str,
+	webdriver: &str,
+	webdriver_config: &WebdriverConfig,
+) -> Result<SmtpDetails, HeadlessError> {
+	let mut attempts = 0;
+	let max_attempts = 3;
+	let mut last_error = None;
+
+	while attempts < max_attempts {
+		attempts += 1;
+		tracing::debug!(
+			target: LOG_TARGET,
+			email=%to_email,
+			attempt=%attempts,
+			"Using Yahoo password recovery in headless navigator"
+		);
+
+		match check_headless_inner(to_email, webdriver, webdriver_config).await {
+			Ok(result) => return Ok(result),
+			Err(e) => {
+				last_error = Some(e);
+				if attempts < max_attempts {
+					sleep(Duration::from_secs(1));
+				}
+			}
+		}
+	}
+
+	Err(last_error.unwrap())
+}
+
+async fn check_headless_inner(
+	to_email: &str,
+	webdriver: &str,
+	webdriver_config: &WebdriverConfig,
+) -> Result<SmtpDetails, HeadlessError> {
+	let c = create_headless_client(webdriver, webdriver_config).await?;
+
+	// Navigate to Microsoft password recovery page.
+	c.goto("https://login.yahoo.com/forgot").await?;
+
+	// Wait for network/javascript/dom to make the input-box available
+	// and click it.
+	let input = c.wait().for_element(Locator::Id("username")).await?;
+	// Sometimes I get "input ... is not reachable by keyboard". Addind this
+	// small sleep helps.
+	sleep(Duration::from_millis(200));
+	input.send_keys(to_email).await?;
+
+	// Click on "Continue"
+	c.find(Locator::Css("button[name=\"verifyYid\"]"))
+		.await?
+		.click()
+		.await?;
+
+	// Depending on what answers we have on the account recovery page, return
+	// the relevant (is_deliverable, is_disabled) tuple.
+
+	// "Sorry, we don't recognise that email address or phone number".
+	let f1 = c
+		.wait()
+		.for_element(Locator::Css(".error-msg"))
+		.and_then(|_| async { Ok((false, false)) });
+	// "This account has been deactivated due to inactivity, but we would love to welcome you back!"
+	let f2 = c
+		.wait()
+		.for_element(Locator::Css(".ctx-account_is_locked"))
+		.and_then(|_| async { Ok((false, true)) });
+	// Recaptcha
+	let f3 = c
+		.wait()
+		.for_element(Locator::Css(".recaptcha-challenge"))
+		.and_then(|_| async { Ok((true, false)) });
+	// "Enter verification code sent to your email address"
+	let f4 = c
+		.wait()
+		.for_element(Locator::Id("email-verify-challenge"))
+		.and_then(|_| async { Ok((true, false)) });
+	// "Select an option to sign in to your account"
+	let f5 = c
+		.wait()
+		.for_element(Locator::Id("challenge-selector-challenge"))
+		.and_then(|_| async { Ok((true, false)) });
+
+	let vec = vec![
+		Box::pin(f1) as Pin<Box<dyn Future<Output = Result<(bool, bool), CmdError>> + Send>>,
+		Box::pin(f2),
+		Box::pin(f3),
+		Box::pin(f4),
+		Box::pin(f5),
+	];
+	let ((is_deliverable, is_disabled), _) = select_ok(vec).await?;
+
+	c.close().await?;
+
+	Ok(SmtpDetails {
+		can_connect_smtp: true,
+		has_full_inbox: false,
+		is_catch_all: false,
+		is_deliverable,
+		is_disabled,
+	})
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::{initialize_crypto_provider, WebdriverConfig};
+
+	use super::check_headless;
+
+	// Ignoring this test as it requires a local process of WebDriver running on
+	// "http://localhost:9515". To debug the headless password recovery page,
+	// run chromedriver and remove the "#[ignore]".
+	// Also see: https://github.com/jonhoo/fantoccini
+	#[tokio::test]
+	#[ignore = "Run a webdriver server on port 9515 locally to test this"]
+	async fn test_yahoo_address() {
+		initialize_crypto_provider();
+		// Run 5 headless sessions with the below dummy emails.
+		for _ in 0..5 {
+			// Email does not exist.
+			let res = check_headless(
+				"test42134@yahoo.com",
+				"http://localhost:9515",
+				&WebdriverConfig::default(),
+			)
+			.await
+			.unwrap();
+			assert!(!res.is_deliverable);
+
+			// Disabled email.
+			let res = check_headless(
+				"amaury@yahoo.com",
+				"http://localhost:9515",
+				&WebdriverConfig::default(),
+			)
+			.await
+			.unwrap();
+			assert!(!res.is_deliverable);
+			assert!(res.is_disabled);
+
+			// OK email.
+			let res = check_headless(
+				"test2@yahoo.com",
+				"http://localhost:9515",
+				&WebdriverConfig::default(),
+			)
+			.await
+			.unwrap();
+			assert!(res.is_deliverable);
+			assert!(!res.is_disabled);
+		}
+	}
+}

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

@@ -0,0 +1,62 @@
+// 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 api;
+
+mod headless;
+
+use crate::util::ser_with_display::ser_with_display;
+use reqwest::Error as ReqwestError;
+use serde::Serialize;
+use serde_json::error::Error as SerdeError;
+use thiserror::Error;
+
+pub use api::check_api;
+pub use headless::check_headless;
+
+/// Possible errors when checking Yahoo email addresses.
+#[derive(Debug, Error, Serialize)]
+pub enum YahooError {
+	/// Cannot find "acrumb" field in cookie.
+	#[error("Cannot find \"acrumb\" field in cookie")]
+	NoAcrumb,
+	/// Cannot find "sessionIndex" hidden input in body
+	#[error("Cannot find \"sessionIndex\" hidden input in body")]
+	NoSessionIndex,
+	/// Cannot find cookie in Yahoo response.
+	#[error("Cannot find cookie in Yahoo response")]
+	NoCookie,
+	/// 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),
+	/// 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}")]
+	SerdeError(SerdeError),
+}
+
+impl From<ReqwestError> for YahooError {
+	fn from(error: ReqwestError) -> Self {
+		YahooError::ReqwestError(error)
+	}
+}
+
+impl From<SerdeError> for YahooError {
+	fn from(error: SerdeError) -> Self {
+		YahooError::SerdeError(error)
+	}
+}

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

@@ -0,0 +1,199 @@
+// 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 normalize;
+
+use crate::EmailAddress;
+use levenshtein::levenshtein;
+use normalize::normalize_email;
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+
+/// Syntax information after parsing an email address
+#[derive(Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub struct SyntaxDetails {
+	/// The email address as a async_smtp `EmailAddress`. It will be `None` if
+	/// the email address is ill-formed.
+	pub address: Option<EmailAddress>,
+	/// The domain name, after "@". It will be the empty string if the email
+	/// address if ill-formed.
+	pub domain: String,
+	/// Does the email have a valid syntax?
+	pub is_valid_syntax: bool,
+	/// The username, before "@". It will be the empty string if the email
+	/// address if ill-formed.
+	pub username: String,
+	/// The normalized form of `address`. It will be `None` if the email
+	/// address is ill-formed.
+	pub normalized_email: Option<String>,
+	pub suggestion: Option<String>,
+}
+
+impl Default for SyntaxDetails {
+	fn default() -> Self {
+		SyntaxDetails {
+			address: None,
+			domain: "".into(),
+			is_valid_syntax: false,
+			username: "".into(),
+			normalized_email: None,
+			suggestion: None,
+		}
+	}
+}
+
+/// From an `email_address` string, compute syntax information about it, such as
+/// username and domain.
+pub fn check_syntax(email_address: &str) -> SyntaxDetails {
+	let email_address = match EmailAddress::from_str(email_address) {
+		Ok(m) => {
+			if mailchecker::is_valid(email_address) {
+				m
+			} else {
+				return SyntaxDetails {
+					address: None,
+					domain: "".into(),
+					is_valid_syntax: false,
+					username: "".into(),
+					normalized_email: None,
+					suggestion: None,
+				};
+			}
+		}
+		_ => {
+			return SyntaxDetails {
+				address: None,
+				domain: "".into(),
+				is_valid_syntax: false,
+				username: "".into(),
+				normalized_email: None,
+				suggestion: None,
+			}
+		}
+	};
+
+	let iter: &str = email_address.as_ref();
+	let mut iter = iter.split('@');
+	let username: String = iter
+		.next()
+		.expect("We checked above that email is valid. qed.")
+		.into();
+	let domain: String = iter
+		.next()
+		.expect("We checked above that email is valid. qed.")
+		.into();
+	let normalized_email = normalize_email(&username, &domain);
+
+	SyntaxDetails {
+		address: Some(email_address),
+		domain,
+		is_valid_syntax: true,
+		username,
+		normalized_email: Some(normalized_email),
+		suggestion: None,
+	}
+}
+
+const MAIL_PROVIDERS: &[&str] = &[
+	"gmail.com",
+	"yahoo.com",
+	"outlook.com",
+	"hotmail.com",
+	"protonmail.com",
+	"icloud.com",
+	"yandex.com",
+];
+// Supplies the syntax parameter with a suggestion that matches the mail domain best by levenshtein
+// distance.
+pub fn get_similar_mail_provider(syntax: &mut SyntaxDetails) {
+	for possible_provider in MAIL_PROVIDERS {
+		let distance = levenshtein(&syntax.domain, possible_provider);
+
+		if distance < 3 {
+			// Return full address
+			syntax.suggestion = Some(format!(
+				"{}@{}",
+				syntax.username,
+				String::from(*possible_provider),
+			));
+			break;
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_return_invalid_for_invalid_email() {
+		assert_eq!(
+			check_syntax("foo"),
+			SyntaxDetails {
+				address: None,
+				domain: "".into(),
+				is_valid_syntax: false,
+				username: "".into(),
+				normalized_email: None,
+				suggestion: None,
+			}
+		);
+	}
+
+	#[test]
+	fn should_return_invalid_for_invalid_email_with_at() {
+		assert_eq!(
+			check_syntax("foo@bar"),
+			SyntaxDetails {
+				address: None,
+				domain: "".into(),
+				is_valid_syntax: false,
+				username: "".into(),
+				normalized_email: None,
+				suggestion: None,
+			}
+		);
+	}
+
+	#[test]
+	fn should_work_for_valid_email() {
+		assert_eq!(
+			check_syntax("foo@bar.com"),
+			SyntaxDetails {
+				address: Some(EmailAddress::new("foo@bar.com".into()).unwrap()),
+				domain: "bar.com".into(),
+				is_valid_syntax: true,
+				username: "foo".into(),
+				normalized_email: Some("foo@bar.com".into()),
+				suggestion: None,
+			}
+		);
+	}
+
+	#[test]
+	fn should_suggest_a_correct_mail_if_similar() {
+		let mut syntax = SyntaxDetails {
+			address: Some(EmailAddress::new("test@gmali.com".into()).unwrap()),
+			domain: "gmali.com".into(),
+			is_valid_syntax: true,
+			username: "test".into(),
+			normalized_email: Some("test@gmali.com".into()),
+			suggestion: None,
+		};
+		get_similar_mail_provider(&mut syntax);
+		assert_eq!(syntax.suggestion, Some("test@gmail.com".to_string()))
+	}
+}

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

@@ -0,0 +1,70 @@
+pub fn normalize_email(username: &str, domain: &str) -> String {
+	match domain {
+		"gmail.com" | "googlemail.com" => normalize_gmail(username),
+		_ => format!("{username}@{domain}"),
+	}
+}
+
+/// Normalize a Gmail address.
+///
+/// See Gmail username
+/// [restrictions](https://support.google.com/mail/answer/9211434?hl=en-GB).
+///
+/// - removes
+///   [sub-addresses](https://support.google.com/a/users/answer/9282734?hl=en#zippy=%2Clearn-how)
+///   (i.e. parts after a `+` character.)
+/// - removes [dots](https://support.google.com/mail/answer/7436150).
+/// - converts to lower-case.
+/// - [replaces](https://support.google.com/mail/answer/10313?hl=en-GB#zippy=%2Cgetting-messages-sent-to-an-googlemailcom-address)
+///   `googlemail.com` with `gmail.com`.
+fn normalize_gmail(username: &str) -> String {
+	let username = match username.split_once('+') {
+		Some((username, _)) => username,
+		_ => username,
+	}
+	.chars()
+	.filter_map(|c| match c.to_ascii_lowercase() {
+		'.' => None,
+		lower => Some(lower),
+	})
+	.collect::<String>();
+
+	format!("{username}@gmail.com",)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_gmail_removes_periods() {
+		assert_eq!(normalize_email("a.b.c", "gmail.com"), "abc@gmail.com");
+	}
+
+	#[test]
+	fn test_gmail_removes_subaddress() {
+		assert_eq!(normalize_email("abc+123", "gmail.com"), "abc@gmail.com");
+	}
+
+	#[test]
+	fn test_gmail_uses_gmail_com() {
+		assert_eq!(normalize_email("abc", "googlemail.com"), "abc@gmail.com");
+	}
+
+	#[test]
+	fn test_gmail() {
+		assert_eq!(
+			normalize_email("A.B.C+123", "googlemail.com"),
+			"abc@gmail.com"
+		);
+	}
+
+	#[test]
+	fn test_gmail_idempotent() {
+		let normalized = normalize_email("A.B.C+123", "googlemail.com");
+
+		let (username, domain) = normalized.rsplit_once('@').unwrap();
+
+		assert_eq!(normalize_email(username, domain), normalized);
+	}
+}