Existe uma maneira de usar os usuários do Wordpress, mas sem carregar todo o núcleo do Wordpress?

Se eu tivesse que fazer isso, usaria meu próprio cookie para determinar o login e só carregaria o WordPress para verificar quando necessário.

O cookie wordpress_logged_in_ {some-hash} pode ser usado para determinar o usuário, e o WordPress o utiliza para determinar o mesmo. Você não pode reimplementar facilmente, mas pode usá-lo sem carregar o WordPress em várias solicitações.

Por exemplo, aqui está meu hash de cookie (dados completamente inventados, mas realísticos):

key: wordpress_logged_in_1234567890abcdef1234567890abcdef
value: admin|1234567890|abcdef1234567890abcdef1234567890

A maneira como o WordPress sabe como esse cookie é válido é irrelevante, tudo que você precisa saber é se ele é válido uma vez e, em seguida, você o assina com um segredo.

Então, pela primeira vez, o usuário ainda não está comprovado. Você carrega o wp-load.php e o WP valida o cookie e faz o login do usuário. Agora você faz o que fizer para provar a si mesmo que o usuário está logado e depois define seu próprio cookie. A chave pode ser qualquer coisa personalizada para você, o valor que você faz em um resumo de mensagem com uma chave secreta usando a função hash_hmac.

$key = ... // the key from the WP cookie
$value = ... // the value from the WP cookie
$hash = hash_hmac ( 'md5' , $key.$value , 'some secret key' );

Você receberá de volta mensagens sem sentido, que você envia de volta para eles usando setcookie (). Em solicitações futuras, eles enviarão esse cookie de volta para você. Você pode verificar isso primeiro e validá-lo usando a mesma função hash e chave secreta.

Só você pode gerar o hash porque só você conhece a chave secreta. Então, se eles enviarem um hash válido que também corresponda ao que eles enviam para o cookie WP, você sabe que eles já foram validados com o WP, através do seu código, e você pode obter o nome de usuário desse valor (é o primeiro parte do cookie, obviamente). Então você não precisa carregar o WP.

A chave secreta, BTW, deve ser longa e aleatória . Não é uma senha curta. Não é uma palavra do dicionário. Apenas um grande jargão sem sentido. Ruído de linha e muito disso. Exemplo de chave: 'GHY5hFNqq4Ntdu=3:SUp8#/+_W!- @@^@xslN*L|N+Vn;(1xo8jNyp,au$v9Ki5*'

Como também estou usando algumas funções do Wordpress ao lado do gerenciamento de usuários, decidi continuar a carregar o núcleo do WP, mas fiz um arquivo personalizado que carrega apenas o que preciso e sem carregar os plug-ins. O novo tempo de carregamento é satisfatório (diminuiu de 1.5s na carga total do WP para 0.3s)

Eu criei um arquivo chamado 'wp-load-minimum.php' e chamo esse arquivo em vez de 'wp-blog-header.php'

Isso é interessante para o WP 3.3. Aqui está o conteúdo do arquivo, Se você achar útil:

<?php

//this stops wp-settings from load everything
define ('SHORTINIT',true);

error_reporting( E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR | E_USER_WARNING | E_RECOVERABLE_ERROR );

/** Define ABSPATH as this files directory */
define( 'ABSPATH', dirname(__FILE__) . '/' );

//WP config file
require ('wp-config.php');

if (SHORTINIT):

// Load the l18n library.
require( ABSPATH . WPINC . '/l10n.php' );

// Run the installer if WordPress is not installed.
wp_not_installed();


