ddmail-webapp 0.0.1__py3-none-any.whl

ddmail_webapp/__init__.py

@@ -0,0 +1,210 @@
+import os
+import sys
+import logging
+import toml
+from flask import Flask
+from flask_wtf.csrf import CSRFProtect
+from logging.config import dictConfig
+from logging import FileHandler
+
+def create_app(config_file=None, test_config=None):
+    """Create and configure an instance of the Flask application ddmail."""
+    # Configure logging.
+    log_format = '[%(asctime)s] %(levelname)s in %(module)s %(funcName)s %(lineno)s: %(message)s'
+    dictConfig({
+        'version': 1,
+        'formatters': {'default': {
+            'format': log_format
+        }},
+        'handlers': {
+            'wsgi': {
+                'class': 'logging.StreamHandler',
+                'stream': 'ext://flask.logging.wsgi_errors_stream',
+                'formatter': 'default',
+            },
+        },
+        'root': {
+            'level': 'INFO',
+            'handlers': ['wsgi']
+        }
+    })
+
+    app = Flask(__name__, instance_relative_config=True)
+
+    toml_config = None
+
+    # Check if config_file has been set.
+    if config_file is None:
+        print("Error: you need to set path to configuration file in toml format")
+        sys.exit(1)
+
+    # Parse toml config file.
+    with open(config_file, 'r') as f:
+        toml_config = toml.load(f)
+
+    # Set app configurations from toml config file.
+    mode = os.environ.get('MODE')
+    print("Running in MODE: " + mode)
+
+    # Apply configuration for the specific MODE.
+    if mode == "PRODUCTION":
+        app.config["SECRET_KEY"] = toml_config["PRODUCTION"]["SECRET_KEY"]
+        app.config['SQLALCHEMY_DATABASE_URI'] = toml_config["PRODUCTION"]['SQLALCHEMY_DATABASE_URI']
+        app.config["WTF_CSRF_SECRET_KEY"] = toml_config["PRODUCTION"]["WTF_CSRF_SECRET_KEY"]
+
+        # Configure services that ddmail_webapp depend on. 
+        app.config["EMAIL_REMOVER_URL"] = toml_config["PRODUCTION"]["EMAIL_REMOVER_URL"]
+        app.config["EMAIL_REMOVER_PASSWORD"] = toml_config["PRODUCTION"]["EMAIL_REMOVER_PASSWORD"]
+        app.config["DMCP_KEYHANDLER_URL"] = toml_config["PRODUCTION"]["DMCP_KEYHANDLER_URL"]
+        app.config["DMCP_KEYHANDLER_PASSWORD"] = toml_config["PRODUCTION"]["DMCP_KEYHANDLER_PASSWORD"]
+        app.config["OPENPGP_KEYHANDLER_URL"] = toml_config["PRODUCTION"]["OPENPGP_KEYHANDLER_URL"]
+        app.config["OPENPGP_KEYHANDLER_PASSWORD"] = toml_config["PRODUCTION"]["OPENPGP_KEYHANDLER_PASSWORD"]
+
+        # Configure payment information.
+        app.config["PAYMENT_MAIL_NAME"] = toml_config["PRODUCTION"]["PAYMENT_MAIL_NAME"]
+        app.config["PAYMENT_MAIL_ADDRESS"] = toml_config["PRODUCTION"]["PAYMENT_MAIL_ADDRESS"]
+        app.config["PAYMENT_MAIL_POSTCODE"] = toml_config["PRODUCTION"]["PAYMENT_MAIL_POSTCODE"]
+        app.config["PAYMENT_MAIL_COUNTRY"] = toml_config["PRODUCTION"]["PAYMENT_MAIL_COUNTRY"]
+        
+        # Configure dns record checked when adding account/own domains.
+        app.config["MX_RECORD_HOST"] = toml_config["PRODUCTION"]["MX_RECORD_HOST"]
+        app.config["MX_RECORD_PRIORITY"] = toml_config["PRODUCTION"]["MX_RECORD_PRIORITY"]
+        app.config["SPF_RECORD"] = toml_config["PRODUCTION"]["SPF_RECORD"]
+        app.config["DKIM_RECORD"] = toml_config["PRODUCTION"]["DKIM_RECORD"]
+        app.config["DMARC_RECORD"] = toml_config["PRODUCTION"]["DMARC_RECORD"]
+
+        # Configure logfile.
+        file_handler = FileHandler(filename=toml_config["PRODUCTION"]["LOGFILE"])
+        file_handler.setFormatter(logging.Formatter(log_format))
+        app.logger.addHandler(file_handler)
+        
+        # Configure loglevel.
+        if toml_config["PRODUCTION"]["LOGLEVEL"] == "ERROR":
+            app.logger.setLevel(logging.ERROR)
+        elif toml_config["PRODUCTION"]["LOGLEVEL"] == "WARNING":
+            app.logger.setLevel(logging.WARNING)
+        elif toml_config["PRODUCTION"]["LOGLEVEL"] == "INFO":
+            app.logger.setLevel(logging.INFO)
+        elif toml_config["PRODUCTION"]["LOGLEVEL"] == "DEBUG":
+            app.logger.setLevel(logging.DEBUG)
+        else:
+            print("Error: you need to set LOGLEVEL to ERROR/WARNING/INFO/DEBUG")
+            sys.exit(1)
+    elif mode == "TESTING":
+        app.config["SECRET_KEY"] = toml_config["TESTING"]["SECRET_KEY"]
+        app.config['SQLALCHEMY_DATABASE_URI'] = toml_config["TESTING"]['SQLALCHEMY_DATABASE_URI']
+        app.config["WTF_CSRF_SECRET_KEY"] = toml_config["TESTING"]["WTF_CSRF_SECRET_KEY"]
+
+        # Configure services that ddmail_webapp depend on. 
+        app.config["EMAIL_REMOVER_URL"] = toml_config["TESTING"]["EMAIL_REMOVER_URL"]
+        app.config["EMAIL_REMOVER_PASSWORD"] = toml_config["TESTING"]["EMAIL_REMOVER_PASSWORD"]
+        app.config["DMCP_KEYHANDLER_URL"] = toml_config["TESTING"]["DMCP_KEYHANDLER_URL"]
+        app.config["DMCP_KEYHANDLER_PASSWORD"] = toml_config["TESTING"]["DMCP_KEYHANDLER_PASSWORD"]
+        app.config["OPENPGP_KEYHANDLER_URL"] = toml_config["TESTING"]["OPENPGP_KEYHANDLER_URL"]
+        app.config["OPENPGP_KEYHANDLER_PASSWORD"] = toml_config["TESTING"]["OPENPGP_KEYHANDLER_PASSWORD"]
+
+        # Configure payment information.
+        app.config["PAYMENT_MAIL_NAME"] = toml_config["TESTING"]["PAYMENT_MAIL_NAME"]
+        app.config["PAYMENT_MAIL_ADDRESS"] = toml_config["TESTING"]["PAYMENT_MAIL_ADDRESS"]
+        app.config["PAYMENT_MAIL_POSTCODE"] = toml_config["TESTING"]["PAYMENT_MAIL_POSTCODE"]
+        app.config["PAYMENT_MAIL_COUNTRY"] = toml_config["TESTING"]["PAYMENT_MAIL_COUNTRY"]
+        
+        # Configure dns record checked when adding account/own domains.
+        app.config["MX_RECORD_HOST"] = toml_config["TESTING"]["MX_RECORD_HOST"]
+        app.config["MX_RECORD_PRIORITY"] = toml_config["TESTING"]["MX_RECORD_PRIORITY"]
+        app.config["SPF_RECORD"] = toml_config["TESTING"]["SPF_RECORD"]
+        app.config["DKIM_RECORD"] = toml_config["TESTING"]["DKIM_RECORD"]
+        app.config["DMARC_RECORD"] = toml_config["TESTING"]["DMARC_RECORD"]
+
+        # Configure logfile.
+        file_handler = FileHandler(filename=toml_config["TESTING"]["LOGFILE"])
+        file_handler.setFormatter(logging.Formatter(log_format))
+        app.logger.addHandler(file_handler)
+
+        # Configure loglevel.
+        if toml_config["TESTING"]["LOGLEVEL"] == "ERROR":
+            app.logger.setLevel(logging.ERROR)
+        elif toml_config["TESTING"]["LOGLEVEL"] == "WARNING":
+            app.logger.setLevel(logging.WARNING)
+        elif toml_config["TESTING"]["LOGLEVEL"] == "INFO":
+            app.logger.setLevel(logging.INFO)
+        elif toml_config["TESTING"]["LOGLEVEL"] == "DEBUG":
+            app.logger.setLevel(logging.DEBUG)
+        else:
+            print("Error: you need to set LOGLEVEL to ERROR/WARNING/INFO/DEBUG")
+            sys.exit(1)
+    elif mode == "DEVELOPMENT":
+        app.config["SECRET_KEY"] = toml_config["DEVELOPMENT"]["SECRET_KEY"]
+        app.config['SQLALCHEMY_DATABASE_URI'] = toml_config["DEVELOPMENT"]['SQLALCHEMY_DATABASE_URI']
+        app.config["WTF_CSRF_SECRET_KEY"] = toml_config["DEVELOPMENT"]["WTF_CSRF_SECRET_KEY"]
+
+        # Configure services that ddmail_webapp depend on. 
+        app.config["EMAIL_REMOVER_URL"] = toml_config["DEVELOPMENT"]["EMAIL_REMOVER_URL"]
+        app.config["EMAIL_REMOVER_PASSWORD"] = toml_config["DEVELOPMENT"]["EMAIL_REMOVER_PASSWORD"]
+        app.config["DMCP_KEYHANDLER_URL"] = toml_config["DEVELOPMENT"]["DMCP_KEYHANDLER_URL"]
+        app.config["DMCP_KEYHANDLER_PASSWORD"] = toml_config["DEVELOPMENT"]["DMCP_KEYHANDLER_PASSWORD"]
+        app.config["OPENPGP_KEYHANDLER_URL"] = toml_config["DEVELOPMENT"]["OPENPGP_KEYHANDLER_URL"]
+        app.config["OPENPGP_KEYHANDLER_PASSWORD"] = toml_config["DEVELOPMENT"]["OPENPGP_KEYHANDLER_PASSWORD"]
+
+        # Configure payment information.
+        app.config["PAYMENT_MAIL_NAME"] = toml_config["DEVELOPMENT"]["PAYMENT_MAIL_NAME"]
+        app.config["PAYMENT_MAIL_ADDRESS"] = toml_config["DEVELOPMENT"]["PAYMENT_MAIL_ADDRESS"]
+        app.config["PAYMENT_MAIL_POSTCODE"] = toml_config["DEVELOPMENT"]["PAYMENT_MAIL_POSTCODE"]
+        app.config["PAYMENT_MAIL_COUNTRY"] = toml_config["DEVELOPMENT"]["PAYMENT_MAIL_COUNTRY"]
+        
+        # Configure dns record checked when adding account/own domains.
+        app.config["MX_RECORD_HOST"] = toml_config["DEVELOPMENT"]["MX_RECORD_HOST"]
+        app.config["MX_RECORD_PRIORITY"] = toml_config["DEVELOPMENT"]["MX_RECORD_PRIORITY"]
+        app.config["SPF_RECORD"] = toml_config["DEVELOPMENT"]["SPF_RECORD"]
+        app.config["DKIM_RECORD"] = toml_config["DEVELOPMENT"]["DKIM_RECORD"]
+        app.config["DMARC_RECORD"] = toml_config["DEVELOPMENT"]["DMARC_RECORD"]
+
+        # Configure logfile.
+        file_handler = FileHandler(filename=toml_config["DEVELOPMENT"]["LOGFILE"])
+        file_handler.setFormatter(logging.Formatter(log_format))
+        app.logger.addHandler(file_handler)
+
+        # Configure loglevel.
+        if toml_config["DEVELOPMENT"]["LOGLEVEL"] == "ERROR":
+            app.logger.setLevel(logging.ERROR)
+        elif toml_config["DEVELOPMENT"]["LOGLEVEL"] == "WARNING":
+            app.logger.setLevel(logging.WARNING)
+        elif toml_config["DEVELOPMENT"]["LOGLEVEL"] == "INFO":
+            app.logger.setLevel(logging.INFO)
+        elif toml_config["DEVELOPMENT"]["LOGLEVEL"] == "DEBUG":
+            app.logger.setLevel(logging.DEBUG)
+        else:
+            print("Error: you need to set LOGLEVEL to ERROR/WARNING/INFO/DEBUG")
+            sys.exit(1)
+    else:
+        print("Error: you need to set env variabel MODE to PRODUCTION/TESTING/DEVELOPMENT")
+        sys.exit(1)
+    
+    app.secret_key = app.config["SECRET_KEY"]
+    app.WTF_CSRF_SECRET_KEY = app.config["WTF_CSRF_SECRET_KEY"]
+    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+    #app.config['SQLALCHEMY_DATABASE_URI'] = app.config['SQLALCHEMY_DATABASE_URI']
+
+    csrf = CSRFProtect(app)
+
+    # Ensure the instance folder exists
+    try:
+        os.makedirs(app.instance_path)
+    except OSError:
+        pass
+
+    # Import the database models.
+    from ddmail_webapp.models import db
+    db.init_app(app)
+
+    # Import forms
+
+    # Apply the blueprints to the app
+    from ddmail_webapp import auth, settings, unauthenticated, well_known
+
+    app.register_blueprint(auth.bp)
+    app.register_blueprint(settings.bp)
+    app.register_blueprint(unauthenticated.bp)
+    app.register_blueprint(well_known.bp)
+
+    return app 

