Comment configurer la vérification des e-mails en PHP via un jeton de vérification : guide complet

La vérification des e-mails est le processus permettant de garantir qu'une adresse e-mail existe et peut recevoir des e-mails. Attendu que la validation des e-mails vérifie si l'adresse est correctement formatée ; c'est-à-dire - écrit selon des normes spécifiques (par exemple UTF-8). 

Dans cet article, je parlerai de la vérification des e-mails PHP et de la façon de l'utiliser pour le développement Web et l'authentification des utilisateurs via un jeton de vérification. L'article comprend quelques micro-tutoriels, notamment :

• Configuration PHPMailer avec Mailtrap

• Une création simple de formulaire HTML

• Vérification de base de l'adresse e-mail 

• Générer et stocker des jetons et des informations d'identification dans une base de données SQL

• Envoi d'un e-mail de vérification avec un jeton de vérification

• Tests des e-mails liés à la vérification 

Alors, allons-y. 

Paramétrage de l'envoi d'e-mails

Pour envoyer des e-mails de vérification, vous pouvez utiliser la fonction mail() intégrée de PHP ou une bibliothèque comme PHPMailer, qui offre plus de fonctionnalités et une meilleure fiabilité.

Comme je souhaite rendre le didacticiel aussi sûr et prêt pour la production que possible, j'utiliserai « PHPMailer ». Vérifiez le code pour installer PHPMailer via Composer :

le compositeur nécessite phpmailer/phpmailer

Pourquoi utiliser l'API/SMTP Mailtrap ?

C'est une plateforme de livraison d'e-mails pour tester, envoyer et contrôler vos e-mails en un seul endroit. Et, entre autres, vous obtenez ce qui suit :

Paramètres de configuration prêts à l'emploi pour différentes langues, PHP et Laravel inclus.

SMTP et API avec SDK dans les principaux langages, bien sûr, PHP inclus. 

Meilleures analyses du secteur. 

Accompagnement humain 27h/27 et 7j/7, et procédure accélérée pour les cas urgents. 

Tout cela vous permet d'amorcer le processus de vérification des e-mails et de le maintenir sûr et stable pour tous.

Passons aux paramètres pour configurer PHPMailer avec Mailtrap :

$phpmailer = new PHPMailer();
$phpmailer->isSMTP();
$phpmailer->Host = 'live.smtp.mailtrap.io';
$phpmailer->SMTPAuth = true;
$phpmailer->Port = 587;
$phpmailer->Username = 'api';
$phpmailer->Password = 'YOUR_MAILTRAP_PASSWORD';

Voici la configuration de PHPMailer :

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'vendor/autoload.php';

function sendVerificationEmail($email, $verificationCode) {
    $mail = new PHPMailer(true);

    try {
        // Server settings
        $mail->isSMTP();
        $mail->Host = 'live.smtp.mailtrap.io';
        $mail->SMTPAuth = true;
        $mail->Username = 'api';
        $mail->Password = 'YOUR_MAILTRAP_PASSWORD';
        $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
        $mail->Port = 587;

        // Recipients
        $mail->setFrom('youremail@example.com', 'Your Website');
        $mail->addAddress($email);

        // Content
        $mail->isHTML(false);
        $mail->Subject = 'Email Verification';
        $mail->Body    = "Your verification code is: $verificationCode";

        $mail->send();
        return true;
    } catch (Exception $e) {
        return false;
    }
}

Notez que le code ci-dessus n'envoie pas le jeton de vérification (cliquez ici pour accéder à l'extrait de code avec le jeton de vérification). Ce n'est qu'un exemple de la façon de configurer Mailtrap SMTP et de définir la fonction de vérification. Voici un aperçu rapide des points clés :

• Les classes PHPMailer et Exception sont importées.

• sendVerificationEmail($email, $verificationCode) est la définition de la fonction. 

• Un nouvel objet PHPMailer est créé. 

• Le bloc try-catch gère les exceptions lors de l'envoi d'e-mails.

• Les paramètres du serveur sont définis sur Mailtrap selon l'exemple de configuration. 

• Le contenu de l'e-mail est défini sur isHTML(false) pour le texte brut. 