// Load most of WordPress.
require( ABSPATH . WPINC . '/class-wp-walker.php' );
//require( ABSPATH . WPINC . '/class-wp-ajax-response.php' );
require( ABSPATH . WPINC . '/formatting.php' );
require( ABSPATH . WPINC . '/capabilities.php' );
require( ABSPATH . WPINC . '/query.php' );
require( ABSPATH . WPINC . '/theme.php' );
require( ABSPATH . WPINC . '/user.php' );
require( ABSPATH . WPINC . '/meta.php' );
require( ABSPATH . WPINC . '/general-template.php' );
require( ABSPATH . WPINC . '/link-template.php' );
//require( ABSPATH . WPINC . '/author-template.php' );
require( ABSPATH . WPINC . '/post.php' );
//require( ABSPATH . WPINC . '/post-template.php' );
//require( ABSPATH . WPINC . '/category.php' );
//require( ABSPATH . WPINC . '/category-template.php' );
require( ABSPATH . WPINC . '/comment.php' );
//require( ABSPATH . WPINC . '/comment-template.php' );
require( ABSPATH . WPINC . '/rewrite.php' );
//require( ABSPATH . WPINC . '/feed.php' );
//require( ABSPATH . WPINC . '/bookmark.php' );
//require( ABSPATH . WPINC . '/bookmark-template.php' );
require( ABSPATH . WPINC . '/kses.php' );
require( ABSPATH . WPINC . '/cron.php' );
//require( ABSPATH . WPINC . '/deprecated.php' );
require( ABSPATH . WPINC . '/script-loader.php' );
require( ABSPATH . WPINC . '/taxonomy.php' );
//require( ABSPATH . WPINC . '/update.php' );
//require( ABSPATH . WPINC . '/canonical.php' );
require( ABSPATH . WPINC . '/shortcodes.php' );
require( ABSPATH . WPINC . '/media.php' );
require( ABSPATH . WPINC . '/http.php' );
require( ABSPATH . WPINC . '/class-http.php' );
require( ABSPATH . WPINC . '/widgets.php' );
require( ABSPATH . WPINC . '/nav-menu.php' );
//require( ABSPATH . WPINC . '/nav-menu-template.php' );
//require( ABSPATH . WPINC . '/admin-bar.php' );

// Load multisite-specific files.
if ( is_multisite() ) {
    require( ABSPATH . WPINC . '/ms-functions.php' );
    require( ABSPATH . WPINC . '/ms-default-filters.php' );
    require( ABSPATH . WPINC . '/ms-deprecated.php' );
}

// Define constants that rely on the API to obtain the default value.
// Define must-use plugin directory constants, which may be overridden in the sunrise.php drop-in.
wp_plugin_directory_constants( );

// Load must-use plugins.
/*foreach ( wp_get_mu_plugins() as $mu_plugin ) {
    include_once( $mu_plugin );
}
unset( $mu_plugin );*/

// Load network activated plugins.
if ( is_multisite() ) {
    foreach( wp_get_active_network_plugins() as $network_plugin ) {
        include_once( $network_plugin );
    }
    unset( $network_plugin );
}

do_action( 'muplugins_loaded' );

if ( is_multisite() )
    ms_cookie_constants(  );

// Define constants after multisite is loaded. Cookie-related constants may be overridden in ms_network_cookies().
wp_cookie_constants( );

// Define and enforce our SSL constants
wp_ssl_constants( );

// Create common globals.
require( ABSPATH . WPINC . '/vars.php' );

// Make taxonomies and posts available to plugins and themes.
// @plugin authors: warning: these get registered again on the init hook.
create_initial_taxonomies();
create_initial_post_types();

// Register the default theme directory root
//register_theme_directory( get_theme_root() );

// Load active plugins.
/*foreach ( wp_get_active_and_valid_plugins() as $plugin )
    include_once( $plugin );
unset( $plugin );*/

// Load pluggable functions.
require( ABSPATH . WPINC . '/pluggable.php' );
//require( ABSPATH . WPINC . '/pluggable-deprecated.php' );

// Set internal encoding.
wp_set_internal_encoding();

// Run wp_cache_postload() if object cache is enabled and the function exists.
if ( WP_CACHE && function_exists( 'wp_cache_postload' ) )
    wp_cache_postload();

do_action( 'plugins_loaded' );

