Développement de la plateforme publique WeChat : description OAuth2.0

Comprendre OAuth2.0

Tout d'abord, comprenons le mode de fonctionnement d'OAuth2.0 à travers une image :

Nous pouvons le voir sur l'image ci-dessus L'ensemble du processus est passé par deux "poignées de main", et finalement le AccessToken autorisé a été utilisé pour faire une série de requêtes. Le processus concerné est expliqué comme suit :

A : Le client envoie une demande de vérification au serveur, et la requête contient généralement ces paramètres

Identification d'ID, telle que appId

URL vers laquelle accéder après vérification (redirectUrl)

Paramètre d'état (facultatif)

Fonction d'autorisation Portée du domaine (facultatif)

Type de réponse (facultatif)

B : Le serveur renvoie une identification d'autorisation d'octroi (WeChat l'appelle code par défaut), similaire à une identification unique Clé de chaîne temporaire. Si redirectUrl est fourni dans A, le serveur fera un saut et accédera à redirectUrl avec les paramètres d'octroi et d'état.

C : La page correspondante redirectUrl du client utilise Grant pour lancer à nouveau une demande. Cette demande contient généralement des informations sensibles :

Identification

Mot de passe

<.> chaîne d'octroi (code)

type d'octroi (facultatif, la valeur par défaut est le code dans WeChat)

D : une fois que le serveur a vérifié que l'ID, le mot de passe et l'octroi sont corrects, il renvoie AccessToken (remarque, l'AccessToken ici n'a rien à voir avec l'AccessToken introduit dans l'interface générale et l'interface avancée précédente, et ne peut pas être utilisé de manière croisée)

E : Le client utilise AccessToken pour demander une série d'API , et ne contiendra plus l'appId, le Secret et l'octroi dans le processus ni d'autres informations sensibles.

F : Le serveur renvoie le résultat de la requête.

Utiliser OAuth2.0 dans WeChat

Après avoir compris les principes de base d'OAuth2.0, examinons comment OAuth2.0 est utilisé dans WeChat.

Supposons un scénario : l'utilisateur accède à un compte public WeChat, puis ouvre une page Web de jeu dans le navigateur intégré WeChat via le lien dans le message. Ce jeu nécessite que l'utilisateur se connecte et enregistre le score de jeu de l'utilisateur. .

Nous avons deux manières de gérer cette situation :

Permettre aux utilisateurs de s'inscrire et de se connecter sur la page Web (et ils devront peut-être se reconnecter à chaque fois qu'ils ouvrent cette page Web, car WeChat a navigation intégrée (la durée de stockage des cookies du serveur est très courte), il s'agit bien sûr d'une conception très trompeuse.

Utilisez OAuth2.0. Lorsque l'utilisateur accède à cette page, il détermine d'abord s'il est connecté. Dans le cas contraire, il accède automatiquement à la page d'autorisation OAuth2.0. Cette page effectue automatiquement la série de vérifications ABCD mentionnée ci-dessus, puis obtient l'OpenId de l'utilisateur. via EF et des informations encore plus détaillées (y compris l'avatar), terminez automatiquement le processus de connexion (ou d'enregistrement nécessaire), puis l'utilisateur entre directement dans le jeu dans l'état connecté.

On peut voir que l'utilisation d'OAuth2.0 améliore considérablement l'expérience utilisateur et peut automatiquement lier et identifier l'OpenId WeChat de l'utilisateur.

Il est à noter que la « page d'autorisation OAuth2.0 » mentionnée ci-dessus a également deux formes :

Lorsque le Scope dans la requête A est snsapi_base, l'ensemble du processus d'autorisation s'y termine automatiquement. il n'y aura pas de page intermédiaire affichée sur le client de l'utilisateur, mais le résultat de l'autorisation ne peut obtenir que l'OpenId de l'utilisateur (que l'utilisateur ait ou non suivi l'utilisateur, bien sûr, si l'utilisateur suit l'utilisateur, utilisez à nouveau l'interface d'informations utilisateur dans l'interface avancée pour obtenir l'OpenId de l'utilisateur. L'information est également disponible, mais il y a quelques détours)

Lorsque le Scope dans la requête A est snsapi_userinfo, une page d'autorisation doit être fournie (similaire à l'autorisation qui de nombreux sites Web utilisent des comptes Weibo et des comptes QQ pour se connecter) ), seulement après l'accord de l'utilisateur, les informations détaillées de l'utilisateur sont immédiatement obtenues. L'utilisateur ici peut être un utilisateur suivant ou un utilisateur non suivi, et le contenu renvoyé est le même.

En d'autres termes, la méthode snsapi_base peut obtenir l'OpenId de l'utilisateur "sans que personne ne s'en aperçoive" et terminer de manière entièrement automatique le processus de connexion et d'enregistrement, mais la quantité d'informations est limitée par snsapi_userinfo qui nécessite que l'utilisateur l'autorise ; l'interface spécifiée, puis la complète automatiquement Pendant tout le processus, cette autorisation a une période de temps et l'utilisateur doit être interrogé à nouveau après l'expiration du délai.

Interface Senparc.Weixin.MP OAuth2.0

Dossier du fichier source : Senparc.Weixin.MP/AdvancedAPIs/OAuth

Les méthodes pertinentes dans le code source sont les suivantes :

