常連

### 前提

DjangoとReactにてJWTをCookieに保存する認証を実装しているが、リフレッシュトークンの更新がうまくいかない

### 実現したいこと

・トークンが切れた時点でリフレッシュトークンを取得し、認証をクリアする

### 発生している問題・エラーメッセージ

```
https://qiita.com/shitikakei/items/d818fb0aa8670aa4228c#authenticationpy
https://www.miracleave.co.jp/contents/1654/react-jwt-axios-interceptors/
こちらのページを参考に、Django側でCookieをResponseヘッダーにセットし、認証を行うところまでは実装できました。
しかし、アクセストークンの期限が切れた時にリフレッシュトークンを取得し、自動更新を行う操作がうまくいきません。
トークンが切れた状態でリロードを行なってもトークンの取得は行われず、再度ログイン認証を行う必要があります。

```

### 該当のソースコード

```React
//ログイン時は以下のフックを使用してPOSTリクエストを行なっています。
const useAuthAxios = () => {
  const refresh = useRefreshToken();
  const { auth } = useContext(AuthContext);
  const { cookies } = useContext(AuthContext);

  useEffect(() => {
    // リクエスト前に実行。headerに認証情報を付与する
    const requestIntercept = authAxios.interceptors.request.use(
      (config) => {
        return config;
      },
      (error) => Promise.reject(error)
    );

    // レスポンスを受け取った直後に実行。もし認証エラーだった場合、再度リクエストする。
    const responseIntercept = authAxios.interceptors.response.use(
      (response) => {
        //console.log(response)
        return response;
      }, 
      async (error) => {
        if (error.response.status === 401) {
          // 新しくaccess_tokenを発行する
          await refresh();
          return refresh.response(error.config);
        } else {
          return Promise.reject(error);
        }
      }
    );

    return () => {
      // 離脱するときにejectする
      authAxios.interceptors.request.eject(requestIntercept);
      authAxios.interceptors.response.eject(responseIntercept);
    };
    
    },[auth, refresh])

    return authAxios;

};

export default useAuthAxios;

//refresh_tokenを元にaccess_tokenを取得するフック
const useRefreshToken = () => {
  const { setAuth } = useContext(AuthContext);
  const { cookies } = useContext(AuthContext);
  const navigate = useNavigate();

  const refresh = async () => {

    // cookieに保存されたrefresh_tokenを送付してaccess_tokenを取得する
    //authAxiosだとタイムアウト
    axios.defaults.xsrfCookieName = "csrftoken"
    axios.defaults.xsrfHeaderName = "X-CSRFTOKEN"

    const res = await axios
    .post("http://localhost:8000/api/auth/refresh",
    {}, {
      headers: 
      {
        "X-CSRFTOKEN": cookies.get("csrftoken"),
        "Content-Type":"application/json"
      },
      withCredentials:true,
    });
    const refreshToken = res.data["refresh"]
    const response = await axios.post("http://localhost:8000/api/auth/newtoken",
      {
        "refresh":refreshToken
      },
      {
        withCredentials:true
      }
    );
    setAuth((prev) => {
      return { ...prev, response};
    });
    return response;
  };
  return refresh;
};

export default useRefreshToken;
```

### 試したこと

refreshの取得が出来ていることは確認できました。以下でリフレッシュが動作することも確認済みです。以下のエンドポイントはSet-Cookieを含むHttpResponseオブジェクトを返します。
```React
    const response = await axios.post("http://localhost:8000/api/auth/newtoken",
      {
        "refresh":refreshToken
      },
```

Responseオブジェクトの受け取り方やuseEffectの使い方が間違っているのかと思い、いろいろ試してみましたがうまくいきませんでした。
リクエスト時にトークンの期限が切れていた場合にそのResponseオブジェクトを利用してCookieをセットし、再度アクセスを行いたいのですが難しいのでしょうか？

ログイン時はSet-Cookieを含むオブジェクトにリクエストを投げることで、以下のようなコードで認証に成功しています。
```React
  const login = async (payload) => {
    await authAxios
    .post("/api/auth/login",payload)
    navigate("/main")
  };
```

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。


DjangoとReactにてJWTを自動でリフレッシュしたい

### 実現したいこと

JavaでRS256アルゴリズムによるJWT電子署名を生成したいと考えています。
現在、[java-jwt](https://github.com/auth0/java-jwt) を用いて実装しようとしています。

手元には、
・BASE64エンコードされたヘッダー情報
・BASE64エンコードされたペイロード情報
・JWT署名のために必要な秘密鍵
がすでに存在するという前提です。

### 前提

具体的には、こちらのページ（LINEWORKS）の
https://developers.worksmobile.com/jp/reference/authorization-sa?lang=ja
部分のJWT電子署名をJavaで実装したいと考えております。

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-18/0007e21f-8c06-4158-baeb-123b08ee1c18.png)

### 発生している問題・エラーメッセージ
プログラム自体は正常に動いてJWTが生成されるのですが、Postmanを用いてLINEWORKS APIを実行しようとするとエラーが発生してしまいます。
そのため、以下の2点を質問させてください。

①string型の秘密鍵を RSAPrivateKey型に変える方法は「該当のソースコード」項目に記載してあるような方法で合っているか？
[https://stackoverflow.com/questions/34454531/java-how-can-i-generate-privatekey-from-a-string ](https://stackoverflow.com/questions/34454531/java-how-can-i-generate-privatekey-from-a-string)を参考に作成しました。


②[こちらのページ](https://developers.worksmobile.com/jp/reference/authorization-sa?lang=ja)のようなJWT署名をやりたい場合、 **秘密鍵を用いたJWT生成は以下のコードで合っているか？**
（最終的なJWTとして、一応それっぽいものは生成されるのですが、Postmanを用いて確認すると「500 Internal Server Error」となり、正しいJWTではないことが予想されます）

一応、ヘッダーとペイロード情報は正常にBASE64エンコードできたことは確認済みです。


### 該当のソースコード
gradleへのインポート
```
dependencies {
	implementation 'com.auth0:java-jwt:3.19.0'
}
```

```Java
//秘密鍵の設定
String privateKey = {"-----BEGIN PRIVATE KEY-----" と改行、"-----END PRIVATE KEY-----" を除去した秘密鍵};

//ヘッダーの設定
Map<String, Object> headerClaims = new HashMap();
//ヘッダーのalg と typ は自動で付与されるため何も書かない

//ペイロードの設定
Map<String, Object> payloadClaims = new HashMap<>();
payloadClaims.put("iss", "Client ID");
payloadClaims.put("sub", "Service Account");
payloadClaims.put("iat", "JWT生成日時");
payloadClaims.put("exp", "JWT満了日時");

KeyFactory keyFactory = KeyFactory.getInstance("RSA");
byte[] keyContentAsBytes = Base64.getDecoder().decode(privateKey);
PKCS8EncodedKeySpec privSpec = new PKCS8EncodedKeySpec(keyContentAsBytes)
//RSA256を用いた電子署名
try {
    RSAPrivateKey privKey = (RSAPrivateKey)keyFactory.generatePrivate(privSpec);
    Algorithm algorithm = Algorithm.RSA256(null, privKey);
    String token = JWT.create()
　　　.withHeader(headerClaims)
　　　.withPayload(payloadClaims)
         .sign(algorithm);
System.out.println("JWT = " + token );
} catch (JWTCreationException exception){
    //Invalid Signing configuration / Couldn't convert Claims.
}
```
実行結果は以下のようになってしまいます。
・JWT自体はエラーが起きずに生成される
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-18/c84fd76b-5bd9-4154-8785-8d008bed11b5.png)

・200 OK が表示されない
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-18/2c985f17-299c-4fae-8559-bb33fedb3d25.png)
申し訳ありませんがどなたかご教授お願い致します。

### 試したこと