ddmail_webapp/auth.py

@@ -0,0 +1,173 @@
+from flask import Blueprint, request, render_template, session, redirect, url_for, current_app
+from argon2 import PasswordHasher
+from ddmail_webapp.models import db, Account, User, Authenticated
+from ddmail_webapp.validators import is_username_allowed, is_password_allowed
+import random
+import string
+import datetime
+import secrets
+
+bp = Blueprint("auth", __name__, url_prefix="/")
+
+# Generate a token that is easy to write down on paper frpm screen.
+def generate_token(length):
+    alphabet = string.ascii_uppercase + string.digits
+    while True:
+        token = ''.join(secrets.choice(alphabet) for i in range(length))
+        if (any(c.isupper() for c in token) and sum(c.isdigit() for c in token) >= 4):
+            break
+    return token
+
+# Generate a password with digit, upparcase letters and lowercase letters.
+def generate_password(length):
+    alphabet = string.ascii_letters + string.digits
+    while True:
+        password = ''.join(secrets.choice(alphabet) for i in range(length))
+        if (any(c.islower() for c in password) and any(c.isupper() for c in password) and sum(c.isdigit() for c in password) >= 3):
+            break
+    return password
+
+# Check if a user is authenticated, if the user is authenticated the user id will be returned else None.
+def is_athenticated(cookie):
+    # Validate the cookie
+    if is_password_allowed(cookie) != True:
+        return None
+
+    # Try to find the cookie in the db.
+    authenticated = Authenticated.query.filter_by(cookie = cookie).first()
+
+    # Check if the cookie was in the authenticated table.
+    if authenticated == None:
+        return None
+
+    # Get the cookie valid_to time in datetime object.
+    valid_to = datetime.datetime.strptime(str(authenticated.valid_to), '%Y-%m-%d %H:%M:%S')
+
+    # Get current time in datetime object.
+    now_time = datetime.datetime.now()
+
+    # Check if cookie is still valid.
+    if now_time > valid_to:
+        return None
+
+    # Get the user object from db.
+    user_from_db = db.session.query(User).filter(User.id == authenticated.user_id).first()
+
+    # User is authenticated, return user object.
+    return user_from_db
+
+@bp.route("/register", methods=['POST', 'GET'])
+def register():
+    if request.method == 'GET':
+        return render_template('register.html')
+    if request.method == 'POST':
+        ph = PasswordHasher()
+
+        # Generate new account.
+        account = generate_token(12)
+        payment_token = generate_token(12)
+
+        # Add new org to the db.
+        new_account = Account(account=account, payment_token=payment_token, funds_in_sek=0, is_enabled=False, is_gratis=False, total_storage_space_g=0 ,created=datetime.datetime.now())
+        db.session.add(new_account)
+        db.session.commit()
+
+        # Generate all the user data.
+        user = generate_token(12)
+        cleartext_password = generate_password(24)
+        cleartext_password_key = generate_password(4096)
+
+        # Generate password hashes for password and password-key.
+        password_hash = ph.hash(cleartext_password)
+        password_key_hash = ph.hash(cleartext_password_key)
+
+        # Add the user data to the db.
+        new_user = User(account_id=new_account.id, user=user, password_hash=password_hash,password_key_hash=password_key_hash)
+        db.session.add(new_user)
+        db.session.commit()
+
+        # Give the data to the user.
+        current_app.logger.info("created new account: " + account  + " with new user: " + user)
+        return render_template('user_created.html',account=new_account.account,user=user,cleartext_password=cleartext_password,cleartext_password_key=cleartext_password_key)
+
+@bp.route("/login", methods=['POST', 'GET'])
+def login():
+    current_user = None
+
+    if request.method == 'GET':
+        return render_template('login.html',current_user = current_user)
+    if request.method == 'POST':
+        ph = PasswordHasher()
+
+        # Get the data from the forms.
+        user_from_form = request.form["user"].strip()
+        cleartext_password_from_form = request.form["password"].strip()
+        file = request.files['key']
+        cleartext_password_key_from_form = file.read().strip().decode("utf-8")
+        
+
+        # Check that form has data.
+        if not user_from_form or not cleartext_password_from_form or not cleartext_password_key_from_form:
+            # Login failed
+            current_app.logger.warning("failed login, data is missing")
+            return render_template('message.html',headline="Login error",message="Failed to login, wrong username and/or password and/or key.",current_user=current_user)
+
+        # Validate the form data.
+        if is_username_allowed(user_from_form) != True or is_password_allowed(cleartext_password_from_form) != True or is_password_allowed(cleartext_password_key_from_form) != True:
+            # Login failed.
+            current_app.logger.warning("failed login, validation failed")
+            return render_template('message.html',headline="Login error",message="Failed to login, wrong username and/or password and/or key.",current_user=current_user)
+
+        # Get the user data from db.
+        user_from_db = db.session.query(User).filter(User.user == user_from_form).first()
+
+        if not user_from_db:
+            # Login failed.
+            current_app.logger.warning("failed login for user " + user_from_form + " do not exsist in db")
+            return render_template('message.html',headline="Login error",message="Failed to login, wrong username and/or password and/or key.",current_user=current_user)
+
+        # Check password hash and password key hash.
+        try:
+            if ph.verify(user_from_db.password_hash, cleartext_password_from_form) == True and ph.verify(user_from_db.password_key_hash, cleartext_password_key_from_form) == True:
+                # Generate a secret random cookie.
+                cookie = generate_password(128)
+
+                # Sign the cookie and store it in the browser.
+                session["secret"] = cookie
+
+                # Store the cookie in the db together with expire time.
+                authenticated = Authenticated(cookie,user_from_db.id,datetime.datetime.now() + datetime.timedelta(hours=3))
+                db.session.add(authenticated)
+                db.session.commit()
+
+                current_app.logger.info("successful login for user " + user_from_db.user + " belonging to account " + user_from_db.account.account)
+                return redirect('/settings')
+                #return render_template('settings.html',current_user=current_user)
+            else:
+                # Login failed.
+                current_app.logger.warning("failed login for user " + user_from_db.user + " belonging to account " + user_from_db.account.account + " wrong password and/or key")
+                return render_template('message.html',headline="Login error",message="Failed to login, wrong username and/or password and/or key.",current_user=current_user)
+        except:
+            # Login failed.
+            current_app.logger.warning("failed login for user " + user_from_db.user + " belonging to account " + user_from_db.account.account + " wrong password and/or key")
+            return render_template('message.html',headline="Login error",message="Failed to login, wrong username and/or password and/or key.",current_user=current_user)
+
+
+@bp.route("/logout")
+def logout():
+    # Check if user is athenticated.
+    if "secret" in session:
+        current_user = is_athenticated(session["secret"])
+        current_app.logger.debug("secret is in session")
+
+        if current_user != None:
+            # Delete the cookie from db.
+            current_app.logger.debug("deleting user with id " + str(current_user.id) + " from authenticated in db")
+            db.session.query(Authenticated).filter(Authenticated.user_id == current_user.id).delete()
+            db.session.commit()
+    else:
+        current_app.logger.debug("secret is not in session")
+        current_user = None
+
+    session.clear()
+    return redirect('/')