Conseils : 

• Le contenu de l'e-mail peut être refactorisé en HTML. 

• En raison des limitations de débit, vous devez éviter d'utiliser gmail.com comme relais SMTP de formulaire d'inscription. Mais si vous souhaitez vraiment créer un fichier PHP de messagerie et l'envoyer via Gmail, consultez ce tutoriel. 

Création d'un formulaire d'inscription

Ce ci-dessous est un simple formulaire d'inscription, il contient l'en-tête et les informations du compte utilisateur (nom d'utilisateur, e-mail et mot de passe). 

Il n'a pas de feuille de style CSS ni de classe div puisqu'il ne s'agit que d'un exemple.

Cependant, je vous conseille de les inclure dans la production et de les aligner sur le langage de conception de votre marque. Sinon, votre formulaire risque de ne pas paraître professionnel et les utilisateurs hésiteraient à s'y engager.

 

<!DOCTYPE html>
<html>
<head>
    <title>Register</title>
</head>
<body>
    <form action="register.php" method="post">
        <label>Username:</label>
        <input type="text" name="username" required>
        <br>
        <label>Email:</label>
        <input type="email" name="email" required>
        <br>
        <label>Password:</label>
        <input type="password" name="password" required>
        <br>
        <input type="submit" name="register" value="Register">
    </form>
</body>
</html>

Conseil de pro bonus : pensez à utiliser JavaScript avec vos formulaires 

Si vous souhaitez un tutoriel complet sur la façon de créer un formulaire de contact PHP incluant reCaptcha, regardez la vidéo ci-dessous ⬇️. 

• JS peut valider les entrées de l'utilisateur en temps réel, fournissant un retour immédiat sur les erreurs sans avoir besoin de recharger la page. 

• En détectant les erreurs côté client, JS peut réduire le nombre de requêtes invalides envoyées au serveur, réduisant ainsi la charge du serveur et améliorant les performances de chaque session.

• Grâce à AJAX, JS peut envoyer et recevoir des données du serveur sans recharger la page, offrant ainsi une expérience utilisateur plus fluide.

Maintenant, je vais passer à la vérification de l'adresse e-mail.  

Vérification de l'adresse e-mail

Voici un script simple pour vérifier le domaine et l'enregistrement MX. Il vous permet essentiellement de vérifier vos e-mails en effectuant une recherche MX.

<?php

// This method checks if the domain part of the email address has a functioning mail server.

$email = "user@example.com";

list($user, $domain) = explode(separator:"@", $email)

if (filter_var($email, filter:FILTER_VALIDATE_EMAIL) && getmxrr($domain, &hosts: $mxhosts)){
    echo "Valid email address with a valid mail server" . PHP_EOL;
} else {
    echo "Invalid email address or no valid mail server found" . PHP_EOL;
}

Cependant, le script n'envoie pas d'e-mail pour l'activation et l'authentification de l'utilisateur. De plus, il ne stocke aucune donnée dans MySQL. 

Pour cela, je ferai ce qui suit dans les sections suivantes : 

• Générer un jeton de vérification 

• Créez un schéma PHP MySQL pour stocker les informations d'identification du formulaire d'inscription

• Send the verification email with the token

• Verify the verification token

Tip: Similar logic can be applied to a logout/login form.

Generating verification token

A verification token is a unique string generated for each user during registration. This token is included in the verification email and there are two methods to generate it.

Method 1

The first method leverages the bin2hex command to create a random token with the parameter set to (random_bytes(50)).

 

$token = bin2hex(random_bytes(50));

Method 2

Alternatively, you can generate the token with the script below. And I’ll be using that script in the email-sending script.

<?php
function generateVerificationCode($length = 6) {
    $characters = '0123456789';
    $code = '';
    for ($i = 0; $i < $length; $i++) {
        $code .= $characters[rand(0, strlen($characters) - 1)];
    }
    return $code;
}
?>

Storing verification token

Before sending the verification email, it’s vital to ensure you properly handle and store user data. I’ll use a simple SQL schema to create the users table and store the generated token in the database along with the user's registration information.

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL,
    password VARCHAR(255) NOT NULL,
    token VARCHAR(255) DEFAULT NULL,
    is_verified TINYINT(1) DEFAULT 0
);

