1148235141

Build Type

github

Committed by GitHub

Commit Message

Merge 1562de8b4 into 44e0cfb34

Pull Request Pull Request #40: Add campaign summary export

Run Details

94 of 380 branches covered (24.74%)

Branch coverage included in aggregate %.

15 of 57 new or added lines in 3 files covered. (26.32%)

241 existing lines in 8 files now uncovered.

292 of 1246 relevant lines covered (23.43%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.06

/src/models/models.py

"""The models library."""

# Standard Python Libraries
from datetime import datetime
from typing import Any, Dict

# TODO Research .attribute only valid properties


class Model(object):
    """The Model class."""

    _valid_properties: Dict[str, Any] = dict()

    @classmethod
    def _is_builtin(cls, obj):
        return isinstance(obj, (int, float, str, list, dict, bool))

    def as_dict(self):
        """Return a dict representation of the resource."""
        result = {}
        for key in self._valid_properties:
            val = getattr(self, key)
            if isinstance(val, datetime):
                val = val.isoformat()
            # Parse custom classes
            elif val and not Model._is_builtin(val):
                val = val.as_dict()
            # Parse lists of objects
            elif isinstance(val, list):
                # We only want to call as_dict in the case where the item
                # isn't a built in type.
                for i in range(len(val)):
                    if Model._is_builtin(val[i]):
                        continue
                    val[i] = val[i].as_dict()
            # If it's a boolean, add it regardless of the value
            elif isinstance(val, bool):
                result[key] = val

            # Add it if it's not None
            if val:
                result[key] = val
        return result

    @classmethod
    def parse(cls, json):
        """Parse a JSON object into a model instance."""
        raise NotImplementedError


class Assessment(Model):
    """The Assessment class."""

    _valid_properties: Dict[str, Any] = {
        "id": None,
        "timezone": "US/Eastern",
        "domain": None,
        "target_domains": [],
        "start_date": None,
        "end_date": None,
        "reschedule": False,
        "start_campaign": 1,
        "groups": [],
        "pages": [],
        "campaigns": [],
    }

    def __init__(self, **kwargs):
        """Create a new assessment instance."""
        for key, default in Assessment._valid_properties.items():
            setattr(self, key, kwargs.get(key, default))

    @classmethod
    def parse(cls, json):
        """Parse assessment json."""
        assessment = cls()
        for key, val in json.items():
            if key == "campaigns":
                campaigns = [Campaign.parse(campaign) for campaign in val]
                setattr(assessment, key, campaigns)
            elif key == "page":
                setattr(assessment, key, Page.parse(val))
            elif key == "groups":
                groups = [Group.parse(group) for group in val]
                setattr(assessment, key, groups)
            elif key in cls._valid_properties:
                setattr(assessment, key, val)
        return assessment


class Page(Model):
    """The Page class."""

    _valid_properties = {
        "name": None,
        "capture_credentials": None,
        "capture_passwords": False,
        "html": None,
        "redirect_url": None,
    }

    def __init__(self, **kwargs):
        """Create a new page instance."""
        for key, default in Page._valid_properties.items():
            setattr(self, key, kwargs.get(key, default))

    @classmethod
    def parse(cls, json):
        """Parse page json."""
        page = cls()
        for key, val in json.items():
            if key in cls._valid_properties:
                setattr(page, key, val)
        return page


class Group(Model):
    """The Group class."""

    _valid_properties: Dict[str, Any] = {"name": None, "targets": []}

    def __init__(self, **kwargs):
        """Create a new group instance."""
        for key, default in Group._valid_properties.items():
            setattr(self, key, kwargs.get(key, default))

    @classmethod
    def parse(cls, json):
        """Parse group json."""
        group = cls()
        for key, val in json.items():
            if key == "targets":
                emails = [Target.parse(email) for email in val]
                setattr(group, key, emails)
            elif key in cls._valid_properties:
                setattr(group, key, val)
        return group


class Target(Model):
    """The Target class."""

    _valid_properties = {
        "first_name": None,
        "last_name": None,
        "email": None,
        "position": None,
    }

    def __init__(self, first_name, last_name, email, **kwargs):
        """Create a new target instance."""
        self.first_name = first_name
        self.last_name = last_name
        self.email = email
        if "position" in kwargs.keys():
            setattr(self, "position", kwargs["position"])

    @classmethod
    def parse(cls, json):
        """Parse target json."""
        email = cls(json["first_name"], json["last_name"], json["email"])
        if json["position"]:
            setattr(email, "position", json["position"])
        return email


class Template(Model):
    """The Template class."""

    _valid_properties = {
        "name": None,
        "subject": None,
        "html": None,
        "text": None,
    }

    def __init__(self, **kwargs):
        """Create a new template instance."""
        for key, default in Template._valid_properties.items():
            setattr(self, key, kwargs.get(key, default))

    @classmethod
    def parse(cls, json):
        """Parse template json."""
        template = cls()
        for key, val in json.items():
            if key in cls._valid_properties:
                setattr(template, key, val)
        return template


class SMTP(Model):
    """The SMTP class."""

    _valid_properties = {
        "name": None,
        "from_address": None,
        "password": None,
        "host": "postfix:587",
        "interface_type": "SMTP",
        "ignore_cert": True,
    }

    def __init__(self, **kwargs):
        """Create a new SMTP instance."""
        for key, default in SMTP._valid_properties.items():
            setattr(self, key, kwargs.get(key, default))

    @classmethod
    def parse(cls, json):
        """Parse SMTP json."""
        smtp = cls()
        for key, val in json.items():
            if key in cls._valid_properties:
                setattr(smtp, key, val)
        return smtp


class Campaign(Model):
    """The Campaign class."""

    _valid_properties = {
        "name": None,
        "launch_date": None,
        "complete_date": None,
        "url": None,
        "template": None,
        "smtp": None,
        "group_name": None,
        "page_name": None,
    }

    def __init__(self, **kwargs):
        """Create a new campaign instance."""
        for key, default in Campaign._valid_properties.items():
            setattr(self, key, kwargs.get(key, default))

    @classmethod
    def parse(cls, json):
        """Parse campaign json."""
        campaign = cls()
        for key, val in json.items():
            if key == "template":
                template = Template.parse(val)
                setattr(campaign, key, template)
            elif key == "smtp":
                smtp = SMTP.parse(val)
                setattr(campaign, key, smtp)
            elif key in cls._valid_properties:
                setattr(campaign, key, val)
        return campaign


class Click(Model):
    """The Click class represents a Click object generated by the Gophish API when a user clicks on an email."""

    _valid_properties = {
        "message": None,
        "user": None,
        "source_ip": None,
        "time": None,
        "application": None,
    }

    def __init__(self, **kwargs):
        """Create a new click instance."""
        for key, default in Click._valid_properties.items():
            setattr(self, key, kwargs.get(key, default))

    @classmethod
    def parse(cls, json):
        """Parse click json."""
        click = cls()
        for key, val in json.items():
            if key in cls._valid_properties:
                setattr(click, key, val)

    def __getitem__(self, item):
        """Get item by attribute name."""
        return getattr(self, item)

1	"""The models library."""
2
3	# Standard Python Libraries
4	from datetime import datetime	4✔
5	from typing import Any, Dict	4✔
6
7	# TODO Research .attribute only valid properties
8
9
10	class Model(object):	4✔
11	"""The Model class."""
12
13	_valid_properties: Dict[str, Any] = dict()	4✔
14
15	@classmethod	4✔
16	def _is_builtin(cls, obj):	2✔
17	return isinstance(obj, (int, float, str, list, dict, bool))	4✔
18
19	def as_dict(self):	4✔
20	"""Return a dict representation of the resource."""
21	result = {}	4✔
22	for key in self._valid_properties:	4✔
23	val = getattr(self, key)	4✔
24	if isinstance(val, datetime):	4!
25	val = val.isoformat()	×
26	# Parse custom classes
27	elif val and not Model._is_builtin(val):	4✔
28	val = val.as_dict()	4✔
29	# Parse lists of objects
30	elif isinstance(val, list):	4✔
31	# We only want to call as_dict in the case where the item
32	# isn't a built in type.
33	for i in range(len(val)):	4✔
34	if Model._is_builtin(val[i]):	4✔
35	continue	4✔
36	val[i] = val[i].as_dict()	4✔
37	# If it's a boolean, add it regardless of the value
38	elif isinstance(val, bool):	4✔
39	result[key] = val	4✔
40
41	# Add it if it's not None
42	if val:	4✔
43	result[key] = val	4✔
44	return result	4✔
45
46	@classmethod	4✔
47	def parse(cls, json):	2✔
48	"""Parse a JSON object into a model instance."""
49	raise NotImplementedError	×
50
51
52	class Assessment(Model):	4✔
53	"""The Assessment class."""
54
55	_valid_properties: Dict[str, Any] = {	4✔
56	"id": None,
57	"timezone": "US/Eastern",
58	"domain": None,
59	"target_domains": [],
60	"start_date": None,
61	"end_date": None,
62	"reschedule": False,
63	"start_campaign": 1,
64	"groups": [],
65	"pages": [],
66	"campaigns": [],
67	}
68
69	def __init__(self, **kwargs):	4✔
70	"""Create a new assessment instance."""
71	for key, default in Assessment._valid_properties.items():	4✔
72	setattr(self, key, kwargs.get(key, default))	4✔
73
74	@classmethod	4✔
75	def parse(cls, json):	2✔
76	"""Parse assessment json."""
77	assessment = cls()	4✔
78	for key, val in json.items():	4✔
79	if key == "campaigns":	4✔
80	campaigns = [Campaign.parse(campaign) for campaign in val]	4✔
81	setattr(assessment, key, campaigns)	4✔
82	elif key == "page":	4✔
83	setattr(assessment, key, Page.parse(val))	4✔
84	elif key == "groups":	4✔
85	groups = [Group.parse(group) for group in val]	4✔
86	setattr(assessment, key, groups)	4✔
87	elif key in cls._valid_properties:	4!
88	setattr(assessment, key, val)	4✔
89	return assessment	4✔
90
91
92	class Page(Model):	4✔
93	"""The Page class."""
94
95	_valid_properties = {	4✔
96	"name": None,
97	"capture_credentials": None,
98	"capture_passwords": False,
99	"html": None,
100	"redirect_url": None,
101	}
102
103	def __init__(self, **kwargs):	4✔
104	"""Create a new page instance."""
105	for key, default in Page._valid_properties.items():	4✔
106	setattr(self, key, kwargs.get(key, default))	4✔
107
108	@classmethod	4✔
109	def parse(cls, json):	2✔
110	"""Parse page json."""
111	page = cls()	4✔
112	for key, val in json.items():	4✔
113	if key in cls._valid_properties:	4!
114	setattr(page, key, val)	4✔
115	return page	4✔
116
117
118	class Group(Model):	4✔
119	"""The Group class."""
120
121	_valid_properties: Dict[str, Any] = {"name": None, "targets": []}	4✔
122
123	def __init__(self, **kwargs):	4✔
124	"""Create a new group instance."""
125	for key, default in Group._valid_properties.items():	4✔
126	setattr(self, key, kwargs.get(key, default))	4✔
127
128	@classmethod	4✔
129	def parse(cls, json):	2✔
130	"""Parse group json."""
131	group = cls()	4✔
132	for key, val in json.items():	4✔
133	if key == "targets":	4✔
134	emails = [Target.parse(email) for email in val]	4✔
135	setattr(group, key, emails)	4✔
136	elif key in cls._valid_properties:	4!
137	setattr(group, key, val)	4✔
138	return group	4✔
139
140
141	class Target(Model):	4✔
142	"""The Target class."""
143
144	_valid_properties = {	4✔
145	"first_name": None,
146	"last_name": None,
147	"email": None,
148	"position": None,
149	}
150
151	def __init__(self, first_name, last_name, email, **kwargs):	4✔
152	"""Create a new target instance."""
153	self.first_name = first_name	4✔
154	self.last_name = last_name	4✔
155	self.email = email	4✔
156	if "position" in kwargs.keys():	4✔
157	setattr(self, "position", kwargs["position"])	4✔
158
159	@classmethod	4✔
160	def parse(cls, json):	2✔
161	"""Parse target json."""
162	email = cls(json["first_name"], json["last_name"], json["email"])	4✔
163	if json["position"]:	4!
164	setattr(email, "position", json["position"])	4✔
165	return email	4✔
166
167
168	class Template(Model):	4✔
169	"""The Template class."""
170
171	_valid_properties = {	4✔
172	"name": None,
173	"subject": None,
174	"html": None,
175	"text": None,
176	}
177
178	def __init__(self, **kwargs):	4✔
179	"""Create a new template instance."""
180	for key, default in Template._valid_properties.items():	4✔
181	setattr(self, key, kwargs.get(key, default))	4✔
182
183	@classmethod	4✔
184	def parse(cls, json):	2✔
185	"""Parse template json."""
186	template = cls()	4✔
187	for key, val in json.items():	4✔
188	if key in cls._valid_properties:	4!
189	setattr(template, key, val)	4✔
190	return template	4✔
191
192
193	class SMTP(Model):	4✔
194	"""The SMTP class."""
195
196	_valid_properties = {	4✔
197	"name": None,
198	"from_address": None,
199	"password": None,
200	"host": "postfix:587",
201	"interface_type": "SMTP",
202	"ignore_cert": True,
203	}
204
205	def __init__(self, **kwargs):	4✔
206	"""Create a new SMTP instance."""
207	for key, default in SMTP._valid_properties.items():	4✔
208	setattr(self, key, kwargs.get(key, default))	4✔
209
210	@classmethod	4✔
211	def parse(cls, json):	2✔
212	"""Parse SMTP json."""
213	smtp = cls()	4✔
214	for key, val in json.items():	4✔
215	if key in cls._valid_properties:	4!
216	setattr(smtp, key, val)	4✔
217	return smtp	4✔
218
219
220	class Campaign(Model):	4✔
221	"""The Campaign class."""
222
223	_valid_properties = {	4✔
224	"name": None,
225	"launch_date": None,
226	"complete_date": None,
227	"url": None,
228	"template": None,
229	"smtp": None,
230	"group_name": None,
231	"page_name": None,
232	}
233
234	def __init__(self, **kwargs):	4✔
235	"""Create a new campaign instance."""
236	for key, default in Campaign._valid_properties.items():	4✔
237	setattr(self, key, kwargs.get(key, default))	4✔
238
239	@classmethod	4✔
240	def parse(cls, json):	2✔
241	"""Parse campaign json."""
242	campaign = cls()	4✔
243	for key, val in json.items():	4✔
244	if key == "template":	4✔
245	template = Template.parse(val)	4✔
246	setattr(campaign, key, template)	4✔
247	elif key == "smtp":	4✔
248	smtp = SMTP.parse(val)	4✔
249	setattr(campaign, key, smtp)	4✔
250	elif key in cls._valid_properties:	4✔
251	setattr(campaign, key, val)	4✔
252	return campaign	4✔
253
254
255	class Click(Model):	4✔
256	"""The Click class represents a Click object generated by the Gophish API when a user clicks on an email."""
257
258	_valid_properties = {	4✔
259	"message": None,
260	"user": None,
261	"source_ip": None,
262	"time": None,
263	"application": None,
264	}
265
266	def __init__(self, **kwargs):	4✔
267	"""Create a new click instance."""
268	for key, default in Click._valid_properties.items():	4✔
269	setattr(self, key, kwargs.get(key, default))	4✔
270
271	@classmethod	4✔
272	def parse(cls, json):	2✔
273	"""Parse click json."""
NEW 274	click = cls()	×
NEW 275	for key, val in json.items():	×
NEW 276	if key in cls._valid_properties:	×
NEW 277	setattr(click, key, val)	×
278
279	def __getitem__(self, item):	4✔
280	"""Get item by attribute name."""
281	return getattr(self, item)	4✔

cisagov / gophish-tools / 1148235141

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous