Part F: Security Considerations - Decorator & DAO Patterns

/**
 * AuthService handles user authentication with security considerations
 */
public class AuthService {
 
    /**
     * Secure login implementation with prepared statements
     * Prevents SQL injection and implements proper error handling
     */
    public IUser login(String username, String password) {
        // SECURITY: Use parameterized query to prevent SQL injection
        String sql = "SELECT role, doctor_id FROM staff WHERE username = ? AND password_hash = ?";
 
        try (Connection conn = DatabaseManager.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
            // SECURITY: Set parameters to prevent injection attacks
            pstmt.setString(1, username);
            pstmt.setString(2, password); // Note: In production, this should be hashed
 
            ResultSet rs = pstmt.executeQuery();
 
            if (rs.next()) {
                String role = rs.getString("role");
                String doctorId = rs.getString("doctor_id");
 
                // Handle NULL values safely
                if (rs.wasNull()) {
                    doctorId = null;
                }
 
                System.out.println("Login successful for user: " + username + " with role: " + role);
                return decorateUser(username, role, doctorId);
            }
 
        } catch (SQLException e) {
            // SECURITY: Log errors without exposing sensitive information
            System.err.println("Database error during login: " + e.getMessage());
        }
 
        // SECURITY: Generic failure message to prevent user enumeration
        System.out.println("Login failed for user: " + username);
        return null;
    }
 
    /**
     * SECURITY: Factory method that applies appropriate security decorators
     */
    private IUser decorateUser(String username, String role, String doctorId) {
        IUser user = new BaseUser(username, role, doctorId);
 
        // Apply role-based security decorators
        switch (role) {
            case "Doctor":
                return new DoctorRole(user);
            case "Nurse":
                return new NurseRole(user);
            case "Admin":
                return new AdminRole(user);
            default:
                // SECURITY: Return base user with minimal permissions for unknown roles
                return user;
        }
    }
}
 

/**
 * DoctorRole decorator with specific security permissions
 */
public class DoctorRole extends UserRoleDecorator {
 
    @Override
    public boolean hasPermission(String permission) {
        // SECURITY: Explicit whitelist of doctor permissions
        switch (permission) {
            case "can_access_appointments":
            case "can_mark_appointment_done":
            case "can_update_appointment":
            case "can_access_patients":
            case "can_add_appointment_notes":
                return true;
            default:
                // SECURITY: Delegate to parent for unknown permissions
                return super.hasPermission(permission);
        }
    }
}
 
/**
 * NurseRole decorator with restricted permissions
 */
public class NurseRole extends UserRoleDecorator {
 
    @Override
    public boolean hasPermission(String permission) {
        // SECURITY: Explicit permission whitelist for nurses
        Set<String> allowedPermissions = Set.of(
            "can_access_patients",
            "can_access_appointments",
            "can_generate_reports",
            "can_book_appointment",
            "can_cancel_appointment",
            "can_update_appointment_reason"
        );
 
        if (allowedPermissions.contains(permission)) {
            return true;
        }
 
        // SECURITY: Explicit denial of dangerous permissions
        Set<String> deniedPermissions = Set.of(
            "can_delete_patient",
            "can_delete_appointment",
            "can_delete_bill",
            "can_access_billing",
            "can_manage_staff"
        );
 
        if (deniedPermissions.contains(permission)) {
            return false;
        }
 
        return super.hasPermission(permission);
    }
}
 

/**
 * PatientDAO implements secure data access patterns
 */
public class PatientDAO {
 
    /**
     * SECURITY: Create patient with parameterized queries
     */
    public boolean createPatient(PatientRecord patient) {
        String sql = "INSERT INTO patients (patient_id, full_name, medical_history, " +
                    "treatment_plans, insurance_plan_id) VALUES (?, ?, ?, ?, ?)";
 
        try (Connection conn = DatabaseManager.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
            // SECURITY: Use prepared statement parameters
            pstmt.setString(1, patient.getPatientId());
            pstmt.setString(2, patient.getName());
            pstmt.setString(3, String.join("\\n", patient.getMedicalHistory()));
            pstmt.setString(4, String.join("\\n", patient.getTreatmentPlans()));
 
            // SECURITY: Handle NULL values safely
            if (patient.getInsurancePlan() != null) {
                pstmt.setInt(5, patient.getInsurancePlan().getPlanId());
            } else {
                pstmt.setNull(5, Types.INTEGER);
            }
 
            return pstmt.executeUpdate() > 0;
        } catch (SQLException e) {
            // SECURITY: Log errors without exposing sensitive patient data
            System.err.println("Error creating patient: " + e.getMessage());
            return false;
        }
    }
 
    /**
     * SECURITY: Safe patient deletion with parameterized query
     */
    public boolean deletePatient(String patientId) {
        String sql = "DELETE FROM patients WHERE patient_id = ?";
 
        try (Connection conn = DatabaseManager.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
            // SECURITY: Parameterized query prevents injection
            pstmt.setString(1, patientId);
            return pstmt.executeUpdate() > 0;
        } catch (SQLException e) {
            // SECURITY: Generic error logging
            System.err.println("Error deleting patient: " + e.getMessage());
            return false;
        }
    }
}
 

/**
 * StaffDAO with enhanced security for user account management
 */
public class StaffDAO {
 
    /**
     * SECURITY: Secure staff creation with duplicate prevention
     */
    public boolean createStaff(Staff staff) {
        // SECURITY: Check for existing username to prevent duplicates
        if (getStaffByUsername(staff.getUsername()) != null) {
            System.err.println("Error: Staff with username '" + staff.getUsername() + "' already exists.");
            return false;
        }
 
        String sql = "INSERT INTO staff (username, password_hash, role, doctor_id) VALUES (?, ?, ?, ?)";
 
        try (Connection conn = DatabaseManager.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
 
            // SECURITY: Parameterized values prevent injection
            pstmt.setString(1, staff.getUsername());
            pstmt.setString(2, staff.getPasswordHash()); // Should be properly hashed
            pstmt.setString(3, staff.getRole());
 
            // SECURITY: Handle optional doctor_id safely
            if (staff.getDoctorId() != null && !staff.getDoctorId().isEmpty()) {
                pstmt.setString(4, staff.getDoctorId());
            } else {
                pstmt.setNull(4, java.sql.Types.VARCHAR);
            }
 
            int affectedRows = pstmt.executeUpdate();
            if (affectedRows > 0) {
                // SECURITY: Update object with generated ID
                try (ResultSet generatedKeys = pstmt.getGeneratedKeys()) {
                    if (generatedKeys.next()) {
                        staff.setStaffId(generatedKeys.getInt(1));
                    }
                }
                return true;
            }
        } catch (SQLException e) {
            // SECURITY: Log error without exposing sensitive data
            System.err.println("Error creating staff: " + e.getMessage());
        }
        return false;
    }
 
    /**
     * SECURITY: Secure staff retrieval by username
     */
    public Staff getStaffByUsername(String username) {
        String sql = "SELECT staff_id, username, password_hash, role, doctor_id FROM staff WHERE username = ?";
 
        try (Connection conn = DatabaseManager.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
            // SECURITY: Parameterized query
            pstmt.setString(1, username);
            ResultSet rs = pstmt.executeQuery();
 
            if (rs.next()) {
                return new Staff(
                    rs.getInt("staff_id"),
                    rs.getString("username"),
                    rs.getString("password_hash"),
                    rs.getString("role"),
                    rs.getString("doctor_id")
                );
            }
        } catch (SQLException e) {
            System.err.println("Error fetching staff by username: " + e.getMessage());
        }
        return null;
    }
}
 

// GOOD: Parameterized query prevents SQL injection
String sql = "SELECT * FROM patients WHERE patient_id = ?";
try (Connection conn = DatabaseManager.getConnection();
     PreparedStatement pstmt = conn.prepareStatement(sql)) {
    pstmt.setString(1, patientId);
    ResultSet rs = pstmt.executeQuery();
    // Process results...
}
 
// BAD: String concatenation vulnerable to injection (NOT used in system)
// String sql = "SELECT * FROM patients WHERE patient_id = '" + patientId + "'";
 

/**
 * Example of safe parameter handling in BillingDAO
 */
public int saveBill(MedicalBill bill) {
    String sql = "INSERT INTO billing (bill_id, patient_id, service_description, amount, " +
                "status, processing_log, final_amount, insurance_policy_number, " +
                "billed_datetime, amount_paid, insurance_paid_amount) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
 
    try (Connection conn = DatabaseManager.getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
 
        // SECURITY: All parameters are safely set
        if (bill.getBillId() == 0) {
            pstmt.setNull(1, java.sql.Types.INTEGER);
        } else {
            pstmt.setInt(1, bill.getBillId());
        }
 
        pstmt.setString(2, bill.getPatientId());
        pstmt.setString(3, bill.getServiceDescription());
        pstmt.setDouble(4, bill.getAmount());
        pstmt.setString(5, bill.getStatus());
        pstmt.setString(6, bill.getProcessingLog());
        pstmt.setDouble(7, bill.getFinalAmount());
 
        // SECURITY: Handle nullable insurance plan safely
        pstmt.setString(8, bill.getAppliedInsurancePlan() != null ?
                       bill.getAppliedInsurancePlan().getPlanName() : null);
 
        // SECURITY: Safe timestamp handling
        if (bill.getBilledDateTime() != null) {
            pstmt.setTimestamp(9, Timestamp.valueOf(bill.getBilledDateTime()));
        } else {
            pstmt.setTimestamp(9, Timestamp.valueOf(LocalDateTime.now()));
        }
 
        pstmt.setDouble(10, bill.getAmountPaid());
        pstmt.setDouble(11, bill.getInsurancePaidAmount());
 
        return pstmt.executeUpdate();
    } catch (SQLException e) {
        System.err.println("Error saving bill: " + e.getMessage());
        return -1;
    }
}
 

/**
 * Example of RBAC implementation in patient management
 */
private void deletePatient() {
    // SECURITY: Check permissions before any operation
    if (!currentUser.hasPermission("can_delete_patient")) {
        JOptionPane.showMessageDialog(view,
            "You do not have permission to delete patient records.",
            "Access Denied", JOptionPane.ERROR_MESSAGE);
        return;
    }
 
    if (currentPatient == null) return;
 
    // SECURITY: Confirmation dialog for destructive operations
    int response = JOptionPane.showConfirmDialog(view,
        "Are you sure you want to delete patient " + currentPatient.getName() + "?",
        "Confirm Deletion", JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
 
    if (response == JOptionPane.YES_OPTION) {
        boolean success = dao.deletePatient(currentPatient.getPatientId());
        if (success) {
            JOptionPane.showMessageDialog(view, "Patient deleted successfully.",
                "Success", JOptionPane.INFORMATION_MESSAGE);
            view.clearFields();
        } else {
            JOptionPane.showMessageDialog(view, "Failed to delete patient.",
                "Error", JOptionPane.ERROR_MESSAGE);
        }
    }
}
 
/**
 * SECURITY: Staff management with administrative permissions
 */
private void addStaff() {
    if (!currentUser.hasPermission("can_manage_staff")) {
        JOptionPane.showMessageDialog(mainFrame,
            "You do not have permission to add staff members.",
            "Access Denied", JOptionPane.ERROR_MESSAGE);
        return;
    }
 
    // Proceed with staff creation...
}
 

/**
 * Example of context-aware security in appointment management
 */
private void updatePrescription() {
    // SECURITY: Multiple layers of permission checking
    if (!currentUser.hasPermission("can_add_appointment_notes")) {
        JOptionPane.showMessageDialog(mainFrame,
            "You do not have permission to update prescriptions.",
            "Access Denied", JOptionPane.ERROR_MESSAGE);
        return;
    }
 
    Appointment selectedAppointment = view.getSelectedAppointment(currentAppointments);
    if (selectedAppointment == null) {
        JOptionPane.showMessageDialog(view,
            "Please select an appointment to update prescription.",
            "Warning", JOptionPane.WARNING_MESSAGE);
        return;
    }
 
    // SECURITY: Ownership verification for doctors
    if (currentUser.getDoctorId() == null ||
        !currentUser.getDoctorId().equals(selectedAppointment.getDoctorId())) {
        JOptionPane.showMessageDialog(mainFrame,
            "You can only update prescriptions for your own appointments.",
            "Access Denied", JOptionPane.ERROR_MESSAGE);
        return;
    }
 
    // SECURITY: Status validation
    if ("Canceled".equalsIgnoreCase(selectedAppointment.getStatus())) {
        JOptionPane.showMessageDialog(view,
            "Cannot update prescription for canceled appointments.",
            "Invalid Operation", JOptionPane.WARNING_MESSAGE);
        return;
    }
 
    // Proceed with prescription update...
}
 

-- SECURITY: Foreign key constraints prevent orphaned records
CREATE TABLE `staff` (
  `staff_id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password_hash` varchar(255) NOT NULL,  -- Stores hashed passwords
  `role` varchar(50) NOT NULL,
  `doctor_id` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`staff_id`),
  UNIQUE KEY `username` (`username`),    -- Prevents duplicate usernames
  KEY `doctor_id` (`doctor_id`),
  CONSTRAINT `fk_staff_doctor_id` FOREIGN KEY (`doctor_id`)
    REFERENCES `doctors` (`doctor_id`) ON DELETE SET NULL
) ENGINE=InnoDB;
 
-- SECURITY: Patient data with insurance plan constraints
CREATE TABLE `patients` (
  `patient_id` varchar(50) NOT NULL,
  `full_name` varchar(255) NOT NULL,
  `medical_history` text,
  `treatment_plans` text,
  `insurance_plan_id` int DEFAULT NULL,
  PRIMARY KEY (`patient_id`),
  KEY `insurance_plan_id` (`insurance_plan_id`),
  CONSTRAINT `patients_ibfk_1` FOREIGN KEY (`insurance_plan_id`)
    REFERENCES `insurance_plans` (`plan_id`)
) ENGINE=InnoDB;
 

/**
 * Note: The current implementation shows basic connection management
 * In production, this should include:
 * - Connection pooling for performance and security
 * - SSL/TLS encryption for data in transit
 * - Proper credential management (not hardcoded)
 */
public class DatabaseManager {
    // SECURITY CONCERN: Credentials should not be hardcoded
    private static final String JDBC_URL = "jdbc:mysql://localhost:3306/globemed_db";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "your_password";
 
    public static Connection getConnection() throws SQLException {
        if (connection == null || connection.isClosed()) {
            try {
                Class.forName("com.mysql.cj.jdbc.Driver");
                connection = DriverManager.getConnection(JDBC_URL, USERNAME, PASSWORD);
                System.out.println("Database connection successful!");
            } catch (ClassNotFoundException e) {
                System.err.println("MySQL JDBC Driver not found.");
                throw new SQLException("JDBC Driver not found", e);
            }
        }
        return connection;
    }
}
 

/**
 * RECOMMENDED: Secure password hashing implementation
 */
public class PasswordSecurity {
    private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(12);
 
    public static String hashPassword(String plainPassword) {
        return encoder.encode(plainPassword);
    }
 
    public static boolean verifyPassword(String plainPassword, String hashedPassword) {
        return encoder.matches(plainPassword, hashedPassword);
    }
}
 
// Updated AuthService login method
public IUser login(String username, String password) {
    String sql = "SELECT role, doctor_id, password_hash FROM staff WHERE username = ?";
 
    try (Connection conn = DatabaseManager.getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
        pstmt.setString(1, username);
        ResultSet rs = pstmt.executeQuery();
 
        if (rs.next()) {
            String storedHash = rs.getString("password_hash");
 
            // SECURITY: Verify password against hash
            if (PasswordSecurity.verifyPassword(password, storedHash)) {
                String role = rs.getString("role");
                String doctorId = rs.getString("doctor_id");
                return decorateUser(username, role, doctorId);
            }
        }
    } catch (SQLException e) {
        System.err.println("Database error during login: " + e.getMessage());
    }
 
    return null;
}
 

/**
 * RECOMMENDED: Secure configuration management
 */
public class DatabaseManager {
    private static final String JDBC_URL = System.getenv("DB_URL");
    private static final String USERNAME = System.getenv("DB_USERNAME");
    private static final String PASSWORD = System.getenv("DB_PASSWORD");
 
    public static Connection getConnection() throws SQLException {
        if (JDBC_URL == null || USERNAME == null || PASSWORD == null) {
            throw new SQLException("Database configuration not properly set");
        }
 
        // Add SSL parameters for encrypted connections
        String secureUrl = JDBC_URL + "?useSSL=true&requireSSL=true&verifyServerCertificate=true";
        return DriverManager.getConnection(secureUrl, USERNAME, PASSWORD);
    }
}
 

/**
 * RECOMMENDED: Secure session management
 */
public class SessionManager {
    private static final Map<String, UserSession> activeSessions = new ConcurrentHashMap<>();
    private static final long SESSION_TIMEOUT = 30 * 60 * 1000; // 30 minutes
 
    public static class UserSession {
        private final IUser user;
        private final long createdTime;
        private long lastAccessTime;
 
        public UserSession(IUser user) {
            this.user = user;
            this.createdTime = System.currentTimeMillis();
            this.lastAccessTime = createdTime;
        }
 
        public boolean isValid() {
            long currentTime = System.currentTimeMillis();
            return (currentTime - lastAccessTime) < SESSION_TIMEOUT;
        }
 
        public void updateAccess() {
            this.lastAccessTime = System.currentTimeMillis();
        }
    }
 
    public static String createSession(IUser user) {
        String sessionId = UUID.randomUUID().toString();
        activeSessions.put(sessionId, new UserSession(user));
        return sessionId;
    }
 
    public static IUser getUser(String sessionId) {
        UserSession session = activeSessions.get(sessionId);
        if (session != null && session.isValid()) {
            session.updateAccess();
            return session.user;
        } else {
            activeSessions.remove(sessionId);
            return null;
        }
    }
}