Como validar um usuário do ouside wordpress / php?

Estou trabalhando em um aplicativo ajax que será incorporado em uma página do wordpress. O aplicativo ajax troca dados com servlets em execução no tomcat. Agora os servlets precisam de uma maneira de determinar se uma solicitação vem de um usuário que está logado no wordpress. E se o usuário estiver conectado, os servlets também deverão poder determinar o ID do usuário para poder consultar o banco de dados. Se o usuário não estiver logado, a solicitação será negada.

Portanto, em outras palavras, eu preciso permitir que um servlet execute uma solicitação apenas se o usuário que causou a solicitação estiver conectado ao wordpress (versão 3.3.x). Tanto o servlet (tomcat) quanto o wordpress (apache2) são executados na mesma máquina física e compartilham o mesmo banco de dados.

Em teoria, isso poderia ser facilmente resolvido fazendo o seguinte:

1. Durante o logon do wordpress, algum token do usuário é armazenado em uma variável javascript.
2. O aplicativo ajax encaminha o token do usuário para os servlets em todas as chamadas.
3. Os servlets usam o token para consultar o wordpress se ele é válido (ou seja, se o usuário estiver logado) e executar ou negar a solicitação.

A questão é como isso pode ser implementado no lado do wordpress?
Porque, o que torna a teoria tão complicada é o fato de eu ainda não ter feito nenhuma programação php.

Primeiro, eu estava pensando em transmitir o cookie wordpress_logged_in (auth) ao servlet e deixar o servlet consultar o wordpress se o cookie de autenticação ainda é válido. Mas, ao que parece, isso não pode ser feito, pois wp_validate_auth_cookie () sempre falha, mesmo que os dados de cookie de um usuário conectado sejam passados. Uma outra solução poderia ser desenvolver um plug-in que armazene o ID da sessão e o ID do usuário em uma tabela, que poderia ser facilmente consultada pelos servlets. Ou talvez haja outra solução ...

O WordPress já possui uma API incorporada por meio de um servidor XMLRPC. Ou seja, você pode fazer uma solicitação XMLRPC a partir do seu aplicativo java e verificar um nome de usuário / senha. Infelizmente, não há como se autenticar como está.

Dito isto, é muito fácil criar o seu próprio. Basta conectar xmlrpc_methodsum filtro e adicionar o seu. A chave da matriz que você adiciona é o método xmlrpc que você chama do seu aplicativo e o valor será a função que é chamada pelo servidor XMLRPC do WordPress.

<?php
add_filter('xmlrpc_methods', 'wpse39662_add_login_method' );
/**
 * Filters the XMLRPC methods to allow just checking the login/pass of
 * a given users
 */
function wpse39662_add_login_method( $methods )
{
    $methods['wpse39662.login'] = 'wpse39662_check_login';
    return $methods;
}

E a função de retorno de chamada wpse39662_check_loginreceberia um argumento, a matriz de itens enviados ao servidor XMLRPC.

<?php
function wpse39662_check_login( $args )
{
    $username = $args[0];
    $password = $args[1];

    $user = wp_authenticate( $username, $password );

    if( is_wp_error( $user ) )
    {
        return false;
    }
    return true;
}

Aqui está tudo isso como um plugin . Com isso instalado e o XMLRPC ativado em seu site WP, você poderá fazer solicitações com algum cliente XMLRPC (tenho certeza que o Java possui um).

Aqui está o código que usei para testar o acima (cliente Python XMLRPC).

>>> import xmlrpclib as xmlrpc
>>> s = xmlrpc.ServerProxy('http://wordpress.dev/xmlrpc.php')
>>> s.wpse39662.login('admin', 'password')
True

O Wordpress (atualmente) verifica se o usuário ainda está logado, verificando um dos cookies que ele fornece no login. Ele constrói o conteúdo desse cookie fazendo um hash. Os detalhes estão na função "wp_generate_auth_cookie" em /wp-includes/pluggable.php:

function wp_generate_auth_cookie($user_id, $expiration, $scheme = 'auth') {
    $user = get_userdata($user_id);

    $pass_frag = substr($user->user_pass, 8, 4);

    $key = wp_hash($user->user_login . $pass_frag . '|' . $expiration, $scheme);
    $hash = hash_hmac('md5', $user->user_login . '|' . $expiration, $key);

    $cookie = $user->user_login . '|' . $expiration . '|' . $hash;

    return apply_filters('auth_cookie', $cookie, $user_id, $expiration, $scheme);
}

Você pode recriar esse algoritmo (usando essa e outras funções auth_cookie) em seu código Java para fazer as mesmas verificações. O JS pode ser usado para garantir que o cookie seja enviado ao seu servlet.

Caso contrário, XMLRPC pode ser uma boa ideia. Você pode escrever um novo método (como explicado em outra solução aqui) para validar o cookie de autenticação (em vez de validar o nome de usuário e a senha como normalmente é feito).

Obtenha o plug-in Exec-PHP e faça uma página do WordPress (não uma postagem) com um bom link permanente ( http://mysite/user_id/) e o código na get_current_user_id()referência da API :

<?php
$user_id = get_current_user_id();
if ($user_id == 0) {
    echo 'You are currently not logged in.';
} else {
    echo 'You are logged in as user '.$user_id.'.';
}
?>

Você pode então extrair os cookies que o cliente envia e colocá-los em uma GETsolicitação http://127.0.0.1/user_id/. Então você saberá se o usuário está logado e qual é o seu ID de usuário.

Você pode fazer algo assim nas páginas não-wp:

<?php
require('./wp-blog-header.php');
// Make sure ^ points to the root of your WP installation

if ( is_user_logged_in() ) {
   // Perform your request here
}

?>

Este é um plug-in WordPress de um arquivo que faz o trabalho:

function yournamespace_validateAuthCookie($cookie, $scheme = 'logged_in') {
    return wp_validate_auth_cookie($cookie, $scheme);
}

function yournamespace_new_xmlrpc_methods($methods) {
    $methods['yournamespace.validateAuthCookie'] = 'yournamespace_validateAuthCookie';
    return $methods;
}
add_filter('xmlrpc_methods', 'yournamespace_new_xmlrpc_methods');

Ele basicamente expõe um novo método XML-RPC com o qual você pode solicitar ao WordPress para validar o wordpress_logged_in_...cookie.

Você precisa escrever algum código para consultar esse método e transmitir o valor do wordpress_logged_in_...cookie.

Este método retornará false(se o cookie não validar) ou o ID do usuário se a validação for bem-sucedida.