// Define constants which affect functionality if not already defined.
wp_functionality_constants( );

// Add magic quotes and set up $_REQUEST ( $_GET + $_POST )
wp_magic_quotes();

do_action( 'sanitize_comment_cookies' );

/**
 * WordPress Query object
 * @global object $wp_the_query
 * @since 2.0.0
 */
$wp_the_query = new WP_Query();

/**
 * Holds the reference to @see $wp_the_query
 * Use this global for WordPress queries
 * @global object $wp_query
 * @since 1.5.0
 */
$wp_query =& $wp_the_query;

/**
 * Holds the WordPress Rewrite object for creating pretty URLs
 * @global object $wp_rewrite
 * @since 1.5.0
 */
$wp_rewrite = new WP_Rewrite();

/**
 * WordPress Object
 * @global object $wp
 * @since 2.0.0
 */
$wp = new WP();

/**
 * WordPress Widget Factory Object
 * @global object $wp_widget_factory
 * @since 2.8.0
 */
$GLOBALS['wp_widget_factory'] = new WP_Widget_Factory();

do_action( 'setup_theme' );

// Define the template related constants.
wp_templating_constants(  );

// Load the default text localization domain.
load_default_textdomain();

// Find the blog locale.
$locale = get_locale();
$locale_file = WP_LANG_DIR . "/$locale.php";
if ( ( 0 === validate_file( $locale ) ) && is_readable( $locale_file ) )
    require( $locale_file );
unset($locale_file);

// Pull in locale data after loading text domain.
require( ABSPATH . WPINC . '/locale.php' );

/**
 * WordPress Locale object for loading locale domain date and various strings.
 * @global object $wp_locale
 * @since 2.1.0
 */
$GLOBALS['wp_locale'] = new WP_Locale();

// Load the functions for the active theme, for both parent and child theme if applicable.
/*if ( ! defined( 'WP_INSTALLING' ) || 'wp-activate.php' === $pagenow ) {
    if ( TEMPLATEPATH !== STYLESHEETPATH && file_exists( STYLESHEETPATH . '/functions.php' ) )
        include( STYLESHEETPATH . '/functions.php' );
    if ( file_exists( TEMPLATEPATH . '/functions.php' ) )
        include( TEMPLATEPATH . '/functions.php' );
}*/

do_action( 'after_setup_theme' );

// Load any template functions the theme supports.
//require_if_theme_supports( 'post-thumbnails', ABSPATH . WPINC . '/post-thumbnail-template.php' );

// Set up current user.
$wp->init();

/**
 * Most of WP is loaded at this stage, and the user is authenticated. WP continues
 * to load on the init hook that follows (e.g. widgets), and many plugins instantiate
 * themselves on it for all sorts of reasons (e.g. they need a user, a taxonomy, etc.).
 *
 * If you wish to plug an action once WP is loaded, use the wp_loaded hook below.
 */
do_action( 'init' );

// Check site status
if ( is_multisite() ) {
    if ( true !== ( $file = ms_site_check() ) ) {
        require( $file );
        die();
    }
    unset($file);
}

/**
 * This hook is fired once WP, all plugins, and the theme are fully loaded and instantiated.
 *
 * AJAX requests should use wp-admin/admin-ajax.php. admin-ajax.php can handle requests for
 * users not logged in.
 *
 * @link http://codex.wordpress.org/AJAX_in_Plugins
 *
 * @since 3.0.0
 */
do_action('wp_loaded');

endif;

//require( ABSPATH . WPINC . '/pluggable.php' );

O próprio Wordpress está ativado ou desativado. Às vezes, mas isso é apenas por acaso e não por design, você pode contornar isso. Mas no seu caso, não tenho certeza se é possível.

Em vez de wp-blog-header.php você pode tentar carregar apenas as funções do WP, inclua wp-load.php . Talvez isso ajude.

Para o Wordpress 4.9: Como não posso comentar (novo usuário). A finalização (instalação única do WP) que uso para fazer is_user_logged_in() e current_user_can() work, é a seguinte. Nós require('wp-load.php') primeiro (para pular wp () em load-blog-header.php) , e obter ABSPATH constante então, manualmente inclui exatamente todas as coisas necessárias.

Usar define('SHORTINIT', true) + require('wp-load.php') + inclui manualmente:

Pageload: 1,05 sek - arquivos incluídos: 43 arquivos

Comparando: usando SOMENTE require('wp-load.php') :

Pageload: 1.35 sek - arquivos incluídos: 419 arquivos

A diferença de tempo (0.3 sek) pode ser diferente das instalações e dos mecanismos PHP, mas ao validar muitas solicitações em uma pageload, as coisas são adicionadas!

Lembre-se de usar a chamada relativa ao diretório instalado pelo WP. De um diretório de plug-in personalizado do Wordpress, dentro de um nível de subdiretório, instalação normal, um caminho deve ser como:

$wordpress = '../../../../wp-load.php';

Então:

define('SHORTINIT', true);
include_once $wordpress;

require_once ( ABSPATH . WPINC . '/class-wp-user.php' );
require_once ( ABSPATH . WPINC . '/class-wp-roles.php' );
require_once ( ABSPATH . WPINC . '/class-wp-role.php' );
require_once ( ABSPATH . WPINC . '/class-wp-session-tokens.php' );
require_once ( ABSPATH . WPINC . '/class-wp-user-meta-session-tokens.php' );
require_once ( ABSPATH . WPINC . '/formatting.php' );
require_once ( ABSPATH . WPINC . '/capabilities.php' );
//require_once ( ABSPATH . WPINC . '/query.php' ); // - might be useful
require_once ( ABSPATH . WPINC . '/user.php' );
require_once ( ABSPATH . WPINC . '/meta.php' );

wp_cookie_constants();

require_once ( ABSPATH . WPINC . '/vars.php' );
require_once ( ABSPATH . WPINC . '/kses.php' );
require_once ( ABSPATH . WPINC . '/rest-api.php' );
require_once ( ABSPATH . WPINC . '/pluggable.php' );

Depois disso, a validação do usuário é acessível. Para outra tarefa, r unning em uma ou duas solicitações , rastrear outros arquivos necessários pode não valer 0,3 sek. Ignore a constante SHORTINIT e a desordem manual.

Você pode tentar acessar a tabela diretamente. Se você conhece o sal dos arquivos de senhas, você pode fazer com que eles efetuem login através de seu próprio sistema, salve a senha você mesmo (veja como wordpress faz isso) e mantenha o controle deles por conta própria. Se você quer a capacidade de atravessar o seu próprio sistema e usar o wordpress sem re-autenticação, você poderia fazer um plugin para o wordpress que passa a sessão atual do usuário para o seu sistema.

O mais rápido que você pode obter com o WP é criar um wrapper personalizado que definirá SHORTINIT e depois carregará o núcleo. Isso fará com que a carga principal pare logo após o banco de dados ser conectado e antes que a maioria das APIs e extensões (tema e plug-ins) sejam processadas.

De lá, você pode tentar obter pelo banco de dados sozinho ou carregar seletivamente partes do núcleo que você precisa.

Esta é uma abordagem bastante desordenada, mas está tão perto da carga principal mais leve quanto as coisas ficam no WP.

Parece que já houve discussão sobre isso. Então, verifique as atualizações em: enlace

Se você quiser permitir que todos os usuários do Wordpress usem o aplicativo da web, você poderá usar o sistema de gerenciamento de usuários do Wordpress e verificar se o usuário está logado ou não.

Para verificar isso, você precisará verificar se o cookie chamado wordpress_logged_in_{some-hash} está presente. Caso contrário, redirecione o usuário para a página de login do Wordpress. A parte {some-hash} do nome do cookie é apenas uma série de letras e dígitos.