PHPMailer\PHPMailer

SMTP::authenticate │ public │ WP 1.0

Perform SMTP authentication. Must be run after hello().

Метод класса: SMTP{}

Хуков нет.

Возвращает

true|false. True if successfully authenticated

Использование

$SMTP = new SMTP();
$SMTP->authenticate( $username, $password, $authtype, $OAuth );

$username(строка) (обязательный)

The user name.

$password(строка) (обязательный)

The password.

$authtype(строка)

The auth type (CRAM-MD5, PLAIN, LOGIN, XOAUTH2).
По умолчанию: null

$OAuth(OAuthTokenProvider)

An optional OAuthTokenProvider instance for XOAUTH2 authentication.
По умолчанию: null

Заметки

• Смотрите: hello()

Код SMTP::authenticate() SMTP::authenticate ^{WP 6.9.1}

public function authenticate(
    $username,
    $password,
    $authtype = null,
    $OAuth = null
) {
    if (!$this->server_caps) {
        $this->setError('Authentication is not allowed before HELO/EHLO');

        return false;
    }

    if (array_key_exists('EHLO', $this->server_caps)) {
        //SMTP extensions are available; try to find a proper authentication method
        if (!array_key_exists('AUTH', $this->server_caps)) {
            $this->setError('Authentication is not allowed at this stage');
            //'at this stage' means that auth may be allowed after the stage changes
            //e.g. after STARTTLS

            return false;
        }

        $this->edebug('Auth method requested: ' . ($authtype ?: 'UNSPECIFIED'), self::DEBUG_LOWLEVEL);
        $this->edebug(
            'Auth methods available on the server: ' . implode(',', $this->server_caps['AUTH']),
            self::DEBUG_LOWLEVEL
        );

        //If we have requested a specific auth type, check the server supports it before trying others
        if (null !== $authtype && !in_array($authtype, $this->server_caps['AUTH'], true)) {
            $this->edebug('Requested auth method not available: ' . $authtype, self::DEBUG_LOWLEVEL);
            $authtype = null;
        }

        if (empty($authtype)) {
            //If no auth mechanism is specified, attempt to use these, in this order
            //Try CRAM-MD5 first as it's more secure than the others
            foreach (['CRAM-MD5', 'LOGIN', 'PLAIN', 'XOAUTH2'] as $method) {
                if (in_array($method, $this->server_caps['AUTH'], true)) {
                    $authtype = $method;
                    break;
                }
            }
            if (empty($authtype)) {
                $this->setError('No supported authentication methods found');

                return false;
            }
            $this->edebug('Auth method selected: ' . $authtype, self::DEBUG_LOWLEVEL);
        }

        if (!in_array($authtype, $this->server_caps['AUTH'], true)) {
            $this->setError("The requested authentication method \"$authtype\" is not supported by the server");

            return false;
        }
    } elseif (empty($authtype)) {
        $authtype = 'LOGIN';
    }
    switch ($authtype) {
        case 'PLAIN':
            //Start authentication
            if (!$this->sendCommand('AUTH', 'AUTH PLAIN', 334)) {
                return false;
            }
            //Send encoded username and password
            if (
                //Format from https://www.rfc-editor.org/rfc/rfc4616#section-2
                //We skip the first field (it's forgery), so the string starts with a null byte
                !$this->sendCommand(
                    'User & Password',
                    base64_encode("\0" . $username . "\0" . $password),
                    235
                )
            ) {
                return false;
            }
            break;
        case 'LOGIN':
            //Start authentication
            if (!$this->sendCommand('AUTH', 'AUTH LOGIN', 334)) {
                return false;
            }
            if (!$this->sendCommand('Username', base64_encode($username), 334)) {
                return false;
            }
            if (!$this->sendCommand('Password', base64_encode($password), 235)) {
                return false;
            }
            break;
        case 'CRAM-MD5':
            //Start authentication
            if (!$this->sendCommand('AUTH CRAM-MD5', 'AUTH CRAM-MD5', 334)) {
                return false;
            }
            //Get the challenge
            $challenge = base64_decode(substr($this->last_reply, 4));

            //Build the response
            $response = $username . ' ' . $this->hmac($challenge, $password);

            //send encoded credentials
            return $this->sendCommand('Username', base64_encode($response), 235);
        case 'XOAUTH2':
            //The OAuth instance must be set up prior to requesting auth.
            if (null === $OAuth) {
                return false;
            }
            $oauth = $OAuth->getOauth64();
            /*
             * An SMTP command line can have a maximum length of 512 bytes, including the command name,
             * so the base64-encoded OAUTH token has a maximum length of:
             * 512 - 13 (AUTH XOAUTH2) - 2 (CRLF) = 497 bytes
             * If the token is longer than that, the command and the token must be sent separately as described in
             * https://www.rfc-editor.org/rfc/rfc4954#section-4
             */
            if ($oauth === '') {
                //Sending an empty auth token is legitimate, but it must be encoded as '='
                //to indicate it's not a 2-part command
                if (!$this->sendCommand('AUTH', 'AUTH XOAUTH2 =', 235)) {
                    return false;
                }
            } elseif (strlen($oauth) <= 497) {
                //Authenticate using a token in the initial-response part
                if (!$this->sendCommand('AUTH', 'AUTH XOAUTH2 ' . $oauth, 235)) {
                    return false;
                }
            } else {
                //The token is too long, so we need to send it in two parts.
                //Send the auth command without a token and expect a 334
                if (!$this->sendCommand('AUTH', 'AUTH XOAUTH2', 334)) {
                    return false;
                }
                //Send the token
                if (!$this->sendCommand('OAuth TOKEN', $oauth, [235, 334])) {
                    return false;
                }
                //If the server answers with 334, send an empty line and wait for a 235
                if (
                    substr($this->last_reply, 0, 3) === '334'
                    && $this->sendCommand('AUTH End', '', 235)
                ) {
                    return false;
                }
            }
            break;
        default:
            $this->setError("Authentication method \"$authtype\" is not supported");

            return false;
    }

    return true;
}