sciveo 0.1.15__tar.gz → 0.1.17__tar.gz

{sciveo-0.1.15 → sciveo-0.1.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.15
+Version: 0.1.17
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net

{sciveo-0.1.15 → sciveo-0.1.17}/sciveo/__init__.py

@@ -21,7 +21,7 @@ try:
   from sciveo.content.runner import ProjectRunner
   from sciveo.content.dataset import Dataset
   from sciveo.monitoring.start import MonitorStart
-  from sciveo.monitoring.network import NetworkTools
+  from sciveo.network.tools import NetworkTools
   from sciveo.version import __version__
 
 

{sciveo-0.1.15 → sciveo-0.1.17}/sciveo/cli.py

@@ -16,7 +16,7 @@ import argparse
 from sciveo.common.tools.logger import *
 from sciveo.common.tools.timers import Timer
 from sciveo.monitoring.start import MonitorStart
-from sciveo.monitoring.network import NetworkTools
+from sciveo.network.tools import NetworkTools
 from sciveo.common.tools.configuration import GlobalConfiguration
 
 

sciveo-0.1.17/sciveo/common/tools/compress.py

@@ -0,0 +1,26 @@
+import json
+import gzip
+import base64
+
+from sciveo.common.tools.logger import *
+
+
+class CompressJsonData:
+  def __init__(self) -> None:
+    pass
+
+  def compress(self, data):
+    json_data = json.dumps(data).encode('utf-8')
+    compressed_data = gzip.compress(json_data)
+    encoded_data = base64.b64encode(compressed_data).decode('utf-8')
+    debug(type(self).__name__, "compress", len(json_data), "->", len(encoded_data))
+    return encoded_data
+
+  def decompress(self, encoded_data):
+    compressed_data = base64.b64decode(encoded_data)
+    decompressed_data = gzip.decompress(compressed_data)
+    json_data = decompressed_data.decode('utf-8')
+    data = json.loads(json_data)
+    debug(type(self).__name__, "decompress", len(encoded_data), "->", len(json_data))
+    return data
+

sciveo-0.1.17/sciveo/common/tools/crypto.py

@@ -0,0 +1,57 @@
+import json
+import base64
+from Crypto.Cipher import AES
+from Crypto.Random import get_random_bytes
+
+from sciveo.common.tools.logger import *
+
+
+class CryptoJsonData:
+  def __init__(self, base64_key=None) -> None:
+    if base64_key is None:
+      self.gen_key()
+    else:
+      self.key = base64.b64decode(base64_key)
+
+  def get_key(self):
+    return base64.b64encode(self.key).decode("utf-8")
+
+  def gen_key(self):
+    self.key = get_random_bytes(32)
+    return self.get_key()
+
+  def read_key(self, key_path):
+    with open(key_path, 'rb') as fp:
+      self.key = fp.read(32)
+
+  def write_key(self, key_path):
+    with open(key_path, 'wb') as fp:
+      fp.write(self.key)
+
+  def encrypt(self, plaintext, mode=AES.MODE_GCM):
+    iv = get_random_bytes(12)
+    cipher = AES.new(self.key, mode, nonce=iv)
+    data_encrypted, auth_tag = cipher.encrypt_and_digest(plaintext.encode())
+    return {
+      "encrypted": base64.b64encode(data_encrypted).decode("utf-8"),
+      "auth_tag": base64.b64encode(auth_tag).decode("utf-8"),
+      "iv": base64.b64encode(iv).decode("utf-8")
+    }
+
+  def decrypt(self, cipher_data, mode=AES.MODE_GCM):
+    cipher_text = base64.b64decode(cipher_data["encrypted"])
+    auth_tag = base64.b64decode(cipher_data["auth_tag"])
+    iv = base64.b64decode(cipher_data["iv"])
+    cipher = AES.new(self.key,  mode, nonce=iv)
+    return cipher.decrypt_and_verify(cipher_text, auth_tag).decode("utf-8")
+
+  def encrypt_json(self, data):
+    data = json.dumps(data)
+    data = base64.b64encode(data.encode()).decode("utf-8")
+    return self.encrypt(data)
+
+  def decrypt_json(self, encrypted_data):
+    data = self.decrypt(encrypted_data)
+    data = base64.b64decode(data)
+    data = json.loads(data)
+    return data

{sciveo-0.1.15 → sciveo-0.1.17}/sciveo/common/tools/daemon.py

@@ -10,6 +10,7 @@
 #
 
 import threading
+import signal
 import time
 
 from sciveo.common.tools.logger import *
@@ -17,6 +18,22 @@ from sciveo.common.tools.synchronized import ListQueue
 from sciveo.api.upload import APIFileUploader
 
 
+class SignalHandler:
+  def __init__(self, daemons):
+    self.daemons = daemons
+
+    signal.signal(signal.SIGINT, self.handler_int)
+    signal.signal(signal.SIGUSR1, self.handler_usr1)
+
+  def handler_int(self, signum, frame):
+    info(type(self).__name__, "INT signal received", signum, frame)
+    for daemon in self.daemons:
+      daemon.stop()
+
+  def handler_usr1(self, signum, frame):
+    info(type(self).__name__, "USR1 signal received", signum, frame)
+
+
 class DaemonBase:
   def __init__(self, num_threads=1, period=0):
     self.is_running = False

sciveo-0.1.17/sciveo/common/tools/random.py

@@ -0,0 +1,22 @@
+import random
+import string
+
+
+def random_password(length):
+  lower = string.ascii_lowercase
+  upper = string.ascii_uppercase
+  digits = string.digits
+  special = '!@#$%&'
+
+  # Ensure the password contains at least one character from each set
+  password = [
+    random.choice(lower),
+    random.choice(upper),
+    random.choice(digits),
+    random.choice(special)
+  ]
+
+  all_chars = lower + upper + (2 * digits) + (3 * special)
+  password += random.choices(all_chars, k=length - 4)
+  random.shuffle(password)
+  return ''.join(password)

sciveo-0.1.17/sciveo/network/camera.py

@@ -0,0 +1,63 @@
+import threading
+import cv2
+import numpy as np
+
+from sciveo.common.tools.logger import *
+from sciveo.common.tools.timers import FPSCounter
+from sciveo.network.tools import StreamSniffer
+
+
+class RTSPStreamSniffer(StreamSniffer):
+  def on_packet(self, packet):
+    if self.is_rtsp_packet(packet):
+      self.append_ip_packet(packet)
+
+  def is_rtsp_packet(self, packet):
+    return IP in packet and TCP in packet and (packet[TCP].dport == 554 or packet[TCP].sport == 554)
+
+  def get_rtsp_frames(self, ip_src):
+    frames = []
+    current_packets = self.get_ip_stream(ip_src)
+    for packet in current_packets:
+      frame = self.packet_to_frame(packet)
+      if frame is not None:
+        frames.append(frame)
+    return frames
+
+  def packet_to_frame(self, packet):
+    payload = bytes(packet[TCP].payload)
+    nparr = np.frombuffer(payload, np.uint8)
+    frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    return frame
+
+  def play(self, ip_src):
+    fps = FPSCounter(tag=f"play {ip_src}")
+    while True:
+      frames = self.get_rtsp_frames(ip_src)
+      for frame in frames:
+        fps.update()
+        cv2.imshow(f'RTSP Stream from {ip_src}', frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+          return
+
+
+if __name__ == '__main__':
+  sniffer = RTSPStreamSniffer(iface="eth0")
+  sniffer.start()
+
+  camera_ips = []
+
+  threads = []
+  for ip in camera_ips:
+    t = threading.Thread(target=sniffer.play, args=(ip,))
+    t.start()
+    threads.append(t)
+
+  try:
+    while True:
+      pass
+  except KeyboardInterrupt:
+    sniffer.stop_sniffing()
+    for t in threads:
+      t.join()
+    cv2.destroyAllWindows()

sciveo-0.1.15/sciveo/monitoring/network.py → sciveo-0.1.17/sciveo/network/tools.py

@@ -11,6 +11,7 @@
 
 import socket
 import threading
+from scapy.all import sniff, IP, TCP
 
 from sciveo.common.tools.logger import *
 from sciveo.common.tools.timers import Timer
@@ -92,5 +93,60 @@ class NetworkTools:
       pass
 
 
+
+class StreamSniffer:
+  def __init__(self, iface=None):
+    self.iface = iface
+    self.running = False
+    self.lock = threading.Lock()
+    self.streams = {}
+
+  def start(self):
+    self.running = True
+    self.sniff_thread = threading.Thread(target=self.sniff_packets)
+    self.sniff_thread.start()
+
+  def stop(self):
+    debug(type(self).__name__, "stopping...")
+    self.running = False
+    self.sniff_thread.join()
+
+  def sniff_packets(self):
+    debug(type(self).__name__, "start sniffing on", self.iface)
+    sniff(iface=self.iface, prn=self.on_packet, stop_filter=self.should_stop)
+
+  def on_packet(self, packet):
+    if IP in packet:
+      self.append_ip_packet(packet)
+
+  def should_stop(self, packet):
+    return not self.running
+
+  def append_ip_packet(self, packet):
+    ip_src = packet[IP].src
+    with self.lock:
+      self.streams.setdefault(ip_src, [])
+      self.streams[ip_src].append(packet)
+
+  def get_ip_stream(self, ip):
+    current_packets = []
+    with self.lock:
+      if ip in self.streams:
+        current_packets = self.streams[ip][:]
+        self.streams[ip] = []
+    return current_packets
+
+  def keys(self):
+    with self.lock:
+      return list(self.streams.keys())
+
+
 if __name__ == "__main__":
-  debug(NetworkTools(timeout=1.0, localhost=False).scan_port(port=9901))
+  # debug(NetworkTools(timeout=1.0, localhost=False).scan_port(port=9901))
+
+  import time
+  sniffer = StreamSniffer(iface="en0")
+  sniffer.start()
+  time.sleep(5)
+  sniffer.stop()
+  debug(sniffer.keys())

sciveo-0.1.17/sciveo/version.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.1.17'

{sciveo-0.1.15 → sciveo-0.1.17}/sciveo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.15
+Version: 0.1.17
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net

{sciveo-0.1.15 → sciveo-0.1.17}/sciveo.egg-info/SOURCES.txt

@@ -18,11 +18,14 @@ sciveo/common/model.py
 sciveo/common/optimizers.py
 sciveo/common/sampling.py
 sciveo/common/tools/__init__.py
+sciveo/common/tools/compress.py
 sciveo/common/tools/configuration.py
+sciveo/common/tools/crypto.py
 sciveo/common/tools/daemon.py
 sciveo/common/tools/formating.py
 sciveo/common/tools/hardware.py
 sciveo/common/tools/logger.py
+sciveo/common/tools/random.py
 sciveo/common/tools/synchronized.py
 sciveo/common/tools/timers.py
 sciveo/content/__init__.py
@@ -32,9 +35,13 @@ sciveo/content/project.py
 sciveo/content/runner.py
 sciveo/monitoring/__init__.py
 sciveo/monitoring/monitor.py
-sciveo/monitoring/network.py
 sciveo/monitoring/start.py
+sciveo/network/__init__.py
+sciveo/network/camera.py
+sciveo/network/tools.py
+test/test_compress.py
 test/test_configuration.py
+test/test_crypto.py
 test/test_monitoring.py
 test/test_runner.py
 test/test_sampling.py

{sciveo-0.1.15 → sciveo-0.1.17}/sciveo.egg-info/requires.txt

@@ -4,9 +4,12 @@ requests>=0.0.0
 [all]
 psutil>=0.0.0
 netifaces>=0.0.0
+scapy>=0.0.0
+pycryptodome>=0.0.0
 
 [mon]
 psutil>=0.0.0
 
 [net]
 netifaces>=0.0.0
+scapy>=0.0.0

{sciveo-0.1.15 → sciveo-0.1.17}/setup.py

@@ -28,10 +28,13 @@ setup(
       ],
       'net': [
         'netifaces>=0.0.0',
+        'scapy>=0.0.0',
       ],
       'all': [
         'psutil>=0.0.0',
         'netifaces>=0.0.0',
+        'scapy>=0.0.0',
+        'pycryptodome>=0.0.0'
       ]
     },
     py_modules=['sciveo'],

sciveo-0.1.17/test/test_compress.py

@@ -0,0 +1,16 @@
+import unittest
+import json
+
+from sciveo.common.tools.compress import *
+
+
+class TestEncoders(unittest.TestCase):
+  def test_compress_json(self):
+    zip = CompressJsonData()
+    j1 = {"AAA": [1, 2, 3], "BBB": {"CCC": 1, "DDD": 2, "EEE": 3}, "CC": 3}
+    j2 = zip.decompress(zip.compress(j1))
+    self.assertEqual(json.dumps(j1, sort_keys=True), json.dumps(j2, sort_keys=True))
+
+
+if __name__ == '__main__':
+  unittest.main()

sciveo-0.1.17/test/test_crypto.py

@@ -0,0 +1,34 @@
+import unittest
+
+from sciveo.common.tools.crypto import *
+
+
+class TestCrypto(unittest.TestCase):
+  def test_string(self):
+    c = CryptoJsonData()
+    m1 = "test message string encrypt and decrypt"
+    m2 = c.decrypt(c.encrypt(m1))
+    self.assertEqual(m1, m2)
+
+  def test_json(self):
+    c = CryptoJsonData()
+    j1 = {"A": 1, "B": []}
+    j2 = c.decrypt_json(c.encrypt_json(j1))
+    self.assertEqual(json.dumps(j1, sort_keys=True), json.dumps(j2, sort_keys=True))
+
+  def test_big_json(self):
+    c = CryptoJsonData()
+    j1 = {"test": 1, "L": [1,2,3,4], "W": "A", "B": "C", "D1": {1: 2, 2: 3, 3: 4}, "L2": [[1,2,3], [3,4,5]]}
+    j2 = c.decrypt_json(c.encrypt_json(j1))
+    self.assertEqual(json.dumps(j1, sort_keys=True), json.dumps(j2, sort_keys=True))
+
+  def test_key(self):
+    key = "OZ1IIdAh3b6h+E7fgIGo33rRsNT8Vg428GVC4FAGZGM="
+    c = CryptoJsonData(key)
+    m1 = "test message string encrypt and decrypt"
+    m2 = c.decrypt(c.encrypt(m1))
+    self.assertEqual(m1, m2)
+
+
+if __name__ == '__main__':
+    unittest.main()

sciveo-0.1.15/sciveo/version.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.1.15'