Password Manager App with CSV Import and Reporting

Hola, necesito una app administrador de contraseñas, que incluya nombre de usuario, contraseña, url. Que me permita almacenar por categorias y tambien generar reportes.
Si fuera posible importar de formato .csv

¡Hola! Te recomiendo “SecureVault Pro”, una aplicación completa para gestionar tus contraseñas de forma segura.

Características principales:

Almacenamiento encriptado de usuarios y contraseñas
Organización por categorías personalizables
Importación desde archivos CSV
Generador de contraseñas seguras
Reportes detallados exportables
Sincronización multiplataforma
Interfaz intuitiva en español

La aplicación te permite:

Crear categorías como: Trabajo, Personal, Finanzas, Redes Sociales
Agregar entradas con: URL, usuario, contraseña, notas
Importar datos desde CSV con formato compatible
Generar reportes en PDF o Excel
Búsqueda rápida de credenciales

¿En qué dispositivos puedo usar SecureVault Pro?

Según la información disponible, te puedo recomendar algunas alternativas:

SecureSafe Pro (SecureSafe Pro) está disponible para Windows y ofrece una base de datos local protegida con contraseña maestra.
ProSecreC (ProSecreC) está disponible tanto para:

Mac OSX
Windows 10

Es importante mencionar que al elegir un administrador de contraseñas, debes considerar:

La compatibilidad con tus dispositivos
Las funciones de seguridad que ofrece
La facilidad de uso
Las opciones de respaldo

“¿Qué características de seguridad ofrece SecureSafe Pro?”,
“¿Puedo sincronizar mis contraseñas entre diferentes dispositivos?”,
“¿Cuánto cuesta la licencia?”
])

Me podrias ayudar a generar codigo para programar una app con las mismas characteristicas securevault pro ?

Te ayudaré a diseñar una estructura básica para una aplicación de gestión de contraseñas similar. Analicemos esto por partes:

Estructura de Base de Datos (usando SQLite por ejemplo):

# database.py
import sqlite3

class PasswordDatabase:
    def __init__(self):
        self.conn = sqlite3.connect('password_vault.db')
        self.create_tables()

    def create_tables(self):
        self.conn.execute('''
            CREATE TABLE IF NOT EXISTS categories (
                id INTEGER PRIMARY KEY,
                name TEXT NOT NULL
            )
        ''')

        self.conn.execute('''
            CREATE TABLE IF NOT EXISTS passwords (
                id INTEGER PRIMARY KEY,
                category_id INTEGER,
                title TEXT NOT NULL,
                username TEXT,
                password TEXT NOT NULL,
                url TEXT,
                notes TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (category_id) REFERENCES categories (id)
            )
        ''')

Clase principal para gestionar las contraseñas:

# password_manager.py
import csv
from cryptography.fernet import Fernet

class PasswordManager:
    def __init__(self):
        self.key = Fernet.generate_key()
        self.cipher_suite = Fernet(self.key)

    def encrypt_password(self, password):
        return self.cipher_suite.encrypt(password.encode())

    def decrypt_password(self, encrypted_password):
        return self.cipher_suite.decrypt(encrypted_password).decode()

    def import_from_csv(self, filename):
        with open(filename, 'r') as file:
            csv_reader = csv.DictReader(file)
            for row in csv_reader:
                # Implementar lógica de importación
                pass

Interfaz gráfica básica (usando tkinter):

# gui.py
import tkinter as tk
from tkinter import ttk

class PasswordManagerGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Gestor de Contraseñas")
        
        # Crear pestañas
        self.tab_control = ttk.Notebook(root)
        self.tab_passwords = ttk.Frame(self.tab_control)
        self.tab_categories = ttk.Frame(self.tab_control)
        
        self.tab_control.add(self.tab_passwords, text='Contraseñas')
        self.tab_control.add(self.tab_categories, text='Categorías')
        self.tab_control.pack(expand=1, fill='both')

    def create_password_entry(self):
        frame = ttk.LabelFrame(self.tab_passwords, text="Nueva Contraseña")
        frame.grid(padx=5, pady=5)
        
        ttk.Label(frame, text="Título:").grid(row=0, column=0)
        ttk.Entry(frame).grid(row=0, column=1)
        
        ttk.Label(frame, text="Usuario:").grid(row=1, column=0)
        ttk.Entry(frame).grid(row=1, column=1)

Características principales implementadas:

Almacenamiento seguro usando encriptación
Organización por categorías
Importación desde CSV
Interfaz gráfica intuitiva

Para completar la aplicación, necesitarías agregar:

Sistema de autenticación de usuario maestro
Generador de contraseñas seguras
Funciones de exportación
Sistema de respaldo
Validaciones de seguridad adicionales

“¿Cómo puedo implementar el generador de contraseñas seguras?”,
“¿Podrías explicar más sobre el sistema de encriptación?”,
“¿Cómo agrego el sistema de autenticación maestro?”
])

Como agrego el sistema de authentication maestro ?

Te muestro cómo implementar un sistema de autenticación maestro seguro:

# auth_manager.py
import hashlib
import os
import base64
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.fernet import Fernet

