IoT_PreTester_Demo/V4.5/django_project/IoTAnalyzer/models.py

from django.db import models
import json

#This class defines the manufacturer
class Manufacturer(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=50)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "name": self.name,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_manufacturer'
        ordering = ['name']

#This class defines the device type
class DeviceType(models.Model):
    id = models.AutoField(primary_key=True)
    device_type = models.CharField(max_length=50)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "device_type": self.device_type,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_device_type'
        ordering = ['device_type']

#This class defines the product
class Product(models.Model):
    id = models.AutoField(primary_key=True)
    manufacturer = models.ForeignKey(Manufacturer, on_delete=models.PROTECT)
    device_type = models.ForeignKey(DeviceType, on_delete=models.PROTECT)
    product_name = models.CharField(max_length=50)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "manufacturer": self.manufacturer.to_json(),
            "product_name": self.product_name,
            "device_type": self.device_type.to_json(),
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_product'
        ordering = ['product_name']

#This class defines the hardware device
class Device(models.Model):
    id = models.AutoField(primary_key=True)
    product = models.ForeignKey(Product, on_delete=models.PROTECT)
    serial = models.CharField(max_length=50)
    comment = models.CharField(max_length=50)
    created = models.DateTimeField(auto_now_add=True)
    #firmware = models.ManyToManyField(Firmware,  through='FirmwareDevices')

    def to_json(self):
        return {
            "id": self.id,
            "product": self.product.to_json(),
            "serial": self.serial,
            "comment":self.comment,
            "created": self.created.isoformat(),
        }

    class Meta:
        db_table = 'iot_device'
        unique_together = ('product', 'serial')

#This class defines the software for the hardware device
class Firmware(models.Model):
    id = models.AutoField(primary_key=True)
    version = models.CharField(max_length=50)
    product = models.ForeignKey(Product, on_delete=models.PROTECT)
    created = models.DateTimeField(auto_now_add=True)
    devices = models.ManyToManyField(Device,  through='FirmwareDevices')

    def to_json(self):
        return {
            "id": self.id,
            "version": self.version,
            "product": self.product.id,
            "created": self.created.isoformat(),
        }

    class Meta:
        db_table = 'iot_firmware'
        unique_together = ('product', 'version')

class FirmwareDevices(models.Model):
    id = models.AutoField(primary_key=True)
    firmware = models.ForeignKey(Firmware, on_delete=models.CASCADE)
    device = models.ForeignKey(Device, on_delete=models.CASCADE)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "firmware_id": self.firmware.id,
            "device_id": self.device_id,
            "created": self.created.isoformat(),
        }
    class Meta:
        db_table = 'iot_firmware_devices'

# This class represents the Pcap file
class File(models.Model):
    id = models.AutoField(primary_key=True)
    firmware = models.ForeignKey(Firmware, on_delete=models.CASCADE)
    device = models.ForeignKey(Device, on_delete=models.CASCADE)
    filename = models.CharField(max_length=50)
    ip_address = models.CharField(max_length=50)
    status = models.CharField(max_length=50)
    upload_time = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "filename": self.filename,
            "ip_address": self.ip_address,
            "status": self.status,
            "upload_time": self.upload_time.isoformat()
        }

    class Meta:
        db_table = 'iot_files'

### Raw data
# This class represents the raw dataset
class RawDataset(models.Model):
    id = models.AutoField(primary_key=True)
    file = models.ForeignKey(File, on_delete=models.CASCADE)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "file": self.file.to_json(),
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_raw_dataset'

# This class represents the raw hash data.
class HashRaw(models.Model):
    id = models.AutoField(primary_key=True)
    raw_dataset = models.ForeignKey(RawDataset, on_delete=models.CASCADE)
    hash_value = models.CharField(max_length=50)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "raw_dataset.id": self.raw_dataset.id,
            "hash_value": self.hash_value,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_raw_hash'

# This class represents the raw DNS data
class DnsRaw(models.Model):
    id = models.AutoField(primary_key=True)
    raw_dataset = models.ForeignKey(RawDataset, on_delete=models.CASCADE)
    dns_hostname = models.CharField(max_length=200)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "raw_dataset_id": self.raw_dataset.id,
            "dns_hostname": self.dns_hostname,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_raw_dns'

# This class represents the raw URL data
class UrlRaw(models.Model):
    id = models.AutoField(primary_key=True)
    raw_dataset = models.ForeignKey(RawDataset, on_delete=models.CASCADE)
    url = models.CharField(max_length=200)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "raw_dataset.id": self.raw_dataset.id,
            "url": self.url,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_raw_url'

# This class represents the tools used
class Tool(models.Model):
    id = models.AutoField(primary_key=True)
    tool_name = models.CharField(max_length=50)
    version = models.CharField(max_length=50)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "tool_name": self.tool_name,
            "version": self.version,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_tool'
### Analyzed data
# A class for discovered ports
class Port(models.Model):
    id = models.AutoField(primary_key=True)
    port = models.IntegerField(unique=True)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "port": self.port,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_ports'

# A class for discovered TLS versions
class TlsVersion(models.Model):
    id = models.AutoField(primary_key=True)
    tls_version = models.TextField(max_length=50, unique=True)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "tls_version": self.tls_version,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_tls_versions'

    def __str__(self):
        return self.tls_version

# A class for discovered CipherSuites
class CipherSuite(models.Model):
    id = models.AutoField(primary_key=True)
    cipher_suite = models.TextField(max_length=50, unique=True)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "cipher_suite": self.cipher_suite,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_cipher_suites'

    def __str__(self):
        return self.cipher_suite

# A class for hash types
class HashType(models.Model):
    id = models.AutoField(primary_key=True)
    hash_type = models.TextField(max_length=50, unique=True)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "hash_type": self.hash_type,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_hash_types'


# This class represents an analyzed dataset
class AnalyzedDataset(models.Model):
    id = models.AutoField(primary_key=True)
    file = models.ForeignKey(File, on_delete=models.CASCADE)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "file": self.file.id,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_analyzed_dataset'

# This class represents the analyzed DNS data
class DnsAnalyzed(models.Model):
    id = models.AutoField(primary_key=True)
    analyzed_dataset = models.ForeignKey(AnalyzedDataset, on_delete=models.CASCADE)
    dns_hostname = models.TextField(max_length=200)
    record_type = models.TextField(max_length=50)
    tool = models.ForeignKey(Tool, on_delete=models.PROTECT)
    ports = models.ManyToManyField(Port)
    tls_versions = models.ManyToManyField(TlsVersion)
    cipher_suites = models.ManyToManyField(CipherSuite)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "analyzed_dataset_id": self.analyzed_dataset.id,
            "dns_hostname": self.dns_hostname,
            "record_type": self.record_type,
            "tool": self.tool.id,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_analyzed_dns'

# This class represents the analyzed URL data
class UrlAnalyzed(models.Model):
    id = models.AutoField(primary_key=True)
    analyzed_dataset = models.ForeignKey(AnalyzedDataset, on_delete=models.CASCADE)
    url = models.TextField(max_length=200)
    tool = models.ForeignKey(Tool, on_delete=models.PROTECT)
    ports = models.ManyToManyField(Port)
    tls_versions = models.ManyToManyField(TlsVersion)
    cipher_suites = models.ManyToManyField(CipherSuite)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "analyzed_dataset_id": self.analyzed_dataset.id,  # _id instead of .id for consistency
            "url": self.url,
            "tool_id": self.tool.id,  # _id added for consistency
            "ports": [port.to_json() for port in self.ports.all()],  # to_json() instead of only id
            "tls_versions": [version.to_json() for version in self.tls_versions.all()],  # to_json()
            "cipher_suites": [suite.to_json() for suite in self.cipher_suites.all()],  # to_json()
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_analyzed_url'

# This class represents the analyzed hash data
class HashAnalyzed(models.Model):
   id = models.AutoField(primary_key=True)
   analyzed_dataset = models.ForeignKey(AnalyzedDataset, on_delete=models.CASCADE)
   hash_type = models.ManyToManyField(HashType)
   hash_value = models.CharField(max_length=50)
   cracked = models.BooleanField(default=False)
   cracked_value = models.CharField(max_length=50, blank=True, null=True)
   crack_time = models.CharField(max_length=50, blank=True, null=True)
   tool = models.ForeignKey(Tool, on_delete=models.PROTECT)
   created = models.DateTimeField(auto_now_add=True)

   def to_json(self):
       return {
           "id": self.id,
           "analyzed_dataset_id": self.analyzed_dataset.id,
           "hash_type": [hash_type.to_json() for hash_type in self.hash_type.all()],
           "hash_value": self.hash_value,
           "cracked": self.cracked,
           "cracked_value": self.cracked_value,
           "crack_time": self.crack_time,
           "tool": self.tool.id,
           "created": self.created.isoformat()
       }

   class Meta:
       db_table = 'iot_analyzed_hash'


# This class represents Binwalk raw data
class BinwalkRaw(models.Model):
    id = models.AutoField(primary_key=True)
    raw_dataset = models.ForeignKey(RawDataset, on_delete=models.CASCADE)
    offset = models.CharField(max_length=20)  # Hex offset (e.g. 0x1000)
    description = models.TextField(max_length=500)  # What was found
    file_path = models.TextField(max_length=500, blank=True, null=True)  # Extracted file
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "raw_dataset_id": self.raw_dataset.id,
            "offset": self.offset,
            "description": self.description,
            "file_path": self.file_path,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_raw_binwalk'

# This class represents Strings raw data
class StringsRaw(models.Model):
    id = models.AutoField(primary_key=True)
    raw_dataset = models.ForeignKey(RawDataset, on_delete=models.CASCADE)
    string_value = models.TextField(max_length=1000)
    string_type = models.CharField(max_length=50, default='generic')  # url, ip, path, generic
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "raw_dataset_id": self.raw_dataset.id,
            "string_value": self.string_value,
            "string_type": self.string_type,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_raw_strings'

# This class represents analyzed Binwalk data
class BinwalkAnalyzed(models.Model):
    id = models.AutoField(primary_key=True)
    analyzed_dataset = models.ForeignKey(AnalyzedDataset, on_delete=models.CASCADE)
    component_type = models.CharField(max_length=100)  # e.g. "Linux Kernel", "U-Boot"
    offset = models.CharField(max_length=20)
    size = models.CharField(max_length=20, blank=True, null=True)
    entropy = models.FloatField(blank=True, null=True)  # Encryption/compression
    tool = models.ForeignKey(Tool, on_delete=models.PROTECT)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "analyzed_dataset_id": self.analyzed_dataset.id,
            "component_type": self.component_type,
            "offset": self.offset,
            "size": self.size,
            "entropy": self.entropy,
            "tool_id": self.tool.id,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_analyzed_binwalk'

# This class represents analyzed Strings data (critical findings)
class StringsAnalyzed(models.Model):
    id = models.AutoField(primary_key=True)
    analyzed_dataset = models.ForeignKey(AnalyzedDataset, on_delete=models.CASCADE)
    string_value = models.TextField(max_length=1000)
    category = models.CharField(max_length=50)  # credentials, api_key, url, ip, path
    severity = models.CharField(max_length=20, default='info')  # critical, high, medium, low, info
    tool = models.ForeignKey(Tool, on_delete=models.PROTECT)
    created = models.DateTimeField(auto_now_add=True)

    def to_json(self):
        return {
            "id": self.id,
            "analyzed_dataset_id": self.analyzed_dataset.id,
            "string_value": self.string_value,
            "category": self.category,
            "severity": self.severity,
            "tool_id": self.tool.id,
            "created": self.created.isoformat()
        }

    class Meta:
        db_table = 'iot_analyzed_strings'