namespace Senparc.Weixin.MP.AdvancedAPIs
{
    //官方文档：http://mp.weixin.qq.com/wiki/index.php?title=%E7%BD%91%E9%A1%B5%E6%8E%88%E6%9D%83%E8%8E%B7%E5%8F%96%E7%94%A8%E6%88%B7%E5%9F%BA%E6%9C%AC%E4%BF%A1%E6%81%AF#.E7.AC.AC.E4.B8.80.E6.AD.A5.EF.BC.9A.E7.94.A8.E6.88.B7.E5.90.8C.E6.84.8F.E6.8E.88.E6.9D.83.EF.BC.8C.E8.8E.B7.E5.8F.96code

    /// <summary>
    /// 应用授权作用域
    /// </summary>
    public enum OAuthScope
    {
        /// <summary>
        /// 不弹出授权页面，直接跳转，只能获取用户openid
        /// </summary>
        snsapi_base,
        /// <summary>
        /// 弹出授权页面，可通过openid拿到昵称、性别、所在地。并且，即使在未关注的情况下，只要用户授权，也能获取其信息
        /// </summary>
        snsapi_userinfo
    }

    public static class OAuth
    {
        /// <summary>
        /// 获取验证地址
        /// </summary>
        /// <param name="appId"></param>
        /// <param name="redirectUrl"></param>
        /// <param name="state"></param>
        /// <param name="scope"></param>
        /// <param name="responseType"></param>
        /// <returns></returns>
        public static string GetAuthorizeUrl(string appId, string redirectUrl, string state, OAuthScope scope, string responseType = "code")
        {
            var url =
                string.Format("https://open.weixin.qq.com/connect/oauth2/authorize?appid={0}&redirect_uri={1}&response_type={2}&scope={3}&state={4}#wechat_redirect",
                                appId, redirectUrl.UrlEncode(), responseType, scope, state);

            /* 这一步发送之后，客户会得到授权页面，无论同意或拒绝，都会返回redirectUrl页面。
             * 如果用户同意授权，页面将跳转至 redirect_uri/?code=CODE&state=STATE。这里的code用于换取access_token（和通用接口的access_token不通用）
             * 若用户禁止授权，则重定向后不会带上code参数，仅会带上state参数redirect_uri?state=STATE
             */
            return url;
        }

        /// <summary>
        /// 获取AccessToken
        /// </summary>
        /// <param name="appId"></param>
        /// <param name="secret"></param>
        /// <param name="code">code作为换取access_token的票据，每次用户授权带上的code将不一样，code只能使用一次，5分钟未被使用自动过期。</param>
        /// <param name="grantType"></param>
        /// <returns></returns>
        public static OAuthAccessTokenResult GetAccessToken(string appId, string secret, string code, string grantType = "authorization_code")
        {
            var url =
                string.Format("https://api.weixin.qq.com/sns/oauth2/access_token?appid={0}&secret={1}&code={2}&grant_type={3}",
                                appId, secret, code, grantType);

            return CommonJsonSend.Send<OAuthAccessTokenResult>(null, url, null, CommonJsonSendType.GET);
        }

        /// <summary>
        /// 刷新access_token（如果需要）
        /// </summary>
        /// <param name="appId"></param>
        /// <param name="refreshToken">填写通过access_token获取到的refresh_token参数</param>
        /// <param name="grantType"></param>
        /// <returns></returns>
        public static OAuthAccessTokenResult RefreshToken(string appId, string refreshToken, string grantType = "refresh_token")
        {
            var url =
                string.Format("https://api.weixin.qq.com/sns/oauth2/refresh_token?appid={0}&grant_type={1}&refresh_token={2}",
                                appId, grantType, refreshToken);

            return CommonJsonSend.Send<OAuthAccessTokenResult>(null, url, null, CommonJsonSendType.GET);
        }

        public static OAuthUserInfo GetUserInfo(string accessToken,string openId)
        {
            var url = string.Format("https://api.weixin.qq.com/sns/userinfo?access_token={0}&openid={1}",accessToken,openId);
            return CommonJsonSend.Send<OAuthUserInfo>(null, url, null, CommonJsonSendType.GET);
        }
    }
}

Pour des exemples de méthodes spécifiques, voir Senparc.Weixin.MP.Sample/Controllers/OAuth2Controller.cs, ainsi que le code de la vue correspondante.

Remarque

Vous devez disposer d'un compte de service authentifié pour utiliser l'interface OAuth.

L'AccessToken utilisé dans l'interface et l'AccessToken utilisé dans l'interface avancée (y compris l'interface commune) ne sont pas liés l'un à l'autre, même s'ils sont obtenus via les mêmes AppId et Secret.

La page d'autorisation officielle actuelle n'est pas stable à 100%. Parfois, il faut quelques clics supplémentaires pour passer sans problème. Si vous rencontrez une telle situation, vous devez porter certains jugements et faire des demandes répétées, au moins en surface, aux utilisateurs. je ne peux pas voir la page d'erreur.

Pour des raisons de sécurité, avant d'utiliser OAuth2.0, vous devez saisir [Mes services] dans le backend WeChat pour définir le nom de domaine de la page de rappel :

Pour plus de développement de la plateforme publique WeChat : instructions OAuth2.0, veuillez faire attention au site Web PHP chinois pour les articles connexes !