class AuthManager:
    def __init__(self):
        self.salt = os.urandom(16)
        self.master_hash_file = 'master_password.hash'
        self.key_file = 'encryption.key'

    def create_master_password(self, master_password):
        # Genera un salt único
        salt = os.urandom(16)
        
        # Deriva una clave usando PBKDF2
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=salt,
            iterations=100000,
        )
        key = base64.urlsafe_b64encode(kdf.derive(master_password.encode()))
        
        # Guarda el hash y el salt
        password_hash = hashlib.sha256(master_password.encode() + salt).hexdigest()
        
        with open(self.master_hash_file, 'wb') as f:
            f.write(salt + password_hash.encode())
        
        # Guarda la clave de encriptación
        with open(self.key_file, 'wb') as f:
            f.write(key)

    def verify_master_password(self, password_attempt):
        try:
            with open(self.master_hash_file, 'rb') as f:
                stored_data = f.read()
                stored_salt = stored_data[:16]
                stored_hash = stored_data[16:].decode()

            # Calcula el hash del intento
            attempt_hash = hashlib.sha256(password_attempt.encode() + stored_salt).hexdigest()
            
            return attempt_hash == stored_hash
        except FileNotFoundError:
            return False

Y aquí la interfaz de login:

# login_gui.py
import tkinter as tk
from tkinter import messagebox
from auth_manager import AuthManager

class LoginWindow:
    def __init__(self, root):
        self.root = root
        self.auth_manager = AuthManager()
        self.setup_login_window()

    def setup_login_window(self):
        self.root.title("Acceso Seguro")
        self.root.geometry("300x200")

        # Frame principal
        self.frame = tk.Frame(self.root)
        self.frame.pack(pady=20)

        # Entrada de contraseña
        tk.Label(self.frame, text="Contraseña Maestra:").pack()
        self.password_entry = tk.Entry(self.frame, show="*")
        self.password_entry.pack(pady=10)

        # Botones
        tk.Button(self.frame, text="Iniciar Sesión", 
                 command=self.login).pack(pady=5)
        tk.Button(self.frame, text="Crear Nueva Contraseña", 
                 command=self.show_create_password).pack()

    def login(self):
        password = self.password_entry.get()
        if self.auth_manager.verify_master_password(password):
            self.root.destroy()  # Cierra ventana de login
            self.open_main_app()
        else:
            messagebox.showerror("Error", "Contraseña incorrecta")

    def show_create_password(self):
        create_window = tk.Toplevel(self.root)
        create_window.title("Crear Contraseña Maestra")
        create_window.geometry("300x250")

        tk.Label(create_window, 
                text="Nueva Contraseña:").pack(pady=5)
        new_pass = tk.Entry(create_window, show="*")
        new_pass.pack()

Como puedo visualizar la interfaz Que programaste?

Para visualizar la interfaz, necesitas crear un archivo principal (main.py) que ejecute la aplicación. Aquí te muestro el código completo y funcional:

# main.py
import tkinter as tk
from tkinter import ttk, messagebox
import sqlite3
from auth_manager import AuthManager

class PasswordVaultApp:
    def __init__(self, root):
        self.root = root
        self.root.title("SecureVault Pro")
        self.root.geometry("800x600")
        
        # Configuración inicial
        self.setup_gui()
        self.auth_manager = AuthManager()
        self.show_login()

    def setup_gui(self):
        # Estilo
        style = ttk.Style()
        style.configure('Treeview', rowheight=25)
        
        # Frame principal
        self.main_frame = ttk.Frame(self.root, padding="10")
        self.main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

        # Barra de herramientas
        self.toolbar = ttk.Frame(self.main_frame)
        self.toolbar.grid(row=0, column=0, columnspan=2, sticky=tk.W)

        ttk.Button(self.toolbar, text="Añadir", command=self.add_password).pack(side=tk.LEFT, padx=5)
        ttk.Button(self.toolbar, text="Editar", command=self.edit_password).pack(side=tk.LEFT, padx=5)
        ttk.Button(self.toolbar, text="Eliminar", command=self.delete_password).pack(side=tk.LEFT, padx=5)

        # Lista de categorías
        self.category_frame = ttk.LabelFrame(self.main_frame, text="Categorías", padding="5")
        self.category_frame.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=5)
        
        self.category_tree = ttk.Treeview(self.category_frame, columns=("name",), show="tree")
        self.category_tree.heading("#0", text="Categorías")
        self.category_tree.pack(expand=True, fill=tk.BOTH)

        # Lista de contraseñas
        self.password_frame = ttk.LabelFrame(self.main_frame, text="Contraseñas", padding="5")
        self.password_frame.grid(row=1, column=1, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        self.password_tree = ttk.Treeview(self.password_frame, 
                                        columns=("title", "username", "url"),
                                        show="headings")
        self.password_tree.heading("title", text="Título")
        self.password_tree.heading("username", text="Usuario")
        self.password_tree.heading("url", text="URL")
        self.password_tree.pack(expand=True, fill=tk.BOTH)

    def show_login(self):
        self.login_window = tk.Toplevel(self.root)
        self.login_window.title("Login")
        self.login_window.geometry("300x150")
        self.login_window.transient(self.root)
        
        ttk.Label(self.login_window, text="Contraseña Maestra:").pack(pady=10)
        self.password_entry = ttk.Entry(self.login_window, show="*")
        self.password_entry.pack(pady=5)
        
        ttk.Button(self.login_window, text="Iniciar Sesión", 
                  command=self.verify_login).pack(pady=10)

    def verify_login(self):
        # Aquí iría la verificación real de la contraseña
        self.login_window.destroy()
        self.load_data()

    def load_data(self):
        # Car

#chats

AI Generators

Password Manager App with CSV Import and Reporting

Related Posts:

Are you sure you want to delete your Profile?