Quick breakdown: 

The script above creates a users table with the following columns:

• id - Unique identifier for each user, automatically incremented.

• username - The user's username; it cannot be null.

• email - The user's email address; it cannot be null.

• password - The user's password (hashed); it cannot be null.

• token - A verification token, which can be null.

• is_verified - A flag indicating whether the user is verified (0 for not verified, 1 for verified), with a default value of 0.

Sending verification token 

Overall, the script below is amalgamation of everything previously discussed in the article and it’s designed to: 

• Generate a random numeric verification code. 

• Send the verification email to a specified email address using PHPMailer.

• Configure the email server settings. 

• Handle potential errors. 

• Provide feedback on whether the email was successfully sent.

Note that the script is geared towards Mailtrap users and it leverages the SMTP method.

<?php

require 'vendor/autoload.php';

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\SMTP
use PHPMailer\PHPMailer\Exception;

//Function to generate a random verification code
1 usage
function generateVerificationCode($length = 6) {
    $characters = '0123456789';
    $code = '';
    for ($i = 0; $i < $length; $i++) {
        $code .= $characters[rand(0, strlen($characters) - 1)];
    }
    return $code;
}

// Function to send a verification email using PHPMailer
1 usage
function sendVerificationEmail($email, $verificationCode) {
    $mail = new PHPMailer (exception: true);

    try {
        // Server settings
        $mail ->SMTPDebug = SMTP::DEBUG_OFF; // Set to DEBUG_SERVER for debugging
        $mail ->isSMTP();
        $mail ->Host = 'live.smtp.mailtrap.io'; // Mailtrap SMTP server host 
        $mail ->SMTPAuth = true;
        $mail ->Username = 'api'; // Your Mailtrap SMTP username
        $mail ->Password = 'YOUR_MAILTRAP_PASSWORD'; // Your Mailtrap SMTP password
        $mail ->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS; // Enable TLS encryption
        $email ->Port = 587; // TCP port to connect to

        //Recipients
        $mail->setFrom(address:'mailtrapclub@gmail.com', name:"John Doe"); //Sender's email and name
        $mail->addAddress($email); // Recipient's email

        //Content
        $mail->isHTML(isHTML:false); //Set to true if sending HTML email
        $mail->Subject = 'Email Verification';
        $mail->Body = "Your verification code is: $verificationCode";

        $mail->send();
        return true;
    }catch (Exception $e) {
        return false;
    }
}

//Example usage
$email = "mailtrapclub+test@gmail.com"
$verificationCode = generateVerificationCode();

if (sendVerificationEmail($email,$verificationCode)){
    echo "A verification email has been sent to $email. Please check your inbox and enter the code to verrify your email." . PHP_EOL;
} else {
    echo "Failed to send the verification email. Please try again later." . PHP_EOL;
}

Verifying verification token

Yeah, the title is a bit circular, but that’s exactly what you need. The script below enables the “verification of verification” flow ? that moves like this:

• A user hits the verification link.
• The token gets validated.
• The user’s email is marked as verified in the database.

<?php
$servername = "localhost";
$username = "root";
$password = "";
$dbname = "user_verification";

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);

// Check connection
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}

if (isset($_GET['token'])) {
    $token = $_GET['token'];

    $stmt = $conn->prepare("SELECT * FROM users WHERE token=? LIMIT 1");    $stmt->bind_param("s", $token);    $stmt->execute();
    $result = $stmt->get_result();
    if ($result->num_rows > 0) {
        $user = $result->fetch_assoc();        $stmt->close();
        $stmt = $conn->prepare("UPDATE users SET is_verified=1, token=NULL WHERE id=?");        $stmt->bind_param("i", $user['id']);

        if ($stmt->execute() === TRUE) {
            echo "Email verification successful!";
        } else {
            echo "Error: " . $conn->error;
        }        $stmt->close();
    } else {
        echo "Invalid token!";
    }
}

$conn->close();
?>

We appreciate you chose this article to know more about php email verification. To continue reading the article and discover more articles on related topics, follow Mailrap Blog!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!