常連

正直、結論の出づらい内容ですが質問させていただきます。

Tokenの保管方法として、

* cookie
* localstrage

が挙げられますが、**localstrageがだめだと言っている情報がかなり多いです**。

自分はJWTを保管しようかと考えています。

localstrageはCSRFに対して脆弱性がない反面、XSSに弱いということだそうです。

しかし、Reactなどのきちんとメンテナンスされているライブラリの場合、XSSに対する脆弱性がないようなものだと思います。きちんとスクリプトをエスケープするはずですし。

入力値をそのまま反映させるdangerous~HTMLを使うなどしなければ、localstrageが優秀に感じますがどうなのでしょうか？

cookieだと、CSRFに対して弱いということが心配なので、localstrageをメンテンナンスサれているJSライブラリで用いて良いでしょうか？

JWTなどのTokenをlocalstrage(HTML5の)に保管することについて

### 実現したいこと
レスポンスヘッダーのSet-CookieにあるtokenをCookieに格納したい

### 前提
フロントエンド: React(v18), TypeScript, AWS Amplify
バックエンド: Python(v3.10),FastAPI, AWS app runner
認証ライブラリ: FastAPI JWT Auth
https://indominusbyte.github.io/fastapi-jwt-auth/usage/jwt-in-cookies/

ログインして利用するWebアプリケーションでフロントエンドとバックエンドは別々にデプロイしています。
ログイン後は、各エンドポイントごとでトークンチェックを行い、認証できない場合はトップ画面(ログイン前）へ遷移します。

### 発生している問題・エラーメッセージ
サーバーサイド側からSet-Cookieでクライアントにtokenを渡してもCookieにセットされず、次の画面で弾かれてトップ画面に戻ってしまう
（ログイン自体は成功してレスポンスが帰ってきます。）

ブラウザのデベロッパーツールでは、レスポンスヘッダーのSet-Cookieでトークンは確認できるが、！マークが表示されておりマウスホバーすると下記のメッセージが表示される

```
このSet-Cookie ヘッダーは、「SameSite」属性を指定しておらず、
デフォルトで「SameSite=Lax,」に設定されていましたが、トップレベルナビゲーション
へのレスポンスではないクロスサイト レスポンスが送信元だったため、
ブロックされました。Set-Cookieには「SameSite=None」を設定し、
クロスサイトでの使用を有効にしておく必要があります。
```

### 該当のソースコード
```
@app.exception_handler(HTTPException)
@router.post(
    "/api/v1/user/login",
    summary="ログイン"
)
def user_login(
    data: UserLoginSchema,
    db: Session = Depends(raw_db),
    Authorize: AuthJWT = Depends(),
):
    try:
        
        user_login_res = AuthService.user_login(data, db, Authorize)
        if user_login_res["res"] == True:
            return user_login_res["data"]
        else:
            return JSONResponse(status_code=400, content={"error": user_login_res["message"]})
        
    except HTTPException as e:
        logger.error(e.message)
        return JSONResponse(status_code=400, content={"error": "システムエラーが発生しました。"})
```
```
class AuthService:
    # ログイン
    @staticmethod
    def user_login(
        data: UserLoginSchema,
        raw_db: Session,
        Authorize: AuthJWT,
    ):

        # ~省略~

        # email、パスワードが一致すればトークンを発行
        issue_token(user.id, user.tenant_id, Authorize)

        
        data = {
                "result": True,
                "message": "Successfully login",
                "user_id": user.id,
        }
            return {"res": True, "data": data}
        
        else:
            return {"res": False, "message": "ログイン情報が正しくありません。"}
```

```ここに言語名を入力
def issue_token(
        user_id: int, 
        tenant_id:  int, 
        Authorize: AuthJWT
    ):
    user_claims = {
        "tenant_id": tenant_id,
    }
    access_token = Authorize.create_access_token(
        subject=user_id,
        user_claims=user_claims,
        expires_time=timedelta(hours=1),
    )
    refresh_token = Authorize.create_refresh_token(subject=user_id)

    Authorize.set_access_cookies(access_token)
    Authorize.set_refresh_cookies(refresh_token)
```
```
class UserLoginSchema(BaseModel):
    email: EmailStr
    password: str
```
```
authjwt_secret_key = "secret"
authjwt_token_location = {"cookies"}
authjwt_cookie_secure = True
authjwt_cookie_csrf_protect = True
```

### 試したこと
エラーメッセージに従いsamesiteをnoneにする

①FastAPI JWT Authのオプションを追加
```
authjwt_cookie_samesite = "none"
```
②直接設定を変える
```
def issue_token(
        user_id: int,
        tenant_id:  int,
        Authorize: AuthJWT,
        res: Response = None
    ):
    user_claims = {
        "tenant_id": tenant_id,
    }
    access_token = Authorize.create_access_token(
        subject=user_id,
        user_claims=user_claims,
        expires_time=timedelta(hours=24),
    )
    refresh_token = Authorize.create_refresh_token(subject=user_id)

    res.set_cookie(
        key="access_token_cookie",
        value=access_token,
        httponly=True,
        samesite="None",  # SameSite=None を指定
        secure=True,      # HTTPS 接続でのみクッキーを送信
    )

    res.set_cookie(
        key="refresh_token_cookie",
        value=refresh_token,
        httponly=True,
        samesite="None",  # SameSite=None を指定
        secure=True,      # HTTPS 接続でのみクッキーを送信
    )
```

上記２つのパターンを試したところ、最初の認証はできるようになりログイン後の一番最初の画面は見れるようになりました。
ただブラウザのCookieに格納されない現象は改善できておらず、次のエンドポイントで弾かれてしまいます。

こちらについて、解決策をご存知の方がいらっしゃいましたらお力を貸していただけないでしょうか。

同様にCookieに格納されないにも関わらず上記の設定変更で、一番最初の画面が見れるようになった理由もわかっていません。

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

参考にした記事
https://qiita.com/sotaheavymetal21/items/fb7ae0e5d09c7b16a3c7


レスポンスヘッダーのSet-CookieにあるtokenをCookieに格納したい

### 実現したいこと

JWTのトークンを使って/home (Protected ルート)にアクセスしたい

### 前提

Flaskでログイン機能を作っています。
Headersに "Authorization" : "Bearer <token>"という形で/homeというルートにアクセスするためのリクエストを送ると、トークンが承認され、一瞬だけアクセスすることができるのですが、すぐ"Token Missing" 401のエラーとともにキックアウトされてしまいます。

### 発生している問題・エラーメッセージ
```
"Token is missing!" (トークンが見当たりません）４０１ERROR
```
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-04-22/06dde448-32d2-4012-9673-d85b3631d057.png)

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

この関数がheadersからトークンを受け取り、チェックするものです。
```Python 
def token_required(func):
    @wraps(func)
    def decorated(*args,**kwargs):
        token = None
        if 'Authorization' in request.headers:
            token = request.headers['Authorization'].split(' ')[1]
            print(token)
        if not token:
            return jsonify({'Alert!' : 'Token is missing!'}),401
        try:
            data = jwt.decode(token, app.config['SECRET_KEY'],algorithms=["HS256"])
            print(data)
        except jwt.ExpiredSignatureError:
            print("Expired!")
            return jsonify({'message': 'Token has expired'}),401
        except jwt.InvalidTokenError:
            print('Invalid token')
            return jsonify({'Alert!' : 'Invalid token!'}),401
        return func(*args,**kwargs)
    return decorated
```
バックエンド側のログインの関数
```Python
@app.route('/auth/login',methods=['GET','POST'])
def loginUser():
    if request.method == 'POST':
        data = request.get_json()
        username = data['username']
        password = data['password']
        if not data or not username or not password:
            return jsonify({'message': 'Missing required fields'}), 400
        if check_username_exist(username) and checkPassword(get_userID(username),password):       
            token = jwt.encode({
            'user':username,
            'exp': datetime.utcnow() + timedelta(hours=1)},app.config['SECRET_KEY'],algorithm='HS256')
            return make_response(jsonify({'token': token}),200)
        else:
            return jsonify({'message': 'Password is incorrect'}),400
    return jsonify({'message': 'Could not verify', 'WWW-Authenticate': 'Basic auth="Login required"'}), 401
```

フロントエンド側のログインの関数
```python
$(document).ready(function () {
        $("form").on("submit", function (event) {
          const userInfo = {
            username: $("#username").val(),
            password: $("#password").val(),
          };
          $.ajax({
            type: "post",
            url: "http://127.0.0.1:5000/auth/login",
            dataType: "json",
            contentType: "application/json",
            data: JSON.stringify(userInfo),
            success: function (result) {
              const token = result.token
              localStorage.setItem("token", token);
              $.ajax({
                url: "http://127.0.0.1:5000/home",
                type: "GET",
                headers: {
                  "Authorization": "Bearer " + localStorage.getItem("token"),
                  "Content-Type": "application/json",
                },
                success: function () {
                  window.location.href = "/home";
                },
                error: function (jqXHR, textStatus, errorThrown) {
                  console.log(errorThrown);
                  alert("Error: " + textStatus);
                },
              });
            },
            error: function (xhr, status, error) {
              console.log(xhr.responseText);
              alert("Error: " + error);
            },
          });
          event.preventDefault();
        });
      });
```

### 試したこと
OAuthLib の設定が必要という記事をみて試してみたのですがだめでした。
しっかりトークンが承認されているのも確認でき、しっかり200が帰ってくるのですが、その後４０１が帰ってきます。
Expireの時間も１時間に伸ばしてみましたが、だめでした。

ここ二日間この問題で詰まっています。誰かわかる方がいたら教えてほしいです。お願いします。




JWTのトークンを使って/home (Protected ルート)にアクセスしたい

### 実現したいこと

ここに実現したいことを箇条書きで書いてください。
- [ ] 表記の環境でエラーが発生します。エラーを解決し、Webサービスを正常に稼働させたいと考えています。エラーはjwtパッケージで発生しており回避したいのですが、ログイン認証のためアプリケーションに組み込む必要があります。

### 前提

環境情報
OS: Linuxサーバ
プラットフォーム: AWS
Apache/2.4.51
Python 3.7.10
Flask Version: 1.1.2


```mod_wsgiコマンドの実行結果
mod_wsgi-express module-config
LoadModule wsgi_module "/usr/local/lib64/python3.7/site-packages/mod_wsgi/server/mod_wsgi-py37.cpython-37m-x86_64-linux-gnu.so"
WSGIPythonHome "/usr"
```


```httpd/conf.d/flask.conf
LoadModule wsgi_module /usr/local/lib64/python3.7/site-packages/mod_wsgi/server/mod_wsgi-py37.cpython-37m-x86_64-linux-gnu.so

WSGIPythonPath /var/www/html/(ProjectPath)
<VirtualHost *:80>
    ServerName xxx
    DocumentRoot /var/www/html/(ProjectPath)
    WSGIDaemonProcess xxx user=apache group=apache threads=5
    WSGIScriptAlias / /var/www/html/(ProjectPath)/(ProjectName).wsgi
    WSGIScriptReloading On
    <Directory "/var/www/html/(ProjectPath)">
        WSGIProcessGroup (ProjectName)
        WSGIApplicationGroup %{GLOBAL}
        Order deny,allow
        Allow from all
    </Directory>
</VirtualHost>
~
```

``` ProjectName.wsgi
import os, sys
import logging
logging.basicConfig(stream = sys.stderr)
sys.path.insert(0, '/var/www/html/(ProjectPath)')

from run import app as application
```


```pip info
$ pip show jwt
WARNING: Package(s) not found: jwt
pip show PyJWT
Name: PyJWT
Version: 2.7.0
Summary: JSON Web Token implementation in Python
Home-page: https://github.com/jpadilla/pyjwt
Author: Jose Padilla
Author-email: hello@jpadilla.com
License: MIT
Location: /home/(UserName)/.local/lib/python3.7/site-packages
Requires: typing-extensions
Required-by:
```


以下のエラーが発生します。
mod_wsgi (pid=23285): Failed to exec Python script file '/var/www/html/(ProjectPath)/(ProjectName).wsgi'., referer: http://(IP address)/login
mod_wsgi (pid=23285): Exception occurred processing WSGI script '/var/www/html/(ProjectPath)/(ProjectName).wsgi'., referer: http://(IP address)/login
Traceback (most recent call last):, referer: http://(IP address)/login
File "/var/www/html/(ProjectPath)/(ProjectName).wsgi", line 7, in <module>, referer: http://(IP address)/login
from run import app as application, referer: http://(IP address)/login
File "/var/www/html/(ProjectPath)/run.py", line 1, in <module>, referer: http://(IP address)/login
from app.app import app, referer: http://(IP address)/login
File "/var/www/html/(ProjectPath)/app/app.py", line 26, in <module>, referer: http://(IP address)/login
import jwt, referer: http://(IP address)/login
ModuleNotFoundError: No module named 'jwt', referer: http://(IP address)/login

Web画面はInternal Server Errorとなります。



### 試したこと

エラーではjwtパッケージが見つからないとなっていますが、調査していたところjwtとPyJWT共存の問題があるようで、PyJWTのみ入った状態にしています。

jwtパッケージを入れた場合でもエラーは発生します。

この状態で、Python3 run.pyとすると問題なく動作します。

そのため、mod_wsgiから参照しているPythonが怪しいと考えています。

そこで、mod_wsgiコマンドで出力された内容をLoadModuleへ設定されているか確認しています。







Linux+Apache+mod_wsgi+Flask環境でApache経由でのみ発生するModuleNotFoundError (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を生成したい

### 解決したいこと
- 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)

【GAS】Pythonならきちんと動いてるLINE Ads APIのHTTPリクエストをGASでも動かしたい

前置きしますと、理解が追いついていない面が多々あるので支離滅裂な内容になっているかもしれないですが宜しくお願いします。

普段Railsアプリを作る際は`devise`を使用して認証機能を作成していました。
ただdeviseはsession認証である為、そのwebアプリをモバイルでも使用したい場合の展開が難しいと言うことで、冬休みを使ってtoken認証を試すべく、[devise_token_auth](https://devise-token-auth.gitbook.io/devise-token-auth/usage)を使用してアプリを作っています。


しかしtoken認証(devise-token-auth)の概念が掴めず、またどうtokenを用いて認証ありのwebアプリを作っていったらいいのか分かりません。
またdeviseと同じくdevise-token-authにもuser_signed_in?等のメソッドが用意されていますが、これがどのようにログインしたユーザーのレコードを取っているかが分かりません。
web上の情報ですとcurlやpostmanを叩いて、200が返ってきたね！という情報ばかりで、これをどうwebアプリ上で展開したら良いかということが分からず混乱しております。
またsession認証は認証が成功したらcookieにログイン情報を保存し、次回以降クライアントがサーバーにアクセスしたら、cookieの情報とサーバーが持っているsession情報と照合して本人かどうか担保するということが感覚的には分かりやすいのですが、token認証はどうも勝手が違うようでよく分からないです。


それを踏まえてまず第一の質問です。

**１.**
devise-token-authを用いて、ログイン(認証系処理へのpost)を行うとresponse headerには`access_token`が返ってくると思います。
access_tokenは飽くまでも認証に成功したという文字通りの印だと思いますが、これはブラウザ上、もしくはDBのどこかに保存したり保持する必要はあるのでしょうか？
tokenの情報はブラウザで保持せず、次の画面等に遷移する際、リクエストヘッダーにこのtokenを含めて使うと、token認証を説明しているウェブページには書いてあったのですが、
つまりログインしているかどうか担保するには何かの画面を見るたびにリクエストにこのaccess_tokenを含ませる、またサーバーからクライアント側に渡すといった処理を書かなきゃいけないのでしょうか？(例えばwebならjavscriptか何かで)
それともdevise-token-authがよしなにやってくれる仕組みを持っているのでしょうか？

またこれに含め第二の質問なのですが

**２.**
```
if user_signed_in?
    @name = current_user.name
end
```
例えばuser_signed_in?はログインしているかどうかbooleanで返す、プレーンなdeviseでもお馴染みなメソッドだと思うのですが、devise-token-authでは`request`にaccess_tokenが含まれているかどうか特に何も処理を書かずとも判別してくれるメソッドと言う解釈でよろしいでしょうか？


長くなってしまいましたが、分からないことが分からないと言う感じの質問になってしまい大変恐縮です。
お手数をおかけしますがご回答をよろしくお願いします。

(rails)devise-token-authを試しているがtoken認証の仕組みがいまいち分からない

ググッても解決しなかったので質問させていただきます。

JsonWebTokenには

* access
* refresh

の二種類があり、両方をcookieに保存するとした場合、意味がわからなくなりました。
再生回数の多い海外のYoutube動画でそうしていました。

JWTは、
永久に使えるtokenが危険だから期限があり、
期限の短いものをリフレッシュさせるトークンもあり、
改ざんしづらいように署名もある

というのはわかりますが、
だからといって二種類のTokenが必要なのでしょうか？

accessのみを利用して、期限を長期間（一ヶ月）にすればいいと思ってしまいました。

ただ、そうしたときにJWTではaccessのみで期限を伸ばすリフレッシュができないため、refreshも用意し、それならばaccessは期限を短くして使おう、ということでしょうか？

JWT(JSON Web Token)