ddmail_webapp/forms.py

@@ -0,0 +1,22 @@
+from flask_wtf import FlaskForm
+from wtforms import StringField, PasswordField, validators
+
+# Form modul for domain.
+class DomainForm(FlaskForm):
+    domain = StringField('Domain', [validators.DataRequired(),validators.Length(min=4, max=200)])
+
+# Form modul for email password.
+class EmailPasswordForm(FlaskForm):
+    email_password = PasswordField('Email account current password', [validators.DataRequired(),validators.Length(min=24, max=24)])
+
+# Form modul for email.
+class EmailForm(FlaskForm):
+    email = StringField('Email', [validators.DataRequired(),validators.Length(min=1, max=200)])
+    domain = StringField('Domain', [validators.DataRequired(),validators.Length(min=4, max=200)])
+
+# Form modul for alias.
+class AliasForm(FlaskForm):
+    src = StringField('Source', [validators.DataRequired(),validators.Length(min=1, max=200)])
+    domain = StringField('Domain', [validators.DataRequired(),validators.Length(min=4, max=200)])
+    dst = StringField('Destination', [validators.DataRequired(),validators.Length(min=4, max=200)])
+

ddmail_webapp/models.py

@@ -0,0 +1,117 @@
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import relationship
+
+db = SQLAlchemy()
+
+# DB modul for accounts.
+class Account(db.Model):
+    __tablename__ = 'accounts'
+    id = db.Column(db.Integer, primary_key=True)
+    account = db.Column(db.String(100), unique=True, nullable=False)
+    payment_token = db.Column(db.String(12), unique=True, nullable=False)
+    funds_in_sek = db.Column(db.Integer, nullable=False)
+    is_enabled = db.Column(db.Boolean, unique=False, nullable=False)
+    is_gratis = db.Column(db.Boolean, unique=False, nullable=False)
+    total_storage_space_g = db.Column(db.Integer, nullable=False)
+    created = db.Column(db.DateTime, nullable=False)
+    last_time_disabled = db.Column(db.DateTime, nullable=True)
+
+    aliases = relationship("Alias", back_populates="account")
+    emails = relationship("Email", back_populates="account")
+    account_domains = relationship("Account_domain", back_populates="account")
+    users = relationship("User", back_populates="account")
+    openpgp_public_keys = relationship("Openpgp_public_key", back_populates="account")
+
+# DB modul for aliases.
+class Alias(db.Model):
+    __tablename__ = 'aliases'
+    id = db.Column(db.Integer, primary_key=True, nullable=False)
+    account_id = db.mapped_column(ForeignKey("accounts.id"), nullable=False)
+    src_email = db.Column(db.String(200), unique=True, nullable=False)
+    src_account_domain_id = db.mapped_column(db.Integer, ForeignKey('account_domains.id'), nullable=True)
+    src_global_domain_id = db.mapped_column(db.Integer, ForeignKey('global_domains.id'), nullable=True)
+    dst_email_id = db.mapped_column(db.Integer, ForeignKey('emails.id'), nullable=False)
+
+    account = relationship("Account", back_populates="aliases")
+    email = relationship("Email", back_populates="aliases")
+    account_domain = relationship("Account_domain", back_populates="aliases")
+    global_domain = relationship("Global_domain", back_populates="aliases")
+
+# DB modul for emails.
+class Email(db.Model):
+    __tablename__ = 'emails'
+    id = db.Column(db.Integer, primary_key=True,nullable=False)
+    account_id = db.mapped_column(db.Integer, ForeignKey('accounts.id'),nullable=False)
+    account_domain_id = db.mapped_column(db.Integer, ForeignKey('account_domains.id'),nullable=True)
+    global_domain_id = db.mapped_column(db.Integer, ForeignKey('global_domains.id'),nullable=True)
+    openpgp_public_key_id = db.mapped_column(db.Integer, ForeignKey('openpgp_public_keys.id'),nullable=True)
+    email = db.Column(db.String(200), unique=True, nullable=False)
+    password_hash = db.Column(db.String(2096), nullable=False)
+    storage_space_mb = db.Column(db.Integer, nullable=False)
+
+    account = relationship("Account", back_populates="emails")
+    account_domain = relationship("Account_domain", back_populates="emails")
+    global_domain = relationship("Global_domain", back_populates="emails")
+    aliases = relationship("Alias", back_populates="email")
+    openpgp_public_key = relationship("Openpgp_public_key", back_populates="emails")
+
+# DB modul for openpgp_public_keys.
+class Openpgp_public_key(db.Model):
+    __tablename__ = 'openpgp_public_keys'
+    id = db.Column(db.Integer, primary_key=True,nullable=False)
+    account_id = db.mapped_column(db.Integer, ForeignKey('accounts.id'),nullable=False)
+    fingerprint = db.Column(db.String(200), unique=True, nullable=False)
+
+    account = relationship("Account", back_populates="openpgp_public_keys")
+    emails = relationship("Email", back_populates="openpgp_public_key")
+
+# DB modul for account domains.
+class Account_domain(db.Model):
+    __tablename__ = 'account_domains'
+    id = db.Column(db.Integer, primary_key=True, nullable=False)
+    account_id = db.mapped_column(db.Integer, ForeignKey('accounts.id'), nullable=False)
+    domain = db.Column(db.String(200), unique=True, nullable=False)
+
+    account = relationship("Account", back_populates="account_domains")
+    emails = relationship("Email", back_populates="account_domain")
+    aliases = relationship("Alias", back_populates="account_domain")
+
+# DB modul for global domains.
+class Global_domain(db.Model):
+    __tablename__ = 'global_domains'
+    id = db.Column(db.Integer, primary_key=True, nullable=False)
+    domain = db.Column(db.String(200), unique=True, nullable=False)
+    is_enabled = db.Column(db.Boolean, unique=False, nullable=False,default=True)
+
+    emails = relationship("Email", back_populates="global_domain")
+    aliases = relationship("Alias", back_populates="global_domain")
+
+
+# DB modul for users.
+class User(db.Model):
+    __tablename__ = 'users'
+    id = db.Column(db.Integer, primary_key=True, nullable=False)
+    account_id = db.mapped_column(db.Integer, ForeignKey('accounts.id'), nullable=False)
+    user = db.Column(db.String(100), unique=True, nullable=False)
+    password_hash = db.Column(db.String(200), unique=True, nullable=False)
+    password_key_hash = db.Column(db.String(200), unique=True, nullable=False)
+
+    account = relationship("Account", back_populates="users")
+    authenticated = relationship("Authenticated", back_populates="user")
+
+# DB model for authenticated.
+class Authenticated(db.Model):
+    __tablename__ = 'authenticateds'
+    id = db.Column(db.Integer, primary_key=True, nullable=False)
+    cookie = db.Column(db.String(12), unique=True, nullable=False)
+    user_id = db.mapped_column(db.Integer, ForeignKey('users.id'), nullable=False)
+    valid_to = db.Column(db.DateTime, nullable=False)
+
+    user = relationship("User", back_populates="authenticated")
+
+    def __init__(self,cookie,user_id,valid_to):
+        self.cookie = cookie
+        self.user_id = user_id
+        self.valid_to = valid_to
+