1
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
2
eyJlbWFpbCI6Imhpcm9AZ21haWwuY29tIn0.
3
WAKjPd_0qcEG3dA9pEwAiw-0ADb8VwqFlSWiIYJTymo

1
from flask import Flask, jsonify, request
2
from flask_jwt_extended import (
3
    JWTManager, jwt_optional, create_access_token,
4
    get_jwt_identity
5
)
6

7
app = Flask(__name__)
8

9
# Setup the Flask-JWT-Extended extension
10
app.config['JWT_SECRET_KEY'] = 'super-secret'  # Change this!
11
jwt = JWTManager(app)
12

13

14
@app.route('/login', methods=['POST'])
15
def login():
16
    username = request.json.get('username', None)
17
    password = request.json.get('password', None)
18
    if not username:
19
        return jsonify({"msg": "Missing username parameter"}), 400
20
    if not password:
21
        return jsonify({"msg": "Missing password parameter"}), 400
22

23
    if username != 'test' or password != 'test':
24
        return jsonify({"msg": "Bad username or password"}), 401
25

26
    access_token = create_access_token(identity=username)
27
    return jsonify(access_token=access_token), 200
28

29

30
@app.route('/partially-protected', methods=['GET'])
31
@jwt_optional
32
def partially_protected():
33
    # If no JWT is sent in with the request, get_jwt_identity()
34
    # will return None
35
    current_user = get_jwt_identity()
36
    if current_user:
37
        return jsonify(logged_in_as=current_user), 200
38
    else:
39
        return jsonify(logged_in_as='anonymous user'), 200
40

41

42
if __name__ == '__main__':
43
    app.run()

1
from flask import Flask, request, jsonify
2

3
from flask_jwt_extended import (
4
    JWTManager, jwt_required, get_jwt_identity,
5
    create_access_token, create_refresh_token,
6
    jwt_refresh_token_required, get_raw_jwt
7
)
8

9

10
# Setup flask
11
app = Flask(__name__)
12

13
# Enable blacklisting and specify what kind of tokens to check
14
# against the blacklist
15
app.config['JWT_SECRET_KEY'] = 'super-secret'  # Change this!
16
app.config['JWT_BLACKLIST_ENABLED'] = True
17
app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['access', 'refresh']
18
jwt = JWTManager(app)
19

20
# A storage engine to save revoked tokens. In production if
21
# speed is the primary concern, redis is a good bet. If data
22
# persistence is more important for you, postgres is another
23
# great option. In this example, we will be using an in memory
24
# store, just to show you how this might work. For more
25
# complete examples, check out these:
26
# https://github.com/vimalloc/flask-jwt-extended/blob/master/examples/redis_blacklist.py
27
# https://github.com/vimalloc/flask-jwt-extended/tree/master/examples/database_blacklist
28
blacklist = set()
29

30

31
# For this example, we are just checking if the tokens jti
32
# (unique identifier) is in the blacklist set. This could
33
# be made more complex, for example storing all tokens
34
# into the blacklist with a revoked status when created,
35
# and returning the revoked status in this call. This
36
# would allow you to have a list of all created tokens,
37
# and to consider tokens that aren't in the blacklist
38
# (aka tokens you didn't create) as revoked. These are
39
# just two options, and this can be tailored to whatever
40
# your application needs.
41
@jwt.token_in_blacklist_loader
42
def check_if_token_in_blacklist(decrypted_token):
43
    jti = decrypted_token['jti']
44
    return jti in blacklist
45

46

47
# Standard login endpoint
48
@app.route('/login', methods=['POST'])
49
def login():
50
    username = request.json.get('username', None)
51
    password = request.json.get('password', None)
52
    if username != 'test' or password != 'test':
53
        return jsonify({"msg": "Bad username or password"}), 401
54

55
    ret = {
56
        'access_token': create_access_token(identity=username),
57
        'refresh_token': create_refresh_token(identity=username)
58
    }
59
    return jsonify(ret), 200
60

61

62
# Standard refresh endpoint. A blacklisted refresh token
63
# will not be able to access this endpoint
64
@app.route('/refresh', methods=['POST'])
65
@jwt_refresh_token_required
66
def refresh():
67
    current_user = get_jwt_identity()
68
    ret = {
69
        'access_token': create_access_token(identity=current_user)
70
    }
71
    return jsonify(ret), 200
72

73

74
# Endpoint for revoking the current users access token
75
@app.route('/logout', methods=['DELETE'])
76
@jwt_required
77
def logout():
78
    jti = get_raw_jwt()['jti']
79
    blacklist.add(jti)
80
    return jsonify({"msg": "Successfully logged out"}), 200
81

82

83
# Endpoint for revoking the current users refresh token
84
@app.route('/logout2', methods=['DELETE'])
85
@jwt_refresh_token_required
86
def logout2():
87
    jti = get_raw_jwt()['jti']
88
    blacklist.add(jti)
89
    return jsonify({"msg": "Successfully logged out"}), 200
90

91

92
# This will now prevent users with blacklisted tokens from
93
# accessing this endpoint
94
@app.route('/protected', methods=['GET'])
95
@jwt_required
96
def protected():
97
    return jsonify({'hello': 'world'})
98

99
if __name__ == '__main__':
100
    app.run()