Linux環境では以下のコマンドですぐに実行できるのですが・・
```
echo -n '{BASE64エンコードされたヘッダー}.{BASE64エンコードされたペイロード}' | openssl dgst -sha256 -sign privateKey.key -binary | base64
```
### 追記
[こちらのサイト](https://tutorialmore.com/questions-2800307.htm)を参考に、以下のコードをJavaで実行すると正常に動作はするのですが、Postmanを使ってアクセストークンを取得しようとすると「500 Internal Sever Error」と表示されてしまいます。おそらく正しいJWTが取得できていないものだと思われます。
本来の質問とはズレてしまうのですが、以下のコードでJWTを取得するためにはどこが間違っているのでしょうか？
以下、使用コードです。
```Java
import java.math.BigInteger; 
import java.util.Base64;
import java.security.KeyFactory;
import java.security.Signature;
import java.security.PrivateKey;
import java.security.SignatureException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.RSAPrivateCrtKeySpec;

import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.Signature;
import java.security.SignatureException;
import java.security.interfaces.RSAPrivateKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
  
public class SHA256withRSA { 
  /**
   * RSASSA-PKCS1-v1_5 with SHA-256によるデジタル署名の生成
   */
  public static void main(String args[]) throws Exception{

    String header_local = "{\"alg\":\"RS256\",\"typ\":\"JWT\"}";
    String payload_local = "{\"iss\":\"{クライアントID}\",\"sub\":\"{サービスアカウントID}\",\"iat\":1652875817,\"exp\":1652878217}";

    String headerEncoded = Base64.getEncoder().encodeToString(header_local.getBytes());
    String payloadEncoded = Base64.getEncoder().encodeToString(payload_local.getBytes());

    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  	byte[] keyContentAsBytes = Base64.getDecoder().decode("{改行等を除去した秘密鍵本体}");
    PKCS8EncodedKeySpec privSpec = new PKCS8EncodedKeySpec(keyContentAsBytes);

        String tempAccessToken = headerEncoded+"."+ payloadEncoded;
        try {
            RSAPrivateKey privKey = (RSAPrivateKey)keyFactory.generatePrivate(privSpec);
            Signature sign = Signature.getInstance("SHA256withRSA");
            sign.initSign(privKey);
            sign.update(tempAccessToken.getBytes());
            byte[] signatureBytes = sign.sign();
            String jsonToken = Base64.getUrlEncoder().encodeToString(signatureBytes);
            String JWTtoken = tempAccessToken + "." + jsonToken;
            System.out.println("JWT = " + JWTtoken);;
        } catch (InvalidKeySpecException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SignatureException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
  }
}
```
実行結果
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-18/6a6fea43-1f36-428c-b557-96b41d0bef0e.png)

Postmanによる取得結果
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2022-05-18/be2899bc-0c12-49fe-b812-606cab3c8a11.png)


JavaでRS256アルゴリズムによるJWTを生成したい

### 前提
Next.js を使ってフロントもバックも開発しています。
今回は、 jwt を使って認証機能を付けたのですがエラーが起きてしまいました。
該当箇所とは関係のない部分の実装をしている途中で急にエラーが起きてしまったので、エラーの原因すら明確にわからず困っています。

### 実現したいこと
- エラーの解消

### 発生している問題・エラーメッセージ

```
TypeError: Right-hand side of 'instanceof' is not an object
    at eval (verify.js?9d88:120:1)
    at getSecret (verify.js?9d88:97:1)
    at module.exports [as verify] (verify.js?9d88:101:1)
    at eval (useAuth.ts?5f37:23:23)
    at commitHookEffectListMount (react-dom.development.js?ac89:23150:1)
    at commitPassiveMountOnFiber (react-dom.development.js?ac89:24926:1)
    at commitPassiveMountEffects_complete (react-dom.development.js?ac89:24891:1)
    at commitPassiveMountEffects_begin (react-dom.development.js?ac89:24878:1)
    at commitPassiveMountEffects (react-dom.development.js?ac89:24866:1)
    at flushPassiveEffectsImpl (react-dom.development.js?ac89:27039:1)
    at flushPassiveEffects (react-dom.development.js?ac89:26984:1)
    at eval (react-dom.development.js?ac89:26769:1)
    at workLoop (scheduler.development.js?bcd2:266:1)
    at flushWork (scheduler.development.js?bcd2:239:1)
    at MessagePort.performWorkUntilDeadline (scheduler.development.js?bcd2:533:1)
```

### 該当のソースコード

