Changeset 56875

Timestamp:

10/12/2023 03:03:26 PM (3 years ago)

Author:

joemcgill

Message:

Grouped backports to the 5.9 branch.

• REST API: Limit search_columns for users without list_users.
• Comments: Prevent users who can not see a post from seeing comments on it.
• Application Passwords: Prevent the use of some pseudo protocols in application passwords.
• Restrict media shortcode ajax to certain type
• REST API: Ensure no-cache headers are sent when methods are overriden.
• Prevent unintended behavior when certain objects are unserialized.

Merges [56833], [56834], [56835], [56836], [56837], and [56838] to the 5.9 branch.
Props xknown, jorbin, Vortfu, joehoyle, timothyblynjacobs, peterwilsoncc, ehtis, tykoted, martinkrcho, paulkevan, dd32, antpb, rmccue.

Location:

branches/5.9

Files:

• . (modified) (1 prop)
• src/wp-admin/includes/ajax-actions.php (modified) (2 diffs)
• src/wp-admin/includes/class-wp-comments-list-table.php (modified) (1 diff)
• src/wp-admin/includes/class-wp-list-table.php (modified) (1 diff)
• src/wp-admin/includes/dashboard.php (modified) (1 diff)
• src/wp-admin/includes/user.php (modified) (3 diffs)
• src/wp-includes/Requests/Hooks.php (modified) (1 diff)
• src/wp-includes/Requests/IRI.php (modified) (1 diff)
• src/wp-includes/Requests/Session.php (modified) (1 diff)
• src/wp-includes/class-wp-block-patterns-registry.php (modified) (1 diff)
• src/wp-includes/class-wp-block-type-registry.php (modified) (1 diff)
• src/wp-includes/class-wp-theme.php (modified) (2 diffs)
• src/wp-includes/media.php (modified) (4 diffs)
• src/wp-includes/rest-api.php (modified) (1 diff)
• src/wp-includes/rest-api/class-wp-rest-server.php (modified) (3 diffs)
• src/wp-includes/rest-api/endpoints/class-wp-rest-users-controller.php (modified) (1 diff)
• src/wp-includes/shortcodes.php (modified) (1 diff)

branches/5.9/src/wp-admin/includes/ajax-actions.php

@@ -3813 +3813 @@
         $shortcode = wp_unslash( $_POST['shortcode'] );
 
