Repository navigation
Expand file tree
/
Copy pathapp.py
More file actions
176 lines (140 loc) · 5.88 KB
/
Copy pathapp.py
File metadata and controls
176 lines (140 loc) · 5.88 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
from flask import Flask, render_template, request, redirect, url_for, session, jsonify, abort
from flask_wtf import FlaskForm, CSRFProtect
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
from dotenv import load_dotenv
import os
import hmac
import hashlib
import requests
load_dotenv()
app = Flask(__name__)
app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'dev-secret')
# CSRF
csrf = CSRFProtect(app)
# Login manager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
# Rate limiter
limiter = Limiter(key_func=get_remote_address, app=app, default_limits=["200 per day", "50 per hour"])
class SimpleLoginForm(FlaskForm):
username = StringField('Username', validators=[DataRequired()])
password = PasswordField('Password', validators=[DataRequired()])
submit = SubmitField('Login')
class User(UserMixin):
def __init__(self, id):
self.id = id
@login_manager.user_loader
def load_user(user_id):
return User(user_id)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/login', methods=['GET', 'POST'])
def login():
form = SimpleLoginForm()
if form.validate_on_submit():
# simple env-based credential check (for demo only)
expected_user = os.getenv('DEMO_USER', 'demo') # You would store these in a database, with an encrypted password
expected_pass = os.getenv('DEMO_PASS', 'demo')
if form.username.data == expected_user and form.password.data == expected_pass:
user = User(form.username.data)
login_user(user)
session['username'] = form.username.data
return redirect(url_for('protected'))
else:
return render_template('login.html', form=form, error='Invalid credentials')
return render_template('login.html', form=form)
@app.route('/logout')
@login_required
def logout():
logout_user()
session.clear()
return redirect(url_for('index'))
@app.route('/protected')
@login_required #Must be logged in to access
def protected():
return render_template('protected.html', user=current_user) #Passes information from the app to the html template
# Example webhook endpoint (no auth, just demonstrates receiving JSON)
# For example, if you're using an external service like a calendar app, it can send information here for you to handle in your app
# This route has signature validation to ensure only the right requests are processed
@app.route('/webhook', methods=['POST'])
@limiter.limit('10 per minute')
@csrf.exempt
def webhook():
# Read raw body for signature verification
payload_bytes = request.get_data()
# Check signature header(s) - support common header names
sig_header = request.headers.get('X-Signature') or request.headers.get('X-Hub-Signature-256') or request.headers.get('X-Hub-Signature')
def verify_webhook_signature(secret: str, payload: bytes, header: str) -> bool:
"""Verify HMAC SHA256 signature.
Expects header like: 'sha256=hexdigest' or raw hexdigest.
"""
if not secret or not header:
return False
# Normalize header
if header.startswith('sha256='):
header_val = header.split('=', 1)[1]
else:
header_val = header
computed = hmac.new(secret.encode('utf-8'), payload, hashlib.sha256).hexdigest()
return hmac.compare_digest(computed, header_val)
webhook_secret = os.getenv('WEBHOOK_SECRET')
if webhook_secret:
if not verify_webhook_signature(webhook_secret, payload_bytes, sig_header):
return jsonify({'error': 'Invalid signature'}), 401
if not request.is_json:
return jsonify({'error': 'Expected JSON payload'}), 400
payload = request.get_json()
# In a real app you'd verify signatures and process the payload
print('Received webhook:', payload)
return jsonify({'status': 'received'}), 200
# Simple API endpoint with token auth
def token_required(f):
def wrapper(*args, **kwargs):
token = request.headers.get('X-API-KEY') or request.args.get('api_key')
expected = os.getenv('API_KEY', 'secret-token')
if not token or token != expected:
return jsonify({'error': 'Unauthorized'}), 401
return f(*args, **kwargs)
wrapper.__name__ = f.__name__
return wrapper
# API endpoint for other servers to get information from your server
@app.route('/api/data')
@limiter.limit('30 per minute')
@token_required
def api_data():
sample = {'data': 'This is example API data', 'user': session.get('username')}
return jsonify(sample)
@app.route('/demo/get')
def demo_get():
"""Server-side demo: perform a GET to a target URL and return the result.
Query params:
- url: target URL (default https://httpbin.org/get)
- api_key: optional API key to send in X-API-KEY header
"""
target = request.args.get('url', 'https://httpbin.org/get')
api_key = request.args.get('api_key')
headers = {}
if api_key:
headers['X-API-KEY'] = api_key
try:
resp = requests.get(target, headers=headers, timeout=10)
except Exception as e:
print('demo_get: request failed', target, str(e))
return jsonify({'error': 'request failed', 'detail': str(e)}), 500
# Try to return JSON if possible
content_type = resp.headers.get('content-type', '')
try:
body = resp.json()
print('demo_get: got', target, resp.status_code)
return jsonify({'status': resp.status_code, 'json': body})
except Exception:
print('demo_get: got text', target, resp.status_code)
return jsonify({'status': resp.status_code, 'text': resp.text})
if __name__ == '__main__':
app.run(debug=True)