```TypeScript
import jwt from "jsonwebtoken";
import { useRouter } from "next/router";
import { useEffect, useState } from "react";

interface DecodedType {
  _id: string;
}

function useAuth() {
  const [loginUserId, setLoginUserId] = useState("");

  const router = useRouter();

  // ページが表示される前に行う処理
  useEffect(() => {
    const token = localStorage.getItem("token");
    if (!token) {
      router.push("http://localhost:3000/");
    }

    const secretKey = process.env.NEXT_PUBLIC_SECRET_KEY;
    try {
      const decoded = jwt.verify(token!, secretKey as string);
      setLoginUserId((decoded as DecodedType)._id);
    } catch (err) {
      console.log(err);
      router.push("http://localhost:3000/");
    }
  }, [router]);

  return loginUserId;
}

export default useAuth;

```

### 試したこと
ログを取りながらエラー箇所を確認したところ verify の部分でエラーが起きていることは確認しました。
エラーメッセージで検索した結果、 instanceof を使わない等の解決策が出てきたのですが、 verify は自分で実装した部分ではないのでこの方法は有効ではないと思い停滞しています。
### 補足情報（FW/ツールのバージョンなど）
- Next : 13.0.5
- jwt : 8.5.1


jwt.verify() におけるエラーの解決

JWTの有効期限に関する質問です.

① ログインしてJWTを取得
② JWTを載せてapiコール
③ JWTの期限が切れる
② JWTを載せてapiコール (期限切れでエラー)
④ ログイン画面にリダイレクト

上記のようなフローの中でいくつかわからない点があります.
- フロント側で毎回JWTが有効がどうか確認する必要があるのか？(期限切れの場合ログイン画面にリダイレクト)
- 例えば取得したJWTの有効期限を伸ばすことはできるのか? (例えば②の時とかに)
- ↑がダメな場合どのような手順で更新されたJWTを取得すれば良いのか?

よろしくお願いします.

JWTの期限について

### 前提

プログラマ1年目の初心者です。至らない点や認識の間違いなどあるかと思いますが、どうかよろしくお願いいたします。
JWT(Json Web Token)発行を実装したいのですが、発行はしているが、正しい署名情報でないためか、認証失敗してしまいます。
調べましたが、情報が乏しいため、こちらに質問させていただくに至りました。
ES256形式（curve : P-256 (secp256r1),hash Algorithm : SHA-256）による実装です。


### 実現したいこと

- [ ] JWTの鍵による認証を成功させたい

### 発生している問題・エラーメッセージ

下記認証サイトによるInvailed Signatureエラー
https://jwt.io/

### 該当のソースコード

```C#
using System;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Text.Json;
using System.IO;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.OpenSsl;
using Org.BouncyCastle.Crypto.Signers;

namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private static string plainText;
        private static string key;
        private static byte[] signature;

        /// <summary>
        /// ボタンクリックイベント(main)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ConfirmButton_Click(object sender, EventArgs e)
        {
            // generate token
            string token = GenerateJwtToken();

            // output token
            Console.WriteLine(token);
        }

        /// <summary>
        /// Jwtトークンの生成
        /// </summary>
        /// <param name="privateKey"></param>
        /// <returns></returns>
        public static string GenerateJwtToken()
        {
            var header = new Header()
            {
                Typ = "JWT",
                Kid = "kid",
                Alg = "ES256"
            };

            var payload = new Payload()
            {
                Name = "name"
            };

            // header,payload確認
            var jsonHeader = JsonSerializer.Serialize(header);
            var jsonPayload = JsonSerializer.Serialize(payload);
            string encodedHeader = Convert.ToBase64String(Encoding.UTF8.GetBytes(jsonHeader)).TrimEnd('=').Replace('+', '-').Replace('/', '_');
            string encodedPayload = Convert.ToBase64String(Encoding.UTF8.GetBytes(jsonPayload)).TrimEnd('=').Replace('+', '-').Replace('/', '_');

            // token発行
            plainText = encodedHeader + "." + encodedPayload;
            key = @"C:\~~~\prime256v1.privatekey";
            signature = Sign(plainText, key);
            string encodedSignature = Convert.ToBase64String(signature).TrimEnd('=').Replace('+', '-').Replace('/', '_');
            string token = encodedHeader + "." + encodedPayload + "." + encodedSignature;

            return token;
        }

        /// <summary>
        /// 署名する
        /// </summary>
        static byte[] Sign(string clearText, string key)
        {
            var plain = Encoding.UTF8.GetBytes(clearText);

            // 鍵を読み込む
            AsymmetricCipherKeyPair pair = null;
            using (var stream = new StreamReader(key))
            {
                var reader = new PemReader(stream);
                pair = reader.ReadObject() as AsymmetricCipherKeyPair;
            }

            // 署名インスタンスを生成＆署名
            var signer = new ECDsaSigner();
            signer.Init(true, pair.Private);
            var sign = signer.GenerateSignature(plain);

            // 署名の値をbyte[]にしておく
            var sign1 = sign[0].ToByteArray().SkipWhile(b => b == 0x00).Reverse();
            var sign2 = sign[1].ToByteArray().SkipWhile(b => b == 0x00).Reverse();
            byte[] signature = sign1.Concat(sign2).ToArray();

            return signature;
        }


        /// <summary>
        /// ヘッダー格納用クラス
        /// </summary>
        public class Header
        {
            public string Typ { get; set; }
            public string Kid { get; set; }
            public string Alg { get; set; }
        }

        /// <summary>
        /// ペイロード格納用クラス
        /// </summary>
        public class Payload
        {
            public string Name { get; set; }
        }

    }
}
```

