regscale-cli 6.16.0.0__py3-none-any.whl

regscale/core/server/templates/upload_ssp_result.html

@@ -0,0 +1,128 @@
+{% extends "base.html" %}
+{% block content %}
+<style>
+    .level-info {
+        color: forestgreen;
+    }
+
+    .level-warning {
+        color: yellow
+    }
+
+    .level-error {
+        color: red
+    }
+
+    ul {
+      list-style-type: none;
+      padding: 0;
+      margin: 0;
+    }
+
+    li {
+      display: flex;
+      align-items: baseline;
+    }
+
+    li .number {
+      width: 50px;
+      text-align: right;
+      font-family: monospace;
+      padding-right: 10px;
+    }
+
+    li .text {
+      flex: 1;
+    }
+
+    .event-text {
+        word-wrap: break-word;
+        word-break: break-all;
+    }
+
+    .event-text-word-break {
+        word-wrap: break-word;
+        word-break: break-word;
+    }
+</style>
+<div class="row">
+    <div class="col-md-12">
+        <div style="padding: '10px'; display: 'grid'; justify-items: 'center'; align-items: 'center'; width: '100%';">
+            <div style="display: grid; justify-items: center; align-items: center;">
+                <h2>Security Plan Processing Results for Source Document "{{ filename }}"</h2>
+                <br>
+                <h1>System Security Plan Created!</h1>
+                <h3 style="padding: 5px;"><i>"{{result_output.ssp_title}}" (# {{ result_output.ssp_id }}) in
+                        RegScale</i></h3>
+                <br>
+                <a href="{{ site_info.domain }}/form/securityplans/{{ result_output.ssp_id }}"
+                   target="_blank"
+                   style="text-align: center;"
+                   rel="noopener"
+                >
+                <button type="button" class="btn btn-primary" target="_blank">
+                    View Security Plan In RegScale &#x2197;
+                </button>
+                </a>
+            </div>
+            <p>&nbsp;</p>
+            <div class="col-md-12 border bg-light" style="padding: 20px; border-radius: 10px;">
+                <h2 class="level-info">Summary</h2>
+                <div style="padding: 10px; border-radius: 10px;">
+                    <h2><b>{{ results.Info + results.Error }}</b> Items in source document processed</h2>
+                    <ul style="font-size: 1.25em;">
+                        <li><span class="number"><b>{{ results.Info }}</b></span><span class="text">Items successfully mapped to created Security Plan</span></li>
+                        <li><span class="number"><b>{{ results.Error }}</b></span><span class="text">Items failed to map to created Security Plan</span></li>
+                        <li><span class="number"><b>{{ result_output.implementations_loaded }}</b></span><span class="text">Control items successfully mapped to created Security Plan<span class="text"></li>
+                    </ul>
+                    <hr>
+                    <h3>{{ (results.Info / (results.Info + results.Error) *
+                        100)|round(1)}}% <i>Item processing success rate</i>
+                    </h3>
+                </div>
+            </div>
+            <p>&nbsp;</p>
+            <div class="col-md-12 border bg-light" style="padding: 20px; border-radius: 10px;">
+                <h2 class="level-info">Items by Category</h2>
+                <ul>
+                    {% for item in category_counts.items() %}
+                    <li><span class="number">{{ item[1] }}</span><span class="text">{{ item[0] }}</span></li>
+                    {% endfor %}
+                </ul>
+                <br>
+
+            </div>
+        </div>
+        <p>&nbsp;</p>
+        <div class="col-md-12">
+            <div class="p-12 border bg-light" style="padding: 10px; border-radius: 10px;">
+
+                {% for level, rows in csv_data_grouped.items()%}
+                <h2 class="level-{{ level|lower }}">{{ level }} Results</h2>
+                <caption><i>The {{ level|lower }} statements found processing source document.</i></caption>
+                <table style="table-layout: fixed; width: 100%;">
+                  <thead>
+                    <tr style="text-align: left;">
+                      <th class="event-text-word-break" style="width: 20%;">NIST Model Layer Item</th>
+                      <th style="width: 20%;">Record Type</th>
+                      <th style="width: 60%;">Event</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {% for row in rows %}
+                    <tr>
+                      <td class="event-text-word-break">{{ row['model_layer'] }}</td>
+                      <td class="event-text-word-break">{{ row['record_type'] }}</td>
+                      <td class="event-text">{{ row['event'] }}</td>
+                    </tr>
+                    {% endfor %}
+                  </tbody>
+                </table>
+                {% endfor %}
+
+            </div>
+        </div>
+
+    </div>
+
+    {% endblock %}

regscale/core/static/regex.py

@@ -0,0 +1,14 @@
+"""Compiled Regexes for use."""
+
+import re
+
+
+URL_REGEX = re.compile(
+    r"^(?:http)s?://"  # http:// or https://
+    r"(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|"  # domain...
+    r"localhost|"  # localhost...
+    r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"  # ...or ip
+    r"(?::\d+)?"  # optional port
+    r"(?:/?|[/?]\S+)$",
+    re.IGNORECASE,
+)

regscale/core/utils/__init__.py

@@ -0,0 +1,117 @@
+"""Utility functions for the application"""
+
+from typing import Union, Optional
+
+UDP = "UDP"
+TCP = "TCP"
+TCP_UDP = "TCP/UDP"
+
+
+def snakify(name: str) -> str:
+    """
+    Convert a string to snake_case
+
+    :param str name: String to convert
+    :returns: String in snake_case
+    :rtype: str
+    """
+    return name.lower().replace(" ", "_")
+
+
+def get_protocol_from_port(port: Union[int, str]) -> Optional[str]:
+    """
+    Determines the protocol from a port number for well known ports
+
+    :param Union[int, str] port: Port number (int or str)
+    :returns: Protocol name or None if not found
+    :rtype: Optional[str]
+    """
+    port_to_protocol = {
+        20: "FTP",  # File Transfer Protocol (FTP) Data Transfer
+        21: "FTP",  # File Transfer Protocol (FTP) Command Control
+        22: "SSH",  # Secure Shell (SSH)
+        23: "Telnet",  # Telnet protocol
+        25: "SMTP",  # Simple Mail Transfer Protocol (SMTP)
+        53: "DNS",  # Domain Name System (DNS)
+        67: "DHCP",  # Dynamic Host Configuration Protocol (DHCP) Server
+        68: "DHCP",  # Dynamic Host Configuration Protocol (DHCP) Client
+        80: "HTTP",  # Hypertext Transfer Protocol (HTTP)
+        110: "POP3",  # Post Office Protocol v3 (POP3)
+        123: "NTP",  # Network Time Protocol (NTP)
+        143: "IMAP",  # Internet Message Access Protocol (IMAP)
+        161: "SNMP",  # Simple Network Management Protocol (SNMP)
+        162: "SNMP",  # Simple Network Management Protocol (SNMP) Trap
+        443: "HTTPS",  # Hypertext Transfer Protocol Secure (HTTPS)
+        445: "SMB",  # Server Message Block (SMB)
+        465: "SMTPS",  # Simple Mail Transfer Protocol Secure (SMTPS)
+        993: "IMAPS",  # Internet Message Access Protocol Secure (IMAPS)
+        995: "POP3S",  # Post Office Protocol 3 Secure (POP3S)
+        1433: "MSSQL",  # Microsoft SQL Server
+        3306: "MySQL",  # MySQL Database Service
+        3389: "RDP",  # Remote Desktop Protocol (RDP)
+        5432: "PostgreSQL",  # PostgreSQL Database
+        5672: "AMQP",  # Advanced Message Queuing Protocol (AMQP)
+        5900: "VNC",  # Virtual Network Computing (VNC)
+        6379: "Redis",  # Redis Key-Value Store
+        8080: "HTTP-ALT",  # Alternative HTTP
+        8443: "HTTPS-ALT",  # Alternative HTTPS
+        27017: "MongoDB",  # MongoDB Database
+    }
+
+    port = int(port)  # Ensure port is an integer
+
+    return port_to_protocol.get(port, None)
+
+
+def get_base_protocol_from_port(port: Union[int, str]) -> str:
+    """
+    Returns the well-known base protocol for a port such as TCP, UDP, both TCP/UDP, or other based on the port number
+    :param Union[int, str] port: Port number
+    :returns: Protocol category
+    :rtype: str
+    """
+    port = int(port)  # Ensure port is an integer
+
+    both_tcp_udp_ports = [
+        20,
+        21,
+        22,
+        23,
+        25,
+        53,
+        80,
+        110,
+        123,
+        143,
+        161,
+        162,
+        443,
+        465,
+        993,
+        995,
+        1433,
+        3306,
+        3389,
+        5432,
+        5672,
+        5900,
+        6379,
+        8080,
+        8443,
+        27017,
+    ]
+    well_known_udp_ports = [7, 9, 19, 49, 67, 68, 69, 123, 161, 162, 514]
+    well_known_tcp_ports = list(set(range(0, 1024)) - set(well_known_udp_ports) - set(both_tcp_udp_ports))
+
+    if port in well_known_udp_ports:
+        return UDP  # Well-known ports for UDP
+    elif port in both_tcp_udp_ports:
+        return TCP_UDP  # Ports used for both TCP and UDP
+    elif port in well_known_tcp_ports:
+        return TCP  # Well-known ports for TCP
+    elif 1024 <= port <= 49151:
+        return TCP_UDP  # Registered ports for both TCP and UDP
+    elif 49152 <= port <= 65535:
+        return TCP_UDP  # Dynamic or private ports for both TCP and UDP
+    else:
+        return "Other"  # Ports that don't fit into the standard categories

regscale/core/utils/click_utils.py

@@ -0,0 +1,13 @@
+"""Use the click methods to generate an importable click hierarchy."""
+
+from regscale.regscale import cli
+from regscale.utils.click_utils import process_click_group
+
+REGSCALE_CLI = process_click_group(group=cli, prefix="regscale")
+
+REGSCALE_CLI_SERIALIZABLE = process_click_group(group=cli)
+
+if __name__ == "__main__":
+    from pprint import pprint
+
+    pprint(REGSCALE_CLI)

regscale/core/utils/date.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Utility functions for handling date and datetime conversions"""
+
+import datetime
+import logging
+from typing import List, Union, Optional
+
+from pandas import Timestamp
+from dateutil.parser import parse, ParserError
+
+
+logger = logging.getLogger("regscale")
+default_date_format = "%Y-%m-%dT%H:%M:%S%z"
+
+
+def date_str(date_object: Union[str, datetime.datetime, datetime.date, None], date_format: Optional[str] = None) -> str:
+    """
+    Convert a date/datetime object to a date string.
+
+    :param Union[str, datetime.datetime, datetime.date, None] date_object: The date/datetime object to convert.
+    :param Optional[str] date_format: The format to use for the date string.
+    :return: The date as a string.
+    """
+    if isinstance(date_object, str):
+        date_object = date_obj(date_object)
+    if isinstance(date_object, datetime.datetime):
+        if date_format:
+            return date_object.strftime(date_format)
+        return date_object.date().isoformat()
+    if isinstance(date_object, datetime.date):
+        if date_format:
+            return date_object.strftime(date_format)
+        return date_object.isoformat()
+    if isinstance(date_object, Timestamp):
+        return date_object.date().isoformat()
+    return ""
+
+
+def datetime_str(
+    date_object: Union[str, datetime.datetime, datetime.date, None], date_format: Optional[str] = None
+) -> str:
+    """
+    Convert a date/datetime object to a datetime string.
+
+    :param Union[str, datetime.datetime, datetime.date, None] date_object: The date/datetime object to convert.
+    :param Optional[str] date_format: The format to use for the datetime string.
+    :return: The datetime as a string.
+    """
+    if not date_format:
+        date_format = default_date_format
+    if isinstance(date_object, str):
+        date_object = datetime_obj(date_object)
+    if isinstance(date_object, datetime.datetime):
+        return date_object.strftime(date_format)
+    if isinstance(date_object, datetime.date):
+        return date_object.strftime(date_format)
+    return ""
+
+
+def date_obj(date_str: Union[str, datetime.datetime, datetime.date, int, None]) -> Optional[datetime.date]:
+    """
+    Convert a string, datetime, date, or integer to a date object.
+
+    :param Union[str, datetime.datetime, datetime.date, int] date_str: The value to convert.
+    :return: The date object.
+    """
+    if isinstance(date_str, (str, int)):
+        dt_obj = datetime_obj(date_str)
+        return dt_obj.date() if dt_obj else None
+    if isinstance(date_str, datetime.datetime):
+        return date_str.date()
+    if isinstance(date_str, datetime.date):
+        return date_str
+    return None
+
+
+def datetime_obj(date_str: Union[str, datetime.datetime, datetime.date, int, None]) -> Optional[datetime.datetime]:
+    """
+    Convert a string, datetime, date, integer, or timestamp string to a datetime object.
+
+    :param Union[str, datetime.datetime, datetime.date, int, None] date_str: The value to convert.
+    :return: The datetime object.
+    """
+    if isinstance(date_str, str):
+        # Check if the string looks like a timestamp integer
+        if date_str.isdigit():
+            return datetime.datetime.fromtimestamp(int(date_str))
+        try:
+            return parse(date_str)
+        except ParserError as e:
+            if date_str and str(date_str).lower() not in ["n/a", "none"]:
+                logger.warning(f"Warning could not parse date string: {date_str}\n{e}")
+            return None
+    if isinstance(date_str, datetime.datetime):
+        return date_str
+    if isinstance(date_str, datetime.date):
+        return datetime.datetime.combine(date_str, datetime.datetime.min.time())
+    if isinstance(date_str, int):
+        return datetime.datetime.fromtimestamp(date_str)
+    return None
+
+
+def time_str(time_obj: Union[str, datetime.datetime, datetime.time]) -> str:
+    """
+    Convert a datetime/time object to a string.
+
+    :param Union[str, datetime.datetime, datetime.time] time_obj: The datetime/time object to convert.
+    :return: The time as a string.
+    """
+    if isinstance(time_obj, str):
+        return time_obj
+    if isinstance(time_obj, datetime.datetime):
+        time_obj = time_obj.time()
+    if isinstance(time_obj, datetime.time):
+        return time_obj.__format__("%-I:%M%p")
+    return ""
+
+
+def time_widget_str(time_obj: Union[str, datetime.datetime, datetime.time]) -> str:
+    """
+    Convert a time object to a string for a widget.
+
+    :param Union[str, datetime.datetime, datetime.time] time_obj: The time object to convert.
+    :return: The time as a string for a widget.
+    """
+    if isinstance(time_obj, str):
+        return time_obj
+    if isinstance(time_obj, datetime.datetime):
+        time_obj = time_obj.time()
+    if isinstance(time_obj, datetime.time):
+        return time_obj.__format__("%-I:%M ") + time_obj.__format__("%p").lower()
+    return ""
+
+
+def parse_time(time_str: str) -> datetime.time:
+    """
+    Parse a time string.
+
+    :param str time_str: The time string to parse.
+    :return: The parsed time.
+    :rtype: datetime.time
+    """
+    try:
+        return parse(f"1/1/2011 {time_str.zfill(4)}").time()
+    except ValueError:
+        return parse(f"1/1/2011 {time_str.zfill(len(time_str) + 1)}").time()
+
+
+def is_weekday(date_obj: datetime.date) -> bool:
+    """
+    Check if a date is a weekday.
+
+    :param datetime.date date_obj: The date to check.
+    :return: True if the date is a weekday, False otherwise.
+    :rtype: bool
+    """
+    return date_obj.weekday() < 5
+
+
+def days_between(
+    start: Union[str, datetime.datetime, datetime.date],
+    end: Union[str, datetime.datetime, datetime.date],
+) -> List[str]:
+    """
+    Get the days between two dates.
+
+    :param Union[str, datetime.datetime, datetime.date] start: The start date.
+    :param Union[str, datetime.datetime, datetime.date] end: The end date.
+    :return: A list of dates between the start and end dates.
+    """
+    delta = date_obj(end) - date_obj(start)
+    return [(date_obj(start) + datetime.timedelta(days=i)).strftime("%Y/%m/%d") for i in range(delta.days + 1)]
+
+
+def weekend_days_between(
+    start: Union[str, datetime.datetime, datetime.date],
+    end: Union[str, datetime.datetime, datetime.date],
+) -> List[str]:
+    """
+    Get the weekend days between two dates.
+
+    :param Union[str, datetime.datetime, datetime.date] start: The start date.
+    :param Union[str, datetime.datetime, datetime.date] end: The end date.
+    :return: A list of weekend dates between the start and end dates.
+    """
+    return [day for day in days_between(start, end) if not is_weekday(date_obj(day))]
+
+
+def days_from_today(i: int) -> datetime.date:
+    """
+    Get the date a certain number of days from today.
+
+    :param int i: The number of days from today.
+    :return: The date i days from today.
+    :rtype: datetime.date
+    """
+    return datetime.date.today() + datetime.timedelta(days=i)
+
+
+def get_day_increment(
+    start: Union[str, datetime.datetime, datetime.date],
+    days: int,
+    excluded_dates: Optional[List[Union[str, datetime.datetime, datetime.date]]] = None,
+) -> datetime.date:
+    """
+    Get the date a certain number of days from a start date, excluding certain dates.
+
+    :param Union[str, datetime.datetime, datetime.date] start: The start date.
+    :param int days: The number of days from the start date.
+    :param Optional[List[Union[str, datetime.datetime, datetime.date]]] excluded_dates: A list of dates to exclude.
+    :return: The date days days from the start date, excluding the excluded dates.
+    """
+    start = date_obj(start)
+    end = start + datetime.timedelta(days=days)
+    if excluded_dates:
+        for excluded_date in sorted([date_obj(x) for x in excluded_dates]):
+            if start <= excluded_date <= end:
+                end += datetime.timedelta(days=1)
+    return end
+
+
+def normalize_date(dt: str, fmt: str) -> str:
+    """
+    Normalize string date to a standard format, if possible.
+
+    :param str dt: Date to normalize
+    :param str fmt: Format of the date
+    :return: Normalized Date
+    :rtype: str
+    """
+    if isinstance(dt, str):
+        try:
+            new_dt = datetime.datetime.strptime(dt, fmt)
+            return new_dt.strftime("%Y-%m-%d %H:%M:%S")
+        except ValueError:
+            return dt
+    return dt