jetpack / modules / sso.php

sso.php in Jetpack – WP Security, Backup, Speed, & Growth 6.7.4, at modules/sso.php

1,093 lines 33.3 KB

Raw Download Zip

1	<?php
2	require_once( JETPACK__PLUGIN_DIR . 'modules/sso/class.jetpack-sso-helpers.php' );
3	require_once( JETPACK__PLUGIN_DIR . 'modules/sso/class.jetpack-sso-notices.php' );
4
5	/**
6	* Module Name: Secure Sign On
7	* Module Description: Allow users to log into this site using WordPress.com accounts
8	* Jumpstart Description: Lets you log in to all your Jetpack-enabled sites with one click using your WordPress.com account.
9	* Sort Order: 30
10	* Recommendation Order: 5
11	* First Introduced: 2.6
12	* Requires Connection: Yes
13	* Auto Activate: No
14	* Module Tags: Developers
15	* Feature: Security, Jumpstart
16	* Additional Search Queries: sso, single sign on, login, log in
17	*/
18
19	class Jetpack_SSO {
20	static $instance = null;
21
22	private function __construct() {
23
24	self::$instance = $this;
25
26	add_action( 'admin_init', array( $this, 'maybe_authorize_user_after_sso' ), 1 );
27	add_action( 'admin_init', array( $this, 'register_settings' ) );
28	add_action( 'login_init', array( $this, 'login_init' ) );
29	add_action( 'delete_user', array( $this, 'delete_connection_for_user' ) );
30	add_filter( 'jetpack_xmlrpc_methods', array( $this, 'xmlrpc_methods' ) );
31	add_action( 'init', array( $this, 'maybe_logout_user' ), 5 );
32	add_action( 'jetpack_modules_loaded', array( $this, 'module_configure_button' ) );
33	add_action( 'login_form_logout', array( $this, 'store_wpcom_profile_cookies_on_logout' ) );
34	add_action( 'jetpack_unlinked_user', array( $this, 'delete_connection_for_user') );
35	add_action( 'wp_login', array( 'Jetpack_SSO', 'clear_cookies_after_login' ) );
36
37	// Adding this action so that on login_init, the action won't be sanitized out of the $action global.
38	add_action( 'login_form_jetpack-sso', '__return_true' );
39	}
40
41	/**
42	* Returns the single instance of the Jetpack_SSO object
43	*
44	* @since 2.8
45	* @return Jetpack_SSO
46	**/
47	public static function get_instance() {
48	if ( ! is_null( self::$instance ) ) {
49	return self::$instance;
50	}
51
52	return self::$instance = new Jetpack_SSO;
53	}
54
55	/**
56	* Add configure button and functionality to the module card on the Jetpack screen
57	**/
58	public static function module_configure_button() {
59	Jetpack::enable_module_configurable( __FILE__ );
60	Jetpack::module_configuration_load( __FILE__, array( __CLASS__, 'module_configuration_load' ) );
61	Jetpack::module_configuration_head( __FILE__, array( __CLASS__, 'module_configuration_head' ) );
62	Jetpack::module_configuration_screen( __FILE__, array( __CLASS__, 'module_configuration_screen' ) );
63	}
64
65	public static function module_configuration_load() {}
66
67	public static function module_configuration_head() {}
68
69	public static function module_configuration_screen() {
70	?>
71	<form method="post" action="options.php">
72	<?php settings_fields( 'jetpack-sso' ); ?>
73	<?php do_settings_sections( 'jetpack-sso' ); ?>
74	<?php submit_button(); ?>
75	</form>
76	<?php
77	}
78
79	/**
80	* If jetpack_force_logout == 1 in current user meta the user will be forced
81	* to logout and reauthenticate with the site.
82	**/
83	public function maybe_logout_user() {
84	global $current_user;
85
86	if ( 1 == $current_user->jetpack_force_logout ) {
87	delete_user_meta( $current_user->ID, 'jetpack_force_logout' );
88	self::delete_connection_for_user( $current_user->ID );
89	wp_logout();
90	wp_safe_redirect( wp_login_url() );
91	exit;
92	}
93	}
94
95	/**
96	* Adds additional methods the WordPress xmlrpc API for handling SSO specific features
97	*
98	* @param array $methods
99	* @return array
100	**/
101	public function xmlrpc_methods( $methods ) {
102	$methods['jetpack.userDisconnect'] = array( $this, 'xmlrpc_user_disconnect' );
103	return $methods;
104	}
105
106	/**
107	* Marks a user's profile for disconnect from WordPress.com and forces a logout
108	* the next time the user visits the site.
109	**/
110	public function xmlrpc_user_disconnect( $user_id ) {
111	$user_query = new WP_User_Query(
112	array(
113	'meta_key' => 'wpcom_user_id',
114	'meta_value' => $user_id,
115	)
116	);
117	$user = $user_query->get_results();
118	$user = $user[0];
119
120	if ( $user instanceof WP_User ) {
121	$user = wp_set_current_user( $user->ID );
122	update_user_meta( $user->ID, 'jetpack_force_logout', '1' );
123	self::delete_connection_for_user( $user->ID );
124	return true;
125	}
126	return false;
127	}
128
129	/**
130	* Enqueues scripts and styles necessary for SSO login.
131	*/
132	public function login_enqueue_scripts() {
133	global $action;
134
135	if ( ! Jetpack_SSO_Helpers::display_sso_form_for_action( $action ) ) {
136	return;
137	}
138
139	if ( is_rtl() ) {
140	wp_enqueue_style( 'jetpack-sso-login', plugins_url( 'modules/sso/jetpack-sso-login-rtl.css', JETPACK__PLUGIN_FILE ), array( 'login', 'genericons' ), JETPACK__VERSION );
141	} else {
142	wp_enqueue_style( 'jetpack-sso-login', plugins_url( 'modules/sso/jetpack-sso-login.css', JETPACK__PLUGIN_FILE ), array( 'login', 'genericons' ), JETPACK__VERSION );
143	}
144
145	wp_enqueue_script( 'jetpack-sso-login', plugins_url( 'modules/sso/jetpack-sso-login.js', JETPACK__PLUGIN_FILE ), array( 'jquery' ), JETPACK__VERSION );
146	}
147
148	/**
149	* Adds Jetpack SSO classes to login body
150	*
151	* @param array $classes Array of classes to add to body tag
152	* @return array Array of classes to add to body tag
153	*/
154	public function login_body_class( $classes ) {
155	global $action;
156
157	if ( ! Jetpack_SSO_Helpers::display_sso_form_for_action( $action ) ) {
158	return $classes;
159	}
160
161	// Always add the jetpack-sso class so that we can add SSO specific styling even when the SSO form isn't being displayed.
162	$classes[] = 'jetpack-sso';
163
164	if ( ! Jetpack::is_staging_site() ) {
165	/**
166	* Should we show the SSO login form?
167	*
168	* $_GET['jetpack-sso-default-form'] is used to provide a fallback in case JavaScript is not enabled.
169	*
170	* The default_to_sso_login() method allows us to dynamically decide whether we show the SSO login form or not.
171	* The SSO module uses the method to display the default login form if we can not find a user to log in via SSO.
172	* But, the method could be filtered by a site admin to always show the default login form if that is preferred.
173	*/
174	if ( empty( $_GET['jetpack-sso-show-default-form'] ) && Jetpack_SSO_Helpers::show_sso_login() ) {
175	$classes[] = 'jetpack-sso-form-display';
176	}
177	}
178
179	return $classes;
180	}
181
182	public function print_inline_admin_css() {
183	?>
184	<style>
185	.jetpack-sso .message {
186	margin-top: 20px;
187	}
188
189	.jetpack-sso #login .message:first-child,
190	.jetpack-sso #login h1 + .message {
191	margin-top: 0;
192	}
193	</style>
194	<?php
195	}
196
197	/**
198	* Adds settings fields to Settings > General > Secure Sign On that allows users to
199	* turn off the login form on wp-login.php
200	*
201	* @since 2.7
202	**/
203	public function register_settings() {
204
205	add_settings_section(
206	'jetpack_sso_settings',
207	__( 'Secure Sign On' , 'jetpack' ),
208	'__return_false',
209	'jetpack-sso'
210	);
211
212	/*
213	* Settings > General > Secure Sign On
214	* Require two step authentication
215	*/
216	register_setting(
217	'jetpack-sso',
218	'jetpack_sso_require_two_step',
219	array( $this, 'validate_jetpack_sso_require_two_step' )
220	);
221
222	add_settings_field(
223	'jetpack_sso_require_two_step',
224	'', // __( 'Require Two-Step Authentication' , 'jetpack' ),
225	array( $this, 'render_require_two_step' ),
226	'jetpack-sso',
227	'jetpack_sso_settings'
228	);
229
230	/*
231	* Settings > General > Secure Sign On
232	*/
233	register_setting(
234	'jetpack-sso',
235	'jetpack_sso_match_by_email',
236	array( $this, 'validate_jetpack_sso_match_by_email' )
237	);
238
239	add_settings_field(
240	'jetpack_sso_match_by_email',
241	'', // __( 'Match by Email' , 'jetpack' ),
242	array( $this, 'render_match_by_email' ),
243	'jetpack-sso',
244	'jetpack_sso_settings'
245	);
246	}
247
248	/**
249	* Builds the display for the checkbox allowing user to require two step
250	* auth be enabled on WordPress.com accounts before login. Displays in Settings > General
251	*
252	* @since 2.7
253	**/
254	public function render_require_two_step() {
255	?>
256	<label>
257	<input
258	type="checkbox"
259	name="jetpack_sso_require_two_step"
260	<?php checked( Jetpack_SSO_Helpers::is_two_step_required() ); ?>
261	<?php disabled( Jetpack_SSO_Helpers::is_require_two_step_checkbox_disabled() ); ?>
262	>
263	<?php esc_html_e( 'Require Two-Step Authentication' , 'jetpack' ); ?>
264	</label>
265	<?php
266	}
267
268	/**
269	* Validate the require two step checkbox in Settings > General
270	*
271	* @since 2.7
272	* @return boolean
273	**/
274	public function validate_jetpack_sso_require_two_step( $input ) {
275	return ( ! empty( $input ) ) ? 1 : 0;
276	}
277
278	/**
279	* Builds the display for the checkbox allowing the user to allow matching logins by email
280	* Displays in Settings > General
281	*
282	* @since 2.9
283	**/
284	public function render_match_by_email() {
285	?>
286	<label>
287	<input
288	type="checkbox"
289	name="jetpack_sso_match_by_email"
290	<?php checked( Jetpack_SSO_Helpers::match_by_email() ); ?>
291	<?php disabled( Jetpack_SSO_Helpers::is_match_by_email_checkbox_disabled() ); ?>
292	>
293	<?php esc_html_e( 'Match by Email', 'jetpack' ); ?>
294	</label>
295	<?php
296	}
297
298	/**
299	* Validate the match by email check in Settings > General
300	*
301	* @since 2.9
302	* @return boolean
303	**/
304	public function validate_jetpack_sso_match_by_email( $input ) {
305	return ( ! empty( $input ) ) ? 1 : 0;
306	}
307
308	/**
309	* Checks to determine if the user wants to login on wp-login
310	*
311	* This function mostly exists to cover the exceptions to login
312	* that may exist as other parameters to $_GET[action] as $_GET[action]
313	* does not have to exist. By default WordPress assumes login if an action
314	* is not set, however this may not be true, as in the case of logout
315	* where $_GET[loggedout] is instead set
316	*
317	* @return boolean
318	**/
319	private function wants_to_login() {
320	$wants_to_login = false;
321
322	// Cover default WordPress behavior
323	$action = isset( $_REQUEST['action'] ) ? $_REQUEST['action'] : 'login';
324
325	// And now the exceptions
326	$action = isset( $_GET['loggedout'] ) ? 'loggedout' : $action;
327
328	if ( Jetpack_SSO_Helpers::display_sso_form_for_action( $action ) ) {
329	$wants_to_login = true;
330	}
331
332	return $wants_to_login;
333	}
334
335	function login_init() {
336	global $action;
337
338	if ( Jetpack_SSO_Helpers::should_hide_login_form() ) {
339	/**
340	* Since the default authenticate filters fire at priority 20 for checking username and password,
341	* let's fire at priority 30. wp_authenticate_spam_check is fired at priority 99, but since we return a
342	* WP_Error in disable_default_login_form, then we won't trigger spam processing logic.
343	*/
344	add_filter( 'authenticate', array( 'Jetpack_SSO_Notices', 'disable_default_login_form' ), 30 );
345
346	/**
347	* Filter the display of the disclaimer message appearing when default WordPress login form is disabled.
348	*
349	* @module sso
350	*
351	* @since 2.8.0
352	*
353	* @param bool true Should the disclaimer be displayed. Default to true.
354	*/
355	$display_sso_disclaimer = apply_filters( 'jetpack_sso_display_disclaimer', true );
356	if ( $display_sso_disclaimer ) {
357	add_filter( 'login_message', array( 'Jetpack_SSO_Notices', 'msg_login_by_jetpack' ) );
358	}
359	}
360
361	if ( 'jetpack-sso' === $action ) {
362	if ( isset( $_GET['result'], $_GET['user_id'], $_GET['sso_nonce'] ) && 'success' == $_GET['result'] ) {
363	$this->handle_login();
364	$this->display_sso_login_form();
365	} else {
366	if ( Jetpack::is_staging_site() ) {
367	add_filter( 'login_message', array( 'Jetpack_SSO_Notices', 'sso_not_allowed_in_staging' ) );
368	} else {
369	// Is it wiser to just use wp_redirect than do this runaround to wp_safe_redirect?
370	add_filter( 'allowed_redirect_hosts', array( 'Jetpack_SSO_Helpers', 'allowed_redirect_hosts' ) );
371	$reauth = ! empty( $_GET['force_reauth'] );
372	$sso_url = $this->get_sso_url_or_die( $reauth );
373	JetpackTracking::record_user_event( 'sso_login_redirect_success' );
374	wp_safe_redirect( $sso_url );
375	exit;
376	}
377	}
378	} else if ( Jetpack_SSO_Helpers::display_sso_form_for_action( $action ) ) {
379
380	// Save cookies so we can handle redirects after SSO
381	$this->save_cookies();
382
383	/**
384	* Check to see if the site admin wants to automagically forward the user
385	* to the WordPress.com login page AND that the request to wp-login.php
386	* is not something other than login (Like logout!)
387	*/
388	if ( Jetpack_SSO_Helpers::bypass_login_forward_wpcom() && $this->wants_to_login() ) {
389	add_filter( 'allowed_redirect_hosts', array( 'Jetpack_SSO_Helpers', 'allowed_redirect_hosts' ) );
390	$reauth = ! empty( $_GET['force_reauth'] );
391	$sso_url = $this->get_sso_url_or_die( $reauth );
392	JetpackTracking::record_user_event( 'sso_login_redirect_bypass_success' );
393	wp_safe_redirect( $sso_url );
394	exit;
395	}
396
397	$this->display_sso_login_form();
398	}
399	}
400
401	/**
402	* Ensures that we can get a nonce from WordPress.com via XML-RPC before setting
403	* up the hooks required to display the SSO form.
404	*/
405	public function display_sso_login_form() {
406	add_filter( 'login_body_class', array( $this, 'login_body_class' ) );
407	add_action( 'login_head', array( $this, 'print_inline_admin_css' ) );
408
409	if ( Jetpack::is_staging_site() ) {
410	add_filter( 'login_message', array( 'Jetpack_SSO_Notices', 'sso_not_allowed_in_staging' ) );
411	return;
412	}
413
414	$sso_nonce = self::request_initial_nonce();
415	if ( is_wp_error( $sso_nonce ) ) {
416	return;
417	}
418
419	add_action( 'login_form', array( $this, 'login_form' ) );
420	add_action( 'login_enqueue_scripts', array( $this, 'login_enqueue_scripts' ) );
421	}
422
423	/**
424	* Conditionally save the redirect_to url as a cookie.
425	*
426	* @since 4.6.0 Renamed to save_cookies from maybe_save_redirect_cookies
427	*/
428	public static function save_cookies() {
429	if ( headers_sent() ) {
430	return new WP_Error( 'headers_sent', __( 'Cannot deal with cookie redirects, as headers are already sent.', 'jetpack' ) );
431	}
432
433	setcookie(
434	'jetpack_sso_original_request',
435	esc_url_raw( set_url_scheme( $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'] ) ),
436	time() + HOUR_IN_SECONDS,
437	COOKIEPATH,
438	COOKIE_DOMAIN,
439	is_ssl(),
440	true
441	);
442
443	if ( ! empty( $_GET['redirect_to'] ) ) {
444	// If we have something to redirect to
445	$url = esc_url_raw( $_GET['redirect_to'] );
446	setcookie( 'jetpack_sso_redirect_to', $url, time() + HOUR_IN_SECONDS, COOKIEPATH, COOKIE_DOMAIN, is_ssl(), true );
447	} elseif ( ! empty( $_COOKIE['jetpack_sso_redirect_to'] ) ) {
448	// Otherwise, if it's already set, purge it.
449	setcookie( 'jetpack_sso_redirect_to', ' ', time() - YEAR_IN_SECONDS, COOKIEPATH, COOKIE_DOMAIN );
450	}
451	}
452
453	/**
454	* Outputs the Jetpack SSO button and description as well as the toggle link
455	* for switching between Jetpack SSO and default login.
456	*/
457	function login_form() {
458	$site_name = get_bloginfo( 'name' );
459	if ( ! $site_name ) {
460	$site_name = get_bloginfo( 'url' );
461	}
462
463	$display_name = ! empty( $_COOKIE[ 'jetpack_sso_wpcom_name_' . COOKIEHASH ] )
464	? $_COOKIE[ 'jetpack_sso_wpcom_name_' . COOKIEHASH ]
465	: false;
466	$gravatar = ! empty( $_COOKIE[ 'jetpack_sso_wpcom_gravatar_' . COOKIEHASH ] )
467	? $_COOKIE[ 'jetpack_sso_wpcom_gravatar_' . COOKIEHASH ]
468	: false;
469
470	?>
471	<div id="jetpack-sso-wrap">
472	<?php if ( $display_name && $gravatar ) : ?>
473	<div id="jetpack-sso-wrap__user">
474	<img width="72" height="72" src="<?php echo esc_html( $gravatar ); ?>" />
475
476	<h2>
477	<?php
478	echo wp_kses(
479	sprintf( __( 'Log in as <span>%s</span>', 'jetpack' ), esc_html( $display_name ) ),
480	array( 'span' => true )
481	);
482	?>
483	</h2>
484	</div>
485
486	<?php endif; ?>
487
488
489	<div id="jetpack-sso-wrap__action">
490	<?php echo $this->build_sso_button( array(), 'is_primary' ); ?>
491
492	<?php if ( $display_name && $gravatar ) : ?>
493	<a rel="nofollow" class="jetpack-sso-wrap__reauth" href="<?php echo esc_url( $this->build_sso_button_url( array( 'force_reauth' => '1' ) ) ); ?>">
494	<?php esc_html_e( 'Log in as a different WordPress.com user', 'jetpack' ); ?>
495	</a>
496	<?php else : ?>
497	<p>
498	<?php
499	echo esc_html(
500	sprintf(
501	__( 'You can now save time spent logging in by connecting your WordPress.com account to %s.', 'jetpack' ),
502	esc_html( $site_name )
503	)
504	);
505	?>
506	</p>
507	<?php endif; ?>
508	</div>
509
510	<?php if ( ! Jetpack_SSO_Helpers::should_hide_login_form() ) : ?>
511	<div class="jetpack-sso-or">
512	<span><?php esc_html_e( 'Or', 'jetpack' ); ?></span>
513	</div>
514
515	<a href="<?php echo esc_url( add_query_arg( 'jetpack-sso-show-default-form', '1' ) ); ?>" class="jetpack-sso-toggle wpcom">
516	<?php
517	esc_html_e( 'Log in with username and password', 'jetpack' )
518	?>
519	</a>
520
521	<a href="<?php echo esc_url( add_query_arg( 'jetpack-sso-show-default-form', '0' ) ); ?>" class="jetpack-sso-toggle default">
522	<?php
523	esc_html_e( 'Log in with WordPress.com', 'jetpack' )
524	?>
525	</a>
526	<?php endif; ?>
527	</div>
528	<?php
529	}
530
531	/**
532	* Clear the cookies that store the profile information for the last
533	* WPCOM user to connect.
534	*/
535	static function clear_wpcom_profile_cookies() {
536	if ( isset( $_COOKIE[ 'jetpack_sso_wpcom_name_' . COOKIEHASH ] ) ) {
537	setcookie(
538	'jetpack_sso_wpcom_name_' . COOKIEHASH,
539	' ',
540	time() - YEAR_IN_SECONDS,
541	COOKIEPATH,
542	COOKIE_DOMAIN,
543	is_ssl()
544	);
545	}
546
547	if ( isset( $_COOKIE[ 'jetpack_sso_wpcom_gravatar_' . COOKIEHASH ] ) ) {
548	setcookie(
549	'jetpack_sso_wpcom_gravatar_' . COOKIEHASH,
550	' ',
551	time() - YEAR_IN_SECONDS,
552	COOKIEPATH,
553	COOKIE_DOMAIN,
554	is_ssl()
555	);
556	}
557	}
558
559	/**
560	* Clear cookies that are no longer needed once the user has logged in.
561	*
562	* @since 4.8.0
563	*/
564	static function clear_cookies_after_login() {
565	self::clear_wpcom_profile_cookies();
566	if ( isset( $_COOKIE[ 'jetpack_sso_nonce' ] ) ) {
567	setcookie(
568	'jetpack_sso_nonce',
569	' ',
570	time() - YEAR_IN_SECONDS,
571	COOKIEPATH,
572	COOKIE_DOMAIN,
573	is_ssl()
574	);
575	}
576
577	if ( isset( $_COOKIE[ 'jetpack_sso_original_request' ] ) ) {
578	setcookie(
579	'jetpack_sso_original_request',
580	' ',
581	time() - YEAR_IN_SECONDS,
582	COOKIEPATH,
583	COOKIE_DOMAIN,
584	is_ssl()
585	);
586	}
587
588	if ( isset( $_COOKIE[ 'jetpack_sso_redirect_to' ] ) ) {
589	setcookie(
590	'jetpack_sso_redirect_to',
591	' ',
592	time() - YEAR_IN_SECONDS,
593	COOKIEPATH,
594	COOKIE_DOMAIN,
595	is_ssl()
596	);
597	}
598	}
599
600	static function delete_connection_for_user( $user_id ) {
601	if ( ! $wpcom_user_id = get_user_meta( $user_id, 'wpcom_user_id', true ) ) {
602	return;
603	}
604	Jetpack::load_xml_rpc_client();
605	$xml = new Jetpack_IXR_Client( array(
606	'wpcom_user_id' => $user_id,
607	) );
608	$xml->query( 'jetpack.sso.removeUser', $wpcom_user_id );
609
610	if ( $xml->isError() ) {
611	return false;
612	}
613
614	// Clean up local data stored for SSO
615	delete_user_meta( $user_id, 'wpcom_user_id' );
616	delete_user_meta( $user_id, 'wpcom_user_data' );
617	self::clear_wpcom_profile_cookies();
618
619	return $xml->getResponse();
620	}
621
622	static function request_initial_nonce() {
623	$nonce = ! empty( $_COOKIE[ 'jetpack_sso_nonce' ] )
624	? $_COOKIE[ 'jetpack_sso_nonce' ]
625	: false;
626
627	if ( ! $nonce ) {
628	Jetpack::load_xml_rpc_client();
629	$xml = new Jetpack_IXR_Client( array(
630	'user_id' => get_current_user_id(),
631	) );
632	$xml->query( 'jetpack.sso.requestNonce' );
633
634	if ( $xml->isError() ) {
635	return new WP_Error( $xml->getErrorCode(), $xml->getErrorMessage() );
636	}
637
638	$nonce = $xml->getResponse();
639
640	setcookie(
641	'jetpack_sso_nonce',
642	$nonce,
643	time() + ( 10 * MINUTE_IN_SECONDS ),
644	COOKIEPATH,
645	COOKIE_DOMAIN,
646	is_ssl()
647	);
648	}
649
650	return sanitize_key( $nonce );
651	}
652
653	/**
654	* The function that actually handles the login!
655	*/
656	function handle_login() {
657	$wpcom_nonce = sanitize_key( $_GET['sso_nonce'] );
658	$wpcom_user_id = (int) $_GET['user_id'];
659
660	Jetpack::load_xml_rpc_client();
661	$xml = new Jetpack_IXR_Client( array(
662	'user_id' => get_current_user_id(),
663	) );
664	$xml->query( 'jetpack.sso.validateResult', $wpcom_nonce, $wpcom_user_id );
665
666	$user_data = $xml->isError() ? false : $xml->getResponse();
667	if ( empty( $user_data ) ) {
668	add_filter( 'jetpack_sso_default_to_sso_login', '__return_false' );
669	add_filter( 'login_message', array( 'Jetpack_SSO_Notices', 'error_invalid_response_data' ) );
670	return;
671	}
672
673	$user_data = (object) $user_data;
674	$user = null;
675
676	/**
677	* Fires before Jetpack's SSO modifies the log in form.
678	*
679	* @module sso
680	*
681	* @since 2.6.0
682	*
683	* @param object $user_data WordPress.com User information.
684	*/
685	do_action( 'jetpack_sso_pre_handle_login', $user_data );
686
687	if ( Jetpack_SSO_Helpers::is_two_step_required() && 0 === (int) $user_data->two_step_enabled ) {
688	$this->user_data = $user_data;
689
690	JetpackTracking::record_user_event( 'sso_login_failed', array(
691	'error_message' => 'error_msg_enable_two_step'
692	) );
693
694	/** This filter is documented in core/src/wp-includes/pluggable.php */
695	do_action( 'wp_login_failed', $user_data->login );
696	add_filter( 'login_message', array( 'Jetpack_SSO_Notices', 'error_msg_enable_two_step' ) );
697	return;
698	}
699
700	$user_found_with = '';
701	if ( empty( $user ) && isset( $user_data->external_user_id ) ) {
702	$user_found_with = 'external_user_id';
703	$user = get_user_by( 'id', intval( $user_data->external_user_id ) );
704	if ( $user ) {
705	update_user_meta( $user->ID, 'wpcom_user_id', $user_data->ID );
706	}
707	}
708
709	// If we don't have one by wpcom_user_id, try by the email?
710	if ( empty( $user ) && Jetpack_SSO_Helpers::match_by_email() ) {
711	$user_found_with = 'match_by_email';
712	$user = get_user_by( 'email', $user_data->email );
713	if ( $user ) {
714	update_user_meta( $user->ID, 'wpcom_user_id', $user_data->ID );
715	}
716	}
717
718	// If we've still got nothing, create the user.
719	$new_user_override_role = false;
720	if ( empty( $user ) && ( get_option( 'users_can_register' ) \|\| ( $new_user_override_role = Jetpack_SSO_Helpers::new_user_override( $user_data ) ) ) ) {
721	/**
722	* If not matching by email we still need to verify the email does not exist
723	* or this blows up
724	*
725	* If match_by_email is true, we know the email doesn't exist, as it would have
726	* been found in the first pass. If get_user_by( 'email' ) doesn't find the
727	* user, then we know that email is unused, so it's safe to add.
728	*/
729	if ( Jetpack_SSO_Helpers::match_by_email() \|\| ! get_user_by( 'email', $user_data->email ) ) {
730
731	if ( $new_user_override_role ) {
732	$user_data->role = $new_user_override_role;
733	}
734
735	$user = Jetpack_SSO_Helpers::generate_user( $user_data );
736	if ( ! $user ) {
737	JetpackTracking::record_user_event( 'sso_login_failed', array(
738	'error_message' => 'could_not_create_username'
739	) );
740	add_filter( 'login_message', array( 'Jetpack_SSO_Notices', 'error_unable_to_create_user' ) );
741	return;
742	}
743
744	$user_found_with = $new_user_override_role
745	? 'user_created_new_user_override'
746	: 'user_created_users_can_register';
747	} else {
748	JetpackTracking::record_user_event( 'sso_login_failed', array(
749	'error_message' => 'error_msg_email_already_exists'
750	) );
751
752	$this->user_data = $user_data;
753	add_action( 'login_message', array( 'Jetpack_SSO_Notices', 'error_msg_email_already_exists' ) );
754	return;
755	}
756	}
757
758	/**
759	* Fires after we got login information from WordPress.com.
760	*
761	* @module sso
762	*
763	* @since 2.6.0
764	*
765	* @param array $user Local User information.
766	* @param object $user_data WordPress.com User Login information.
767	*/
768	do_action( 'jetpack_sso_handle_login', $user, $user_data );
769
770	if ( $user ) {
771	// Cache the user's details, so we can present it back to them on their user screen
772	update_user_meta( $user->ID, 'wpcom_user_data', $user_data );
773
774	add_filter( 'auth_cookie_expiration', array( 'Jetpack_SSO_Helpers', 'extend_auth_cookie_expiration_for_sso' ) );
775	wp_set_auth_cookie( $user->ID, true );
776	remove_filter( 'auth_cookie_expiration', array( 'Jetpack_SSO_Helpers', 'extend_auth_cookie_expiration_for_sso' ) );
777
778	/** This filter is documented in core/src/wp-includes/user.php */
779	do_action( 'wp_login', $user->user_login, $user );
780
781	wp_set_current_user( $user->ID );
782
783	$_request_redirect_to = isset( $_REQUEST['redirect_to'] ) ? esc_url_raw( $_REQUEST['redirect_to'] ) : '';
784	$redirect_to = user_can( $user, 'edit_posts' ) ? admin_url() : self::profile_page_url();
785
786	// If we have a saved redirect to request in a cookie
787	if ( ! empty( $_COOKIE['jetpack_sso_redirect_to'] ) ) {
788	// Set that as the requested redirect to
789	$redirect_to = $_request_redirect_to = esc_url_raw( $_COOKIE['jetpack_sso_redirect_to'] );
790	}
791
792	$json_api_auth_environment = Jetpack_SSO_Helpers::get_json_api_auth_environment();
793
794	$is_json_api_auth = ! empty( $json_api_auth_environment );
795	$is_user_connected = Jetpack::is_user_connected( $user->ID );
796	JetpackTracking::record_user_event( 'sso_user_logged_in', array(
797	'user_found_with' => $user_found_with,
798	'user_connected' => (bool) $is_user_connected,
799	'user_role' => Jetpack::translate_current_user_to_role(),
800	'is_json_api_auth' => (bool) $is_json_api_auth,
801	) );
802
803	if ( $is_json_api_auth ) {
804	Jetpack::init()->verify_json_api_authorization_request( $json_api_auth_environment );
805	Jetpack::init()->store_json_api_authorization_token( $user->user_login, $user );
806
807	} else if ( ! $is_user_connected ) {
808	$calypso_env = ! empty( $_GET['calypso_env'] )
809	? sanitize_key( $_GET['calypso_env'] )
810	: '';
811
812	wp_safe_redirect(
813	add_query_arg(
814	array(
815	'redirect_to' => $redirect_to,
816	'request_redirect_to' => $_request_redirect_to,
817	'calypso_env' => $calypso_env,
818	'jetpack-sso-auth-redirect' => '1',
819	),
820	admin_url()
821	)
822	);
823	exit;
824	}
825
826	add_filter( 'allowed_redirect_hosts', array( 'Jetpack_SSO_Helpers', 'allowed_redirect_hosts' ) );
827	wp_safe_redirect(
828	/** This filter is documented in core/src/wp-login.php */
829	apply_filters( 'login_redirect', $redirect_to, $_request_redirect_to, $user )
830	);
831	exit;
832	}
833
834	add_filter( 'jetpack_sso_default_to_sso_login', '__return_false' );
835
836	JetpackTracking::record_user_event( 'sso_login_failed', array(
837	'error_message' => 'cant_find_user'
838	) );
839
840	$this->user_data = $user_data;
841	/** This filter is documented in core/src/wp-includes/pluggable.php */
842	do_action( 'wp_login_failed', $user_data->login );
843	add_filter( 'login_message', array( 'Jetpack_SSO_Notices', 'cant_find_user' ) );
844	}
845
846	static function profile_page_url() {
847	return admin_url( 'profile.php' );
848	}
849
850	/**
851	* Builds the "Login to WordPress.com" button that is displayed on the login page as well as user profile page.
852	*
853	* @param array $args An array of arguments to add to the SSO URL.
854	* @param boolean $is_primary Should the button have the `button-primary` class?
855	* @return string Returns the HTML markup for the button.
856	*/
857	function build_sso_button( $args = array(), $is_primary = false ) {
858	$url = $this->build_sso_button_url( $args );
859	$classes = $is_primary
860	? 'jetpack-sso button button-primary'
861	: 'jetpack-sso button';
862
863	return sprintf(
864	'<a rel="nofollow" href="%1$s" class="%2$s"><span>%3$s %4$s</span></a>',
865	esc_url( $url ),
866	$classes,
867	'<span class="genericon genericon-wordpress"></span>',
868	esc_html__( 'Log in with WordPress.com', 'jetpack' )
869	);
870	}
871
872	/**
873	* Builds a URL with `jetpack-sso` action and option args which is used to setup SSO.
874	*
875	* @param array $args An array of arguments to add to the SSO URL.
876	* @return string The URL used for SSO.
877	*/
878	function build_sso_button_url( $args = array() ) {
879	$defaults = array(
880	'action' => 'jetpack-sso',
881	);
882
883	$args = wp_parse_args( $args, $defaults );
884
885	if ( ! empty( $_GET['redirect_to'] ) ) {
886	$args['redirect_to'] = urlencode( esc_url_raw( $_GET['redirect_to'] ) );
887	}
888
889	return add_query_arg( $args, wp_login_url() );
890	}
891
892	/**
893	* Retrieves a WordPress.com SSO URL with appropriate query parameters or dies.
894	*
895	* @param boolean $reauth Should the user be forced to reauthenticate on WordPress.com?
896	* @param array $args Optional query parameters.
897	* @return string The WordPress.com SSO URL.
898	*/
899	function get_sso_url_or_die( $reauth = false, $args = array() ) {
900	if ( empty( $reauth ) ) {
901	$sso_redirect = $this->build_sso_url( $args );
902	} else {
903	self::clear_wpcom_profile_cookies();
904	$sso_redirect = $this->build_reauth_and_sso_url( $args );
905	}
906
907	// If there was an error retrieving the SSO URL, then error.
908	if ( is_wp_error( $sso_redirect ) ) {
909	$error_message = sanitize_text_field(
910	sprintf( '%s: %s', $sso_redirect->get_error_code(), $sso_redirect->get_error_message() )
911	);
912	JetpackTracking::record_user_event( 'sso_login_redirect_failed', array(
913	'error_message' => $error_message
914	) );
915	wp_die( $error_message );
916	}
917
918	return $sso_redirect;
919	}
920
921	/**
922	* Build WordPress.com SSO URL with appropriate query parameters.
923	*
924	* @param array $args Optional query parameters.
925	* @return string WordPress.com SSO URL
926	*/
927	function build_sso_url( $args = array() ) {
928	$sso_nonce = ! empty( $args['sso_nonce'] ) ? $args['sso_nonce'] : self::request_initial_nonce();
929	$defaults = array(
930	'action' => 'jetpack-sso',
931	'site_id' => Jetpack_Options::get_option( 'id' ),
932	'sso_nonce' => $sso_nonce,
933	'calypso_auth' => '1',
934	);
935
936	$args = wp_parse_args( $args, $defaults );
937
938	if ( is_wp_error( $args['sso_nonce'] ) ) {
939	return $args['sso_nonce'];
940	}
941
942	return add_query_arg( $args, 'https://wordpress.com/wp-login.php' );
943	}
944
945	/**
946	* Build WordPress.com SSO URL with appropriate query parameters,
947	* including the parameters necessary to force the user to reauthenticate
948	* on WordPress.com.
949	*
950	* @param array $args Optional query parameters.
951	* @return string WordPress.com SSO URL
952	*/
953	function build_reauth_and_sso_url( $args = array() ) {
954	$sso_nonce = ! empty( $args['sso_nonce'] ) ? $args['sso_nonce'] : self::request_initial_nonce();
955	$redirect = $this->build_sso_url( array( 'force_auth' => '1', 'sso_nonce' => $sso_nonce ) );
956
957	if ( is_wp_error( $redirect ) ) {
958	return $redirect;
959	}
960
961	$defaults = array(
962	'action' => 'jetpack-sso',
963	'site_id' => Jetpack_Options::get_option( 'id' ),
964	'sso_nonce' => $sso_nonce,
965	'reauth' => '1',
966	'redirect_to' => urlencode( $redirect ),
967	'calypso_auth' => '1',
968	);
969
970	$args = wp_parse_args( $args, $defaults );
971
972	if ( is_wp_error( $args['sso_nonce'] ) ) {
973	return $args['sso_nonce'];
974	}
975
976	return add_query_arg( $args, 'https://wordpress.com/wp-login.php' );
977	}
978
979	/**
980	* Determines local user associated with a given WordPress.com user ID.
981	*
982	* @since 2.6.0
983	*
984	* @param int $wpcom_user_id User ID from WordPress.com
985	* @return object Local user object if found, null if not.
986	*/
987	static function get_user_by_wpcom_id( $wpcom_user_id ) {
988	$user_query = new WP_User_Query( array(
989	'meta_key' => 'wpcom_user_id',
990	'meta_value' => intval( $wpcom_user_id ),
991	'number' => 1,
992	) );
993
994	$users = $user_query->get_results();
995	return $users ? array_shift( $users ) : null;
996	}
997
998	/**
999	* When jetpack-sso-auth-redirect query parameter is set, will redirect user to
1000	* WordPress.com authorization flow.
1001	*
1002	* We redirect here instead of in handle_login() because Jetpack::init()->build_connect_url
1003	* calls menu_page_url() which doesn't work properly until admin menus are registered.
1004	*/
1005	function maybe_authorize_user_after_sso() {
1006	if ( empty( $_GET['jetpack-sso-auth-redirect'] ) ) {
1007	return;
1008	}
1009
1010	$redirect_to = ! empty( $_GET['redirect_to'] ) ? esc_url_raw( $_GET['redirect_to'] ) : admin_url();
1011	$request_redirect_to = ! empty( $_GET['request_redirect_to'] ) ? esc_url_raw( $_GET['request_redirect_to'] ) : $redirect_to;
1012
1013	/** This filter is documented in core/src/wp-login.php */
1014	$redirect_after_auth = apply_filters( 'login_redirect', $redirect_to, $request_redirect_to, wp_get_current_user() );
1015
1016	/**
1017	* Since we are passing this redirect to WordPress.com and therefore can not use wp_safe_redirect(),
1018	* let's sanitize it here to make sure it's safe. If the redirect is not safe, then use admin_url().
1019	*/
1020	$redirect_after_auth = wp_sanitize_redirect( $redirect_after_auth );
1021	$redirect_after_auth = wp_validate_redirect( $redirect_after_auth, admin_url() );
1022
1023	/**
1024	* Return the raw connect URL with our redirect and attribute connection to SSO.
1025	*/
1026	$connect_url = Jetpack::init()->build_connect_url( true, $redirect_after_auth, 'sso' );
1027
1028	add_filter( 'allowed_redirect_hosts', array( 'Jetpack_SSO_Helpers', 'allowed_redirect_hosts' ) );
1029	wp_safe_redirect( $connect_url );
1030	exit;
1031	}
1032
1033	/**
1034	* Cache user's display name and Gravatar so it can be displayed on the login screen. These cookies are
1035	* stored when the user logs out, and then deleted when the user logs in.
1036	*/
1037	function store_wpcom_profile_cookies_on_logout() {
1038	if ( ! Jetpack::is_user_connected( get_current_user_id() ) ) {
1039	return;
1040	}
1041
1042	$user_data = $this->get_user_data( get_current_user_id() );
1043	if ( ! $user_data ) {
1044	return;
1045	}
1046
1047	setcookie(
1048	'jetpack_sso_wpcom_name_' . COOKIEHASH,
1049	$user_data->display_name,
1050	time() + WEEK_IN_SECONDS,
1051	COOKIEPATH,
1052	COOKIE_DOMAIN,
1053	is_ssl()
1054	);
1055
1056	setcookie(
1057	'jetpack_sso_wpcom_gravatar_' . COOKIEHASH,
1058	get_avatar_url(
1059	$user_data->email,
1060	array( 'size' => 144, 'default' => 'mystery' )
1061	),
1062	time() + WEEK_IN_SECONDS,
1063	COOKIEPATH,
1064	COOKIE_DOMAIN,
1065	is_ssl()
1066	);
1067	}
1068
1069	/**
1070	* Determines if a local user is connected to WordPress.com
1071	*
1072	* @since 2.8
1073	* @param integer $user_id - Local user id
1074	* @return boolean
1075	**/
1076	public function is_user_connected( $user_id ) {
1077	return $this->get_user_data( $user_id );
1078	}
1079
1080	/**
1081	* Retrieves a user's WordPress.com data
1082	*
1083	* @since 2.8
1084	* @param integer $user_id - Local user id
1085	* @return mixed null or stdClass
1086	**/
1087	public function get_user_data( $user_id ) {
1088	return get_user_meta( $user_id, 'wpcom_user_data', true );
1089	}
1090	}
1091
1092	Jetpack_SSO::get_instance();
1093