¿Hay alguna forma de usar los usuarios de Wordpress pero sin cargar todo el núcleo de Wordpress?

Si tuviera que hacer esto, usaría mi propia cookie para determinar el inicio de sesión y solo cargaría WordPress para verificarlo cuando fuera necesario.

La cookie wordpress_logged_in_ {some-hash} se puede usar para determinar el usuario, y WordPress la usa para determinar la misma. No puede volver a implementar eso fácilmente, pero puede usarlo sin cargar WordPress en múltiples solicitudes.

Por ejemplo, aquí está mi hash de cookies (datos totalmente inventados, pero realistas):

key: wordpress_logged_in_1234567890abcdef1234567890abcdef
value: admin|1234567890|abcdef1234567890abcdef1234567890

La forma en que WordPress sabe que la cookie es válida es irrelevante, todo lo que necesitas saber es si es válida una vez, luego la firmas con un secreto.

Entonces, la primera vez, el usuario no está probado todavía. Cargas wp-load.php y WP valida la cookie e inicia sesión en el usuario. Ahora haces todo lo posible para demostrarte que el usuario ha iniciado sesión y luego configuras tu propia cookie. La clave puede ser cualquier cosa personalizada para usted, el valor que convierte en un resumen de mensaje con una clave secreta mediante la función 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' );

Obtendrás gibberish, que les envías usando setcookie (). En futuras solicitudes, le enviarán esta cookie a usted. Puede verificar eso primero y validarlo usando la misma función de hash y clave secreta.

Solo tú puedes generar el hash porque solo tú conoces la clave secreta. Entonces, si envían de vuelta un hash válido que también coincide con lo que envían para su cookie de WP, entonces sabrá que han sido validados con WP, a través de su código, antes, y puede obtener el nombre de usuario directamente de ese valor (es el primero parte de la cookie, obviamente). Entonces no tienes que cargar WP.

La clave secreta, BTW, debe ser larga y aleatoria . No es una contraseña corta. No es una palabra de diccionario. Sólo grandes galimatías sin sentido. Línea de ruido, y mucho. Ejemplo de clave: 'GHY5hFNqq4Ntdu=3:SUp8#/+_W!- @@^@xslN*L|N+Vn;(1xo8jNyp,au$v9Ki5*'

Como también estoy usando algunas funciones de Wordpress junto a la administración de usuarios, decidí continuar cargando el núcleo de WP, pero hice un archivo personalizado que carga solo lo que necesito y sin cargar los complementos. El nuevo tiempo de carga es satisfactorio (disminuyó de 1.5s en la carga completa de WP a 0.3s)

He creado un archivo llamado 'wp-load-minimum.php' y llamo a este archivo en lugar de 'wp-blog-header.php'

Esto está funcionando para WP 3.3. Aquí está el contenido del archivo, si lo encuentra ú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' );

Wordpress solo está activado o desactivado. A veces, pero eso es solo por casualidad y no por diseño, puedes solucionarlo. Pero en tu caso, no estoy realmente seguro de que sea posible.

En lugar de wp-blog-header.php puede intentar cargar solo las funciones WP, incluya wp-load.php en su lugar. Tal vez eso ayude.

Para Wordpress 4.9: Como no puedo comentar (nuevo usuario). La versión final (instalación de WP individual) que utilizo para hacer que is_user_logged_in() y current_user_can() funcione, es la siguiente a continuación. Nosotros require('wp-load.php') primero (para omitir wp () en load-blog-header.php) , y obtenemos ABSPATH constant, luego manualmente incluye exactamente todas las cosas necesarias.

El uso manual de define('SHORTINIT', true) + require('wp-load.php') + incluye:

Pageload: 1.05 sek - archivos incluidos: 43 archivos

Comparando: utilizando SOLAMENTE require('wp-load.php') :

Pageload: 1.35 sek - archivos incluidos: 419 archivos

La diferencia de tiempo (0,3 sek) puede diferir de las instalaciones y los motores PHP, pero al validar muchas solicitudes en una carga de página, ¡las cosas se acumulan!

Recuerde usar la llamada relativa a WP instalado dir. Desde un directorio de plugin personalizado de Wordpress, dentro de un nivel de subdirección, instalación normal, una ruta debería ser como:

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

Entonces:

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' );

Después de esto, la validación del usuario es accesible. Para otras tareas, r hasta que se cumpla una o dos solicitudes , el rastreo de otros archivos necesarios puede no valer 0,3 sek. Omita la constante SHORTINIT y el desorden manual.

Puedes intentar acceder a la tabla directamente. Si conoce la sal de los archivos de contraseñas, puede hacer que inicien sesión a través de su propio sistema, ingrese la contraseña usted mismo (mire cómo lo hace wordpress) y manténgalos al tanto. Si desea tener la capacidad de atravesar su propio sistema y wordpress sin volver a autenticarse, puede crear un plugin para wordpress que pase la sesión de los usuarios actuales a su sistema.

Lo más rápido que puede obtener con WP es crear un contenedor personalizado que definirá SHORTINIT y luego cargará el núcleo. Esto hará que la carga principal se detenga justo después de que se conecte la base de datos y antes de que se procese la mayoría de las API y extensiones (tema y complementos).

Desde allí puede intentar acceder solo a la base de datos o cargar selectivamente partes del núcleo que necesita.

Este es un enfoque bastante desordenado, pero es lo más parecido a una carga de núcleo más liviana que las cosas se ponen en WP.

Parece que ya hubo discusión sobre eso. Por lo tanto, consulte las actualizaciones en: enlace

Si solo desea permitir que todos los usuarios de Wordpress utilicen la aplicación web, puede usar el sistema de administración de usuarios de Wordpress y verificar si el usuario ha iniciado sesión o no.

Para verificar esto, deberá comprobar si la cookie denominada wordpress_logged_in_{some-hash} está presente. Si no, redirige al usuario a la página de inicio de sesión de Wordpress. La parte {some-hash} del nombre de la cookie es solo una serie de letras y dígitos.