+        // Only process previews for media related shortcodes:
+        $found_shortcodes = get_shortcode_tags_in_content( $shortcode );
+        $media_shortcodes = array(
+                'audio',
+                'embed',
+                'playlist',
+                'video',
+                'gallery',
+        );
+
+        $other_shortcodes = array_diff( $found_shortcodes, $media_shortcodes );
+
+        if ( ! empty( $other_shortcodes ) ) {
+                wp_send_json_error();
+        }
+
         if ( ! empty( $_POST['post_ID'] ) ) {
                 $post = get_post( (int) $_POST['post_ID'] );
@@ -3819 +3835 @@
         // The embed shortcode requires a post.
         if ( ! $post || ! current_user_can( 'edit_post', $post->ID ) ) {
-                if ( 'embed' === $shortcode ) {
+                if ( in_array( 'embed', $found_shortcodes, true ) ) {
                         wp_send_json_error();
                 }

branches/5.9/src/wp-admin/includes/class-wp-comments-list-table.php

@@ -640 +640 @@
 
                 $this->user_can = current_user_can( 'edit_comment', $comment->comment_ID );
+
+                $edit_post_cap = $post ? 'edit_post' : 'edit_posts';
+                if (
+                        current_user_can( $edit_post_cap, $comment->comment_post_ID ) ||
+                        (
+                                empty( $post->post_password ) &&
+                                current_user_can( 'read_post', $comment->comment_post_ID )
+                        )
+                ) {
+                        // The user has access to the post
+                } else {
+                        return false;
+                }
 
                 echo "<tr id='comment-$comment->comment_ID' class='$the_comment_class'>";

branches/5.9/src/wp-admin/includes/class-wp-list-table.php

@@ -739 +739 @@
                         $pending_comments_number
                 );
+
+                $post_object   = get_post( $post_id );
+                $edit_post_cap = $post_object ? 'edit_post' : 'edit_posts';
+                if (
+                        current_user_can( $edit_post_cap, $post_id ) ||
+                        (
+                                empty( $post_object->post_password ) &&
+                                current_user_can( 'read_post', $post_id )
+                        )
+                ) {
+                        // The user has access to the post and thus can see comments
+                } else {
+                        return false;
+                }
 
                 if ( ! $approved_comments && ! $pending_comments ) {

branches/5.9/src/wp-admin/includes/dashboard.php

@@ -1086 +1086 @@
                 echo '<ul id="the-comment-list" data-wp-lists="list:comment">';
                 foreach ( $comments as $comment ) {
-                        _wp_dashboard_recent_comments_row( $comment );
+
+                        $comment_post = get_post( $comment->comment_post_ID );
+                        if (
+                                current_user_can( 'edit_post', $comment->comment_post_ID ) ||
+                                (
+                                        empty( $comment_post->post_password ) &&
+                                        current_user_can( 'read_post', $comment->comment_post_ID )
+                                )
+                        ) {
+                                _wp_dashboard_recent_comments_row( $comment );
+                        }
                 }
                 echo '</ul>';

branches/5.9/src/wp-admin/includes/user.php

@@ -600 +600 @@
  *
  * @since 5.6.0
+ * @since 6.2.0 Allow insecure HTTP connections for the local environment.
+ * @since 6.3.2 Validates the success and reject URLs to prevent javascript pseudo protocol being executed.
  *
  * @param array   $request {
@@ -615 +617 @@
         $error = new WP_Error();
 
-        if ( ! empty( $request['success_url'] ) ) {
-                $scheme = wp_parse_url( $request['success_url'], PHP_URL_SCHEME );
-
-                if ( 'http' === $scheme ) {
+        if ( isset( $request['success_url'] ) ) {
+                $validated_success_url = wp_is_authorize_application_redirect_url_valid( $request['success_url'] );
+                if ( is_wp_error( $validated_success_url ) ) {
                         $error->add(
-                                'invalid_redirect_scheme',
-                                __( 'The success URL must be served over a secure connection.' )
+                                $validated_success_url->get_error_code(),
+                                $validated_success_url->get_error_message()
                         );
                 }
         }
 
-        if ( ! empty( $request['reject_url'] ) ) {
-                $scheme = wp_parse_url( $request['reject_url'], PHP_URL_SCHEME );
-
-                if ( 'http' === $scheme ) {
+        if ( isset( $request['reject_url'] ) ) {
+                $validated_reject_url = wp_is_authorize_application_redirect_url_valid( $request['reject_url'] );
+                if ( is_wp_error( $validated_reject_url ) ) {
                         $error->add(
-                                'invalid_redirect_scheme',
-                                __( 'The rejection URL must be served over a secure connection.' )
+                                $validated_reject_url->get_error_code(),
+                                $validated_reject_url->get_error_message()
                         );
                 }
@@ -661 +661 @@
         return true;
 }
+
+/**
+ * Validates the redirect URL protocol scheme. The protocol can be anything except http and javascript.
+ *
+ * @since 6.3.2
+ *
+ * @param string $url - The redirect URL to be validated.
+ *
+ * @return true|WP_Error True if the redirect URL is valid, a WP_Error object otherwise.
+ */
+function wp_is_authorize_application_redirect_url_valid( $url ) {
+        $bad_protocols = array( 'javascript', 'data' );
+        if ( empty( $url ) ) {
+                return true;
+        }
+
+        // Based on https://www.rfc-editor.org/rfc/rfc2396#section-3.1
+        $valid_scheme_regex = '/^[a-zA-Z][a-zA-Z0-9+.-]*:/';
+        if ( ! preg_match( $valid_scheme_regex, $url ) ) {
+                return new WP_Error(
+                        'invalid_redirect_url_format',
+                        __( 'Invalid URL format.' )
+                );
+        }
+
+        /**
+         * Filters the list of invalid protocols used in applications redirect URLs.
+         *
+         * @since 6.3.2
+         *
+         * @param string[]  $bad_protocols Array of invalid protocols.
+         * @param string    $url The redirect URL to be validated.
+         */
+        $invalid_protocols = array_map( 'strtolower', apply_filters( 'wp_authorize_application_redirect_url_invalid_protocols', $bad_protocols, $url ) );
+
+        $scheme   = wp_parse_url( $url, PHP_URL_SCHEME );
+        $host     = wp_parse_url( $url, PHP_URL_HOST );
+        $is_local = 'local' === wp_get_environment_type();
+
+        // validates if the proper URI format is applied to the $url
+        if ( empty( $host ) || empty( $scheme ) || in_array( strtolower( $scheme ), $invalid_protocols, true ) ) {
+                return new WP_Error(
+                        'invalid_redirect_url_format',
+                        __( 'Invalid URL format.' )
+                );
+        }
+
+        if ( 'http' === $scheme && ! $is_local ) {
+                return new WP_Error(
+                        'invalid_redirect_scheme',
+                        __( 'The URL must be served over a secure connection.' )
+                );
+        }
+
+        return true;
+}

branches/5.9/src/wp-includes/Requests/Hooks.php

@@ -66 +66 @@
                 return true;
         }
+
+        public function __wakeup() {
+                throw new \LogicException( __CLASS__ . ' should never be unserialized' );
+        }
 }

branches/5.9/src/wp-includes/Requests/IRI.php

@@ -706 +706 @@
         }
 
+        public function __wakeup() {
+                $class_props = get_class_vars( __CLASS__ );
+                $string_props = array( 'scheme', 'iuserinfo', 'ihost', 'port', 'ipath', 'iquery', 'ifragment' );
+                $array_props = array( 'normalization' );
+                foreach ( $class_props as $prop => $default_value ) {
+                        if ( in_array( $prop, $string_props, true ) && ! is_string( $this->$prop ) ) {
+                                throw new UnexpectedValueException();
+                        } elseif ( in_array( $prop, $array_props, true ) && ! is_array( $this->$prop ) ) {
+                                throw new UnexpectedValueException();
+                        }
+                        $this->$prop = null;
+                }
+        }
+
         /**
          * Set the entire IRI. Returns true on success, false on failure (if there

branches/5.9/src/wp-includes/Requests/Session.php

@@ -230 +230 @@
         }
 
+        public function __wakeup() {
+                throw new \LogicException( __CLASS__ . ' should never be unserialized' );
+        }
+
         /**
          * Merge a request's data with the default data

branches/5.9/src/wp-includes/class-wp-block-patterns-registry.php

@@ -157 +157 @@
         }
 
+        public function __wakeup() {
+                if ( ! $this->registered_patterns ) {
+                        return;
+                }
+                if ( ! is_array( $this->registered_patterns ) ) {
+                        throw new UnexpectedValueException();
+                }
+                foreach ( $this->registered_patterns as $value ) {
+                        if ( ! is_array( $value ) ) {
+                                throw new UnexpectedValueException();
+                        }
+                }
+                $this->registered_patterns_outside_init = array();
+        }
+
         /**
          * Utility method to retrieve the main instance of the class.

branches/5.9/src/wp-includes/class-wp-block-type-registry.php

@@ -168 +168 @@
         }
 
+        public function __wakeup() {
+                if ( ! $this->registered_block_types ) {
+                        return;
+                }
+                if ( ! is_array( $this->registered_block_types ) ) {
+                        throw new UnexpectedValueException();
+                }
+                foreach ( $this->registered_block_types as $value ) {
+                        if ( ! $value instanceof WP_Block_Type ) {
+                                throw new UnexpectedValueException();
+                        }
+                }
+        }
+
         /**
          * Utility method to retrieve the main instance of the class.

branches/5.9/src/wp-includes/class-wp-theme.php

@@ -706 +706 @@
 
         /**
+         * Perform reinitialization tasks.
+         *
+         * Prevents a callback from being injected during unserialization of an object.
+         *
+         * @return void
+         */
+        public function __wakeup() {
+                if ( $this->parent && ! $this->parent instanceof self ) {
+                        throw new UnexpectedValueException();
+                }
+                if ( $this->headers && ! is_array( $this->headers ) ) {
+                        throw new UnexpectedValueException();
+                }
+                foreach ( $this->headers as $value ) {
+                        if ( ! is_string( $value ) ) {
+                                throw new UnexpectedValueException();
+                        }
+                }
+                $this->headers_sanitized = array();
+        }
+
+        /**
          * Adds theme data to cache.
          *
@@ -1764 +1786 @@
                 return strnatcasecmp( $a->name_translated, $b->name_translated );
         }
+
+        private static function _check_headers_property_has_correct_type( $headers ) {
+                if ( ! is_array( $headers ) ) {
+                        return false;
+                }
+                foreach ( $headers as $key => $value ) {
+                        if ( ! is_string( $key ) || ! is_string( $value ) ) {
+                                return false;
+                        }
+                }
+                return true;
+        }
 }

branches/5.9/src/wp-includes/media.php

@@ -2355 +2355 @@
                 }
         } elseif ( ! empty( $atts['exclude'] ) ) {
+                $post_parent_id = $id;
                 $attachments = get_children(
                         array(
@@ -2367 +2368 @@
                 );
         } else {
+                $post_parent_id = $id;
                 $attachments = get_children(
                         array(
@@ -2377 +2379 @@
                         )
                 );
+        }
+
+        if ( ! empty( $post_parent_id ) ) {
+                $post_parent = get_post( $post_parent_id );
+
+                // terminate the shortcode execution if user cannot read the post or password-protected
+                if (
+                ( ! is_post_publicly_viewable( $post_parent->ID ) && ! current_user_can( 'read_post', $post_parent->ID ) )
+                || post_password_required( $post_parent ) ) {
+                        return '';
+                }
         }
 
@@ -2705 +2718 @@
         }
 
+        if ( ! empty( $args['post_parent'] ) ) {
+                $post_parent = get_post( $id );
+
+                // terminate the shortcode execution if user cannot read the post or password-protected
+                if ( ! current_user_can( 'read_post', $post_parent->ID ) || post_password_required( $post_parent ) ) {
+                        return '';
+                }
+        }
+
         if ( empty( $attachments ) ) {
                 return '';

branches/5.9/src/wp-includes/rest-api.php

@@ -1045 +1045 @@
 
         if ( ! $result ) {
+                add_filter( 'rest_send_nocache_headers', '__return_true', 20 );
                 return new WP_Error( 'rest_cookie_invalid_nonce', __( 'Cookie check failed' ), array( 'status' => 403 ) );
         }

branches/5.9/src/wp-includes/rest-api/class-wp-rest-server.php

@@ -332 +332 @@
 
                 /**
-                 * Filters whether to send nocache headers on a REST API request.
-                 *
-                 * @since 4.4.0
-                 *
-                 * @param bool $rest_send_nocache_headers Whether to send no-cache headers.
-                 */
-                $send_no_cache_headers = apply_filters( 'rest_send_nocache_headers', is_user_logged_in() );
-                if ( $send_no_cache_headers ) {
-                        foreach ( wp_get_nocache_headers() as $header => $header_value ) {
-                                if ( empty( $header_value ) ) {
-                                        $this->remove_header( $header );
-                                } else {
-                                        $this->send_header( $header, $header_value );
-                                }
-                        }
-                }
-
-                /**
                  * Filters whether the REST API is enabled.
                  *
@@ -403 +385 @@
                  * header.
                  */
+                $method_overridden = false;
                 if ( isset( $_GET['_method'] ) ) {
                         $request->set_method( $_GET['_method'] );
                 } elseif ( isset( $_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE'] ) ) {
                         $request->set_method( $_SERVER['HTTP_X_HTTP_METHOD_OVERRIDE'] );
+                        $method_overridden = true;
                 }
 
@@ -464 +448 @@
                  */
                 $served = apply_filters( 'rest_pre_serve_request', false, $result, $request, $this );
+
+                /**
+                 * Filters whether to send nocache headers on a REST API request.
+                 *
+                 * @since 4.4.0
+                 * @since 6.x.x Moved the block to catch the filter added on rest_cookie_check_errors() from rest-api.php
+                 *
+                 * @param bool $rest_send_nocache_headers Whether to send no-cache headers.
+                 */
+                $send_no_cache_headers = apply_filters( 'rest_send_nocache_headers', is_user_logged_in() );
+
+                // send no cache headers if the $send_no_cache_headers is true
+                // OR if the HTTP_X_HTTP_METHOD_OVERRIDE is used but resulted a 4xx response code.
+                if ( $send_no_cache_headers || ( true === $method_overridden && strpos( $code, '4' ) === 0 ) ) {
+                        foreach ( wp_get_nocache_headers() as $header => $header_value ) {
+                                if ( empty( $header_value ) ) {
+                                        $this->remove_header( $header );
+                                } else {
+                                        $this->send_header( $header, $header_value );
+                                }
+                        }
+                }
 
                 if ( ! $served ) {

branches/5.9/src/wp-includes/rest-api/endpoints/class-wp-rest-users-controller.php

@@ -319 +319 @@
 
                 if ( ! empty( $prepared_args['search'] ) ) {
+                        if ( ! current_user_can( 'list_users' ) ) {
+                                $prepared_args['search_columns'] = array( 'ID', 'user_login', 'user_nicename', 'display_name' );
+                        }
                         $prepared_args['search'] = '*' . $prepared_args['search'] . '*';
                 }

branches/5.9/src/wp-includes/shortcodes.php

@@ -171 +171 @@
 
 /**
- * Search content for shortcodes and filter shortcodes through their hooks.
+ * Returns a list of registered shortcode names found in the given content.
+ *
+ * Example usage:
+ *
+ *     get_shortcode_tags_in_content( '[audio src="file.mp3"][/audio] [foo] [gallery ids="1,2,3"]' );
+ *     // array( 'audio', 'gallery' )
+ *
+ * @since 6.3.2
+ *
+ * @param string $content The content to check.
+ * @return string[] An array of registered shortcode names found in the content.
+ */
+function get_shortcode_tags_in_content( $content ) {
+        if ( false === strpos( $content, '[' ) ) {
+                return array();
+        }
+
+        preg_match_all( '/' . get_shortcode_regex() . '/', $content, $matches, PREG_SET_ORDER );
+        if ( empty( $matches ) ) {
+                return array();
+        }
+
+        $tags = array();
+        foreach ( $matches as $shortcode ) {
+                $tags[] = $shortcode[2];
+
+                if ( ! empty( $shortcode[5] ) ) {
+                        $deep_tags = get_shortcode_tags_in_content( $shortcode[5] );
+                        if ( ! empty( $deep_tags ) ) {
+                                $tags = array_merge( $tags, $deep_tags );
+                        }
+                }
+        }
+
+        return $tags;
+}
+
+/**
+ * Searches content for shortcodes and filter shortcodes through their hooks.
  *
  * This function is an alias for do_shortcode().