### 試したこと

大参考記事 https://qiita.com/rawr/items/1a11edf694f550596879
①opensslで鍵ペアを作成
②(①を取り込んだ)C#を実行し、JWTを生成
③ ①と②を https://jwt.io/ に入力し、認証

②の署名作成部分(Sign())が間違っているのではないかと思ったのですが、調べても同じような実装例が見つからず、解決できませんでした。

参考記事の認証メソッドVerifyも実装しました。メソッドでは認証が成功しましたが、認証サイトでは認証が成功しませんでした。

### 補足情報（FW/ツールのバージョンなど）

Windows10
Visual studio 2019
.NET Framework 4.7.2
BouncyCastle 1.8.9(VS2019インストール時にすでにインストール済)
OpenSSL 1.1.1s  1 Nov 2022

openssl実行コマンド：

$ openssl ecparam -genkey -name prime256v1 -out prime256v1.keypair
$ openssl ec -in prime256v1.keypair -outform PEM -out prime256v1.privatekey
$ openssl ec -in prime256v1.keypair -outform PEM -pubout -out prime256v1.publickey


[C#]JWT認証が失敗してしまう

DjangoのdjoserのURLについて質問があります。

```ここに言語を入力
from django.urls import path, include

urlpatterns = [
    path("test/auth/", include('djoser.urls')),
    path("test/auth/", include('djoser.urls.jwt')),
    path("test", include('test.urls')), 
]
```
今まで、JWT認証をしようする際は見よう見まねで上記のurls.pyを作成していました。
http://IPアドレス/test/auth/jwt/create/ でJWTを取得でき、
http://IPアドレス/test/auth/jwt/refresh/ はリフレッシュトークンの送り先であることを認識しています。

**path("test/auth/", include('djoser.urls')),**

このURLの意味がわかりません。どういう目的で書かれている（どういうときに使用する）のでしょうか。

**path("test/auth/", include('djoser.urls')),
path("test/auth/", include('djoser.urls.jwt')),**

今までこの2行をセットで書かないとJWT認証ができないのかな、と思っていましたが、もしかしたら1行目は不要なのでは、と思い質問いたしました。

▽追記
とりあえず1行目をコメントアウトをして検証をしていますが、JWTの取得、再取得、検証は問題なく機能しています。
もう少し様子見をします。



Django REST framework のdjoser のURLについて


permission_classes = [IsAuthenticatedOrReadOnly] のAPIを作成し、ターミナルからの以下のコマンドでJWTを取得しました。

curl -X POST http://xxx.xxx.xxx.xxx/api/v1/auth/jwt/create/ -H "Accept:application/json" -H "Content-type: application/json" -d '{"username": "admin","password": 12345}'

取得したアクセストークンを利用して、testuserを削除するコマンドを実行しました。

curl -v -X DELETE http://xxx.xxx.xxx.xxx/api/v1/accounts/testuser/ -H 'Authorization: JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNjY2OTE5MjE2LCJqdGkiOiJmNDNkMGVhNGIwYjM0ZmY3YjM2MmIwOTZlN2FmN2ViNiIsInVzZXJfaWQiOjF9.6EKlLtemKd2MAbSeb5d1uqWQfyxKvhoW1.........'

認証情報が含まれていません、という結果が出力されました。原因を解決したいと思っています。

```ここに言語を入力
*   Trying xxx.xxx.xxx.xxx:80...
* Connected to xxx.xxx.xxx.xxx (xxx.xxx.xxx.xxx) port 80 (#0)
> DELETE /api/v1/accounts/testuser/ HTTP/1.1
> Host: xxx.xxx.xxx.xxx
> User-Agent: curl/7.82.0
> Accept: */*
> Authorization: JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNjY2OTE5MjE2LCJqdGkiOiJmNDNkMGVhNGIwYjM0ZmY3YjM2MmIwOTZlN2FmN2ViNiIsInVzZXJfaWQiOjF9.6EKlLtemKd2MAbSeb5d1uqWQfyxKvhoW1.........
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 401 Unauthorized
< Date: Fri, 28 Oct 2022 01:03:23 GMT
< Server: Apache
< WWW-Authenticate: JWT realm="api"
< Vary: Accept,Origin
< Allow: GET, PUT, PATCH, DELETE, HEAD, OPTIONS
< X-Frame-Options: DENY
< Content-Length: 55
< X-Content-Type-Options: nosniff
< Referrer-Policy: same-origin
< Cross-Origin-Opener-Policy: same-origin
< Content-Type: application/json
<
* Connection #0 to host xxx.xxx.xxx.xxx left intact
{"detail":"認証情報が含まれていません。"}
```


これは、APIの作成方法に問題がある（認証情報を含んだAPIを作成できていない）ということでしょうか？

settings.pyのSIMPLE_JWTは以下のように設定しています。

```ここに言語を入力
SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=10),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
    'ROTATE_REFRESH_TOKENS': True,
    'BLACKLIST_AFTER_ROTATION': False,
    'UPDATE_LAST_LOGIN': False,

    'ALGORITHM': 'HS256',
    'SIGNING_KEY': SECRET_KEY,
    'VERIFYING_KEY': None,
    #'AUDIENCE': None,
    #'ISSUER': None,
    #'JWK_URL': None,
    #'LEEWAY': 0,

    'AUTH_HEADER_TYPES': ('JWT',),
    #'AUTH_HEADER_NAME': 'HTTP_AUTHORIZATION',
    'USER_ID_FIELD': 'id',
    'USER_ID_CLAIM': 'user_id',
    #'USER_AUTHENTICATION_RULE': 'rest_framework_simplejwt.authentication.default_user_authentication_rule',

    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),
    'TOKEN_TYPE_CLAIM': 'token_type',
    #'TOKEN_USER_CLASS': 'rest_framework_simplejwt.models.TokenUser',

    #'JTI_CLAIM': 'jti',

    #'SLIDING_TOKEN_REFRESH_EXP_CLAIM': 'refresh_exp',
    #'SLIDING_TOKEN_LIFETIME': timedelta(minutes=5),
    #'SLIDING_TOKEN_REFRESH_LIFETIME': timedelta(days=1),
}
```

Django REST FrameworkのJWT認証がうまくいかない

### 解決したいこと
- LINE広告APIドキュメントにある、[パフォーマンスレポートを作成するPOSTリクエスト](https://ads.line.me/public-docs/v3/3.9.1/certificated-ad-tech-general-partner#_createreport)をGAS（Google Apps Script）で動かしたい
- サンプルコードがPythonだったので、Pythonで書いてみたところ動いたが、これをGASでとなると思ったようにいかない

### 開発の背景
- LINE広告のパフォーマンスレポートをスプレッドシートに自動で書き出したい
- 他にGoogle広告やYahoo!広告のデータ抽出もすでにGASで実装しているため、できればGASで書きたい

### 発生しているエラー
```
Request failed for https://ads.line.me returned code 401.
Truncated server response: {"errors":[{"reason":"Unauthorized","message":"Request digest is invalid."}]}
```
エラーコードをドキュメントで調べてみると、
> 401　The token specified in 'Authorization' header is invalid.
「Authorization ヘッダーで指定されたトークンが無効」だと言われます。

ただ、Authorization ヘッダーに渡している`token` という変数の中身は、PythonでもGASでも一致しているんです...。ここが今一番混乱しているところです。

以下が「レスポンスが返ってくるPythonのコード」と「エラーで返ってくるGASのコード」です。
変数名も全体の構成もなるべく同じにしています。

#### Python
```Python
import base64
import datetime
import hashlib
import hmac
from inspect import signature
import json
import urllib.request
from datetime import datetime, timedelta

def calc_sha256_digest(content: str) -> str:
    sha256 = hashlib.new('sha256')
    sha256.update(content.encode())
    return sha256.hexdigest()

def encode_with_base64(value: bytes) -> str:
    return base64.urlsafe_b64encode(value).decode()

if __name__ == '__main__':
    # Setting parameters for your request
    today = datetime.now()
    yesterday = (today - timedelta(1)).strftime('%Y-%m-%d')
    accountId = "A00000000000"
    
    access_key = "XXXXXXXXXXXXXXXX"
    secret_key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    method = "POST"
    canonical_url = "/api/v3/adaccounts/" + accountId + "/pfreports"
    url_parameters = ""
    request_body = {
        "level":"ADACCOUNT",
        "since": yesterday,
        "until": yesterday,
        "filtering":{
            "idType":"ADACCOUNT",
            "ids":[accountId]
        },
        "fileFormat":"CSV"
    }
    has_request_body = request_body is not None

    endpoint = 'https://ads.line.me' + canonical_url + url_parameters
    request_body_json = json.dumps(request_body) if has_request_body else ""
    content_type = 'application/json' if has_request_body else ""

    jws_header = encode_with_base64(
        json.dumps({
            "alg": "HS256",
            "kid": access_key,
            "typ": "text/plain"
        }).encode()
    )

    hex_digest = calc_sha256_digest(request_body_json)
    payload_date = today.strftime('%Y%m%d')
    payload = "%s\n%s\n%s\n%s" % (hex_digest, content_type, payload_date, canonical_url)
    jws_payload = encode_with_base64(payload.encode())

    signing_input = "%s.%s" % (jws_header, jws_payload)
    signature = hmac.new(
        secret_key.encode(),
        signing_input.encode(),
        hashlib.sha256
    ).digest()
    encoded_signature = encode_with_base64(signature)
    token = "%s.%s.%s" % (jws_header, jws_payload, encoded_signature)
    print(token)

    http_headers = {
        "Date": today.strftime('%a, %d %b %Y %H:%M:%S GMT'),
        "Authorization": "Bearer %s" % token
    }
    if has_request_body:
        http_headers["Content-Type"] = content_type
        req = urllib.request.Request(endpoint, data=request_body_json.encode(), headers=http_headers, method=method)
    else:
        req = urllib.request.Request(endpoint, headers=http_headers, method=method)

    with urllib.request.urlopen(req) as res:
        resp = res.read()
    print(resp.decode())
```

#### GAS
```JavaScript
function main() {
  const today = new Date();
  const yesterday = getYesterday(new Date());
  const accountId = "A00000000000";

  const access_key = "XXXXXXXXXXXXXXXX";
  const secret_key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
  const method = "POST";
  const canonical_url = `/api/v3/adaccounts/${accountId}/pfreports`;
  const url_parameters = "";
  const request_body = {
    "level":"ADACCOUNT",
    "since":yesterday,
    "until":yesterday,
    "filtering": {
      "idType": "ADACCOUNT",
      "ids": [accountId]
    },
    "fileFormat": "CSV"
  };
  const has_request_body = request_body

  const endpoint = "https://ads.line.me" + canonical_url + url_parameters;
  const request_body_json = JSON.stringify(request_body).replace(/:/g, ': ').replace(/,/g, ', ');
  const content_type = "application/json";

  const jws_header = encode_with_base64(JSON.stringify({
    "alg":"HS256",
    "kid":access_key,
    "typ":"text/plain"
  }).replace(/:/g, ': ').replace(/,/g, ', '));
  
  const hex_digest = calc_sha256_digest(request_body_json);
  const payload_date = Utilities.formatDate(today, 'JST', 'yyyyMMdd');
  const payload = `${hex_digest}\n${content_type}\n${payload_date}\n${canonical_url}`;
  const jws_payload = encode_with_base64(payload);

  const signing_input = `${jws_header}.${jws_payload}`;
  const encoded_signature = hmacSha256(secret_key, signing_input);
  const token = `${jws_header}.${jws_payload}.${encoded_signature}`;
  console.log(token);

  const http_headers = {
    "Date": Utilities.formatDate(today, 'GMT', 'E, dd MMM yyyy HH:mm:ss z'),
    "Authorization": `Bearer ${token}`,
    "Content-Type":content_type
  }
  const resp = UrlFetchApp.fetch(endpoint, {
    "data": request_body_json,
    "headers": http_headers,
    "method": method,
  });
  console.log(resp.getContentText());
}

/**
 * SHA 256でハッシュ化
 * @param {string} input - ハッシュ化する文字列
 * @return {string} - ハッシュ値
 */
function calc_sha256_digest(input) {
  const rawHash = Utilities.computeDigest(Utilities.DigestAlgorithm.SHA_256, input, Utilities.Charset.UTF_8);
  let txtHash = '';
  for (i = 0; i < rawHash.length; i++) {
    let hashVal = rawHash[i];
    if (hashVal < 0) {
      hashVal += 256;
    }
    if (hashVal.toString(16).length == 1) {
      txtHash += '0';
    }
    txtHash += hashVal.toString(16);
  }
  return txtHash
}

/**
 * base64エンコード
 * @param {string} input - エンコードしたい文字列
 * @return {string} - base64エンコードされた文字列
 */
function encode_with_base64(input) {
  return Utilities.base64Encode(input, Utilities.Charset.UTF_8)
}

/**
 * HMAC SHA 256でハッシュ化
 * @param {string} key - ハッシュ化するシークレットキー
 * @param {string} text - ハッシュ化する文字列
 * @return {string} - ハッシュ値
 */
function hmacSha256(key, text) {
  const rowHash = Utilities.computeHmacSignature(Utilities.MacAlgorithm.HMAC_SHA_256, text, key);
  return Utilities.base64Encode(rowHash);
};

/**
 * 昨日の日付を計算
 * @param {date} date - 今日の日付
 * @return {date} - 昨日の日付（YYYY-MM-DD形式）
 */
function getYesterday(date) {
  date.setDate(date.getDate() - 1);
  const yesterday = Utilities.formatDate(date, 'JMT', 'yyyy-MM-dd');
  return yesterday
}
```

### エラーの原因っぽいところ
エラーメッセージ的には`token` が間違っているみたいなんですが...。
Pythonで`print(tokne)` とした結果と、GASで`console.log(token)` とした結果は完全に一致していました。

だとすると最後のHTTPリクエストのところなのかなと...。
Pythonだと
```Python
resp = urllib.request.Request(endpoint, data=request_body_json.encode(), headers=http_headers, method=method)
```
と書いていて、GASでは
```JavaScript
const resp = UrlFetchApp.fetch(endpoint, {
    "data": request_body_json,
    "headers": http_headers,
    "method": method,
  });
```
と書いているのですが、このあたりは自信がないです。

「Pythonは`request_body_json` をエンコードしてるけどこれってバイト列に変えてるってこと...？GAS（JavaScript）にバイト列ってあるっけ...？これ変換しないとだめなのか...？」となっています。

Pythonに関してはかなり知識不足なところがありますが、上記誤っている箇所がお分かりになる方いらっしゃいましたら、ご教示いただけるととても勉強になります...。よろしくお願いいたします...。

### 補足
この「LINE Ads APIのPython→GAS変換」は以前にも当サイトで質問させていただいたことがありました。
今回と直接関係するか分かりませんが、こちらも記載させていただきます。

[Pythonで書かれたLINE Ads APIのサンプルコードをGAS(JavaScript)に翻訳したい](https://teratail.com/questions/jh62abgfnivhpm)

JWT(JSON Web Token)