Zdalne-systemy-z-kit-uVPN/app.py

import datetime
from functools import wraps
from time import sleep
from flask import Flask, make_response, redirect, send_file, jsonify, request, render_template, url_for
import db
import os
from werkzeug.utils import secure_filename
import subprocess
import utils
import shutil
import config
import machines

app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = "squash"
app.config['STYLE_FOLDER'] = "style"
app.config['MAX_CONTENT_LENGTH'] = 1024 * 1024 * 512  # 512MB

utils.init_threads()

def login_required(f):
    @wraps(f)
    def login_function(*args, **kwargs):
        auth_token = request.cookies.get('auth_token')
        if auth_token != "" or auth_token is not None:
            if db.get_user_bytoken(auth_token) is None:
                return redirect("/login")
        return f(*args, **kwargs)
    return login_function

def is_logged(auth_token):
    if auth_token != "" or auth_token is not None:
        if db.get_user_bytoken(auth_token) is not None:
            return True
        
    return False

@app.route('/')
@login_required
def main():
    machines_all = db.get_machines()
    return render_template('index.html', ssh_port=config.webssh_port, machines=machines_all.machines)


@app.route('/login')
def login():
    if is_logged(request.cookies.get('auth_token')) is True:
        machines_all = db.get_machines()
        return render_template('index.html', ssh_port=config.webssh_port, machines=machines_all.machines)
    return render_template('login.html')


@app.route('/logout')
def logout():
    if is_logged(request.cookies.get('auth_token')) is True:
        db.del_auth_token(request.cookies.get('auth_token'))
        response = make_response(redirect('/'))
        response.delete_cookie('auth_token')
        return response
    return render_template('login.html')


@app.route('/images')
@login_required
def list_images():
    images_all = db.get_images()
    return render_template("images.html", images=images_all.images)


@app.route('/create')
@login_required
def create_conf():
    return render_template("create.html")


@app.route('/api/createconf', methods=['POST'])
@login_required
def create_conf_post():
    try:
        config_name = request.form['config_name']
        token_name = request.form['token_name']
        key_length = request.form['key_length']
        ip = request.form['ip']
        password = request.form['pass']
    except:
        return jsonify(message="400")
    if db.get_conf_id_name(config_name+".squashfs") is not None:
        return jsonify(message="400")
    if db.get_conf_id(token_name) is not None:
        return jsonify(message="400")
    folder = utils.generate_random_string(5)
    try:
        os.mkdir(os.path.join(os.getcwd(), 'configs', folder))
        authorized_keys_config = request.form['authorized_keys_config']
        authorized_keys_file = open(folder+"/authorized_keys", "w")
        authorized_keys_file.write(authorized_keys_config)
        authorized_keys_file.close()
    except:
        shutil.copy('./configs/authorized_keys',
                    './configs/' + folder+"/authorized_keys")

    script_path = os.path.join(os.getcwd(), 'configs', "create.sh")
    ini_path = os.path.join(os.getcwd(), 'configs', "uVPN.ini")
    conf_path = os.path.join(os.getcwd(), 'configs', "uVPN.conf")
    pub_path = os.path.join(os.getcwd(), 'configs', "server.pub")
    authorized_keys_path = os.path.join(
        os.getcwd(), 'configs', folder, "authorized_keys")
    sshd_config_path = os.path.join(os.getcwd(), 'configs', "sshd_config")
    sendmail_path = os.path.join(os.getcwd(), 'configs', "sendmail.sh")
    msmtp_conf = os.path.join(os.getcwd(), 'configs', "msmtprc")
    
    subprocess.run([script_path, "-i "+ini_path, "-c "+conf_path, 
                    "-k "+pub_path, "-l "+key_length, "-n"+config_name,
                    "-p "+ip, "-a "+authorized_keys_path, "-d "+sshd_config_path, 
                    "-m "+sendmail_path, "-o "+msmtp_conf," > /dev/null 2>&1 "])

    if os.path.exists(folder):
        shutil.rmtree(folder)
    output = subprocess.run(
        ['openssl', 'passwd', '-6', password], capture_output=True, text=True)
    db.add_conf_image(config_name+".squashfs", token_name, ip, output.stdout)

    return send_file(os.path.join(app.config['UPLOAD_FOLDER'], config_name+".pub"))


@app.route('/api/login', methods=['POST'])
def login_api():
    username = request.form['username']
    password = request.form['password']
    # register
    # db.add_user(username, password)
    # register
    auth_token = db.login(username, password)
    if auth_token is None:
        return render_template('login.html', incorrect="Incorrect username or password!")

    response = make_response(redirect('/'))
    response.set_cookie('auth_token', auth_token)
    return response


@app.route('/delete/<int:image_id>', methods=['POST'])
@login_required
def delete(image_id):
    if db.get_image_allocation(image_id) is not None:
        return jsonify(message="409")
    filename = db.get_conf_image_id(image_id)
    squashfs = os.path.join(app.config['UPLOAD_FOLDER'], filename)
    pubkey = os.path.join(
        app.config['UPLOAD_FOLDER'], filename.split(".")[0]+".pub")
    if os.path.exists(squashfs):
        os.remove(squashfs)
    if os.path.exists(pubkey):
        os.remove(pubkey)
    db.del_image(image_id)

    return redirect(url_for('list_images'))



@app.route('/download_key/<int:image_id>', methods=['POST'])
@login_required
def download_key(image_id):
    filename = db.get_conf_image_id(image_id)

    return send_file(os.path.join(
        app.config['UPLOAD_FOLDER'], filename.split(".")[0]+".pub"))


@app.route("/api/getconf")
def get_image():
    try:
        filename = db.get_conf_image(request.headers['token'])
    except:
        pass
    try:
        date = db.get_image_allocation_time(request.headers['token'])
        if date is not None:
            delta = datetime.datetime.now() - date
            if delta.total_seconds() > 30:
                db.del_image_allocation_token(request.headers['token'])
            else:
                filename = None
        else:
            db.set_image_allocation(
                request.headers['token'], request.remote_addr)
    except:
        pass

    if filename is None or filename == "":
        filename = config.default_file

    return send_file(os.path.join(app.config['UPLOAD_FOLDER'], filename))


@app.route("/api/getpass")
def get_pass():
    try:
        password = db.get_conf_password(request.headers['token'])
        return password
    except:
        return ""


@app.route("/api/release_allocation", methods=['POST'])
def release_allocation():
    try:
        id_allocation = db.get_conf_id_name(
            request.headers['name']+".squashfs")
        if id_allocation is None or id_allocation == "":
            return jsonify(message="400")
    except:
        return jsonify(message="400")
    if id_allocation is not None:
        db.del_image_allocation_id_image(id_allocation)
    else:
        return jsonify(message="404")

    return jsonify(message="200")


@app.route("/api/addip", methods=['POST'])
def add_ip():
    try:
        token = request.headers['token']
        ip = request.form['ip']
        if utils.is_valid_ip_address(ip) is False:
            return jsonify(message="400")
    except:
        return jsonify(message="400")
    if db.update_image_allocation_ip_vpn(token, ip) is not None:
        return jsonify(message="200")
    else:
        return jsonify(message="400")


@app.route("/style/<string:name>")
def get_style(name):
    try:
        return send_file(os.path.join(app.config['STYLE_FOLDER'], name))
    except:
        return "", 404

if __name__ == '__main__':
    app.run(host="0.0.0.0")