tesi-pegaso/src/auth/utils.py

import json
import os
import hashlib
import jwt as pyjwt
from datetime import datetime, timedelta
import secrets

# Costanti
SECRET_KEY = 'M!3EmyJ@P$yqt$dYRQ#73QtxFy$aTn8M98P8i5T9x9Fd5LHMcHgdfEEt#?H9EPg&9Qhokh$#pTyYLHxL'  # In produzione, usare una variabile d'ambiente
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
USERS_FILE = os.path.join(BASE_DIR, "users", "users.json")
CONFIGS_DIR = os.path.join(BASE_DIR, "users", "configs")

def init_directory_structure():
    """
    Inizializza la struttura delle directory necessarie per l'applicazione
    """
    # Crea directory per utenti e configurazioni
    os.makedirs(os.path.dirname(USERS_FILE), exist_ok=True)
    os.makedirs(CONFIGS_DIR, exist_ok=True)

    # Se il file users.json non esiste, crealo vuoto
    if not os.path.exists(USERS_FILE):
        with open(USERS_FILE, 'w') as f:
            json.dump({}, f)

    print(f"Initialized directory structure:")
    print(f"Users file: {USERS_FILE}")
    print(f"Configs directory: {CONFIGS_DIR}")

def hash_password(password):
    """Hash la password usando SHA-256"""
    return hashlib.sha256(password.encode()).hexdigest()

# In auth/utils.py
def create_user(username, password):
    """
    Crea un nuovo utente
    Args:
        username: nome utente
        password: password in chiaro
    Returns:
        tuple: (success: bool, message: str)
    """
    try:
        print(f"Tentativo di creazione utente: {username}")

        # Inizializza la struttura delle directory
        init_directory_structure()

        # Inizializza o carica il dizionario degli utenti
        users = {}
        if os.path.exists(USERS_FILE):
            try:
                with open(USERS_FILE, 'r') as f:
                    content = f.read()
                    if content.strip():  # Verifica che il file non sia vuoto
                        users = json.loads(content)
                    print(f"Utenti esistenti: {len(users)}")
            except json.JSONDecodeError as e:
                print(f"Errore nel parsing del file utenti: {e}")
                pass

        # Validazioni
        if not username or len(username) < 3:
            return False, "Username deve essere almeno 3 caratteri"
        if not password or len(password) < 6:
            return False, "Password deve essere almeno 6 caratteri"
        if username in users:
            return False, "Username già esistente"

        # Genera il salt e hash della password
        salt = secrets.token_hex(8)
        password_hash = hashlib.sha256((password + salt).encode()).hexdigest()

        # Ottieni il percorso della configurazione utente
        user_config = get_user_config_path(username)
        print(f"Percorso configurazione utente: {user_config}")

        # Crea la configurazione dell'utente
        os.makedirs(os.path.dirname(user_config), exist_ok=True)

        # Salva la configurazione di default
        default_config = get_default_config()
        with open(user_config, 'w') as f:
            json.dump(default_config, f, indent=4)
        print("Configurazione default salvata")

        # Aggiungi nuovo utente con struttura semplificata
        users[username] = {
            "salt": salt,
            "password_hash": password_hash
        }

        # Salva il file utenti
        with open(USERS_FILE, 'w') as f:
            json.dump(users, f, indent=4)
        print("File utenti aggiornato con successo")

        return True, "Utente creato con successo"

    except Exception as e:
        print(f"Errore nella creazione dell'utente: {str(e)}")
        import traceback
        traceback.print_exc()
        return False, f"Errore nella creazione dell'utente: {str(e)}"

def verify_user(username, password):
    """
    Verifica le credenziali utente usando salt e hash
    Args:
        username: nome utente
        password: password in chiaro
    Returns:
        bool: True se le credenziali sono valide, False altrimenti
    """
    try:
        if not os.path.exists(USERS_FILE):
            print("File utenti non trovato")
            return False

        with open(USERS_FILE, 'r') as f:
            users = json.load(f)

        if username not in users:
            print("Username non trovato")
            return False

        # Ottieni il salt e l'hash salvati
        user_data = users[username]
        stored_salt = user_data['salt']
        stored_hash = user_data['password_hash']

        # Calcola l'hash della password fornita con il salt salvato
        password_hash = hashlib.sha256((password + stored_salt).encode()).hexdigest()

        # Confronta gli hash
        return stored_hash == password_hash

    except Exception as e:
        print(f"Errore nella verifica dell'utente: {str(e)}")
        return False

def create_token(username):
    """Crea JWT token"""
    expiration = datetime.utcnow() + timedelta(hours=24)
    return pyjwt.encode(
        {"user": username, "exp": expiration},
        SECRET_KEY,
        algorithm="HS256"
    )

def verify_token(token):
    """Verifica JWT token"""
    try:
        payload = pyjwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        return True, payload["user"]
    except pyjwt.ExpiredSignatureError:
        return False, "Token scaduto"
    except pyjwt.InvalidTokenError:
        return False, "Token non valido"

def get_user_config_path(username):
    """
    Restituisce il percorso del file di configurazione per l'utente specificato
    Args:
        username: nome utente
    Returns:
        str: percorso assoluto del file di configurazione
    """
    # Sostituisci caratteri non validi nel nome utente
    safe_username = "".join(c for c in username if c.isalnum() or c in ('-', '_'))

    # Costruisci il percorso assoluto
    base_dir = os.path.dirname(os.path.abspath(__file__))
    config_dir = os.path.join(base_dir, 'config', 'users')
    config_path = os.path.join(config_dir, f"{safe_username}_config.json")

    # Assicurati che la directory esista
    os.makedirs(os.path.dirname(config_path), exist_ok=True)

    return config_path

def get_default_config():
    return {
        "oliveto": {
            "hectares": 1,
            "varieties": [
                {
                    "variety": "Nocellara dell'Etna",
                    "technique": "tradizionale",
                    "percentage": 50
                },
                {
                    "variety": "Frantoio",
                    "technique": "tradizionale",
                    "percentage": 10
                },
                {
                    "variety": "Coratina",
                    "technique": "tradizionale",
                    "percentage": 40
                }
            ]
        },
        "costs": {
            "fixed": {
                "ammortamento": 2000,
                "assicurazione": 500,
                "manutenzione": 800,
                "certificazioni": 3000
            },
            "variable": {
                "raccolta": 0.35,
                "potatura": 600,
                "fertilizzanti": 400,
                "irrigazione": 300
            },
            "transformation": {
                "molitura": 0.15,
                "stoccaggio": 0.2,
                "bottiglia": 1.2,
                "etichettatura": 0.3
            },
            "marketing": {
                "budget_annuale": 15000,
                "costi_commerciali": 0.5,
                "prezzo_vendita": 12,
                "perc_vendita_diretta": 30
            }
        },
        "inference": {
            "debug_mode": True,
            'model_path': './sources/olive_oil_transformer/olive_oil_transformer_model.keras'
        }
    }