Hier is een voorbeeld van Ruby-code voor het implementeren van veilige gebruikersauthenticatie en autorisatie in een online winkel met klanten en een beheerdersdashboard. Ik gebruik Ruby on Rails met de populaire gem Devise voor authenticatie en Pundit voor autorisatie, omdat deze best practices en beveiligingsmaatregelen bieden. 1. Authenticatiemethoden: - Gebruikers kunnen zich registreren en inloggen via email en wachtwoord. - Gebruik van beveiligde wachtwoord hashing (Devise doet dit standaard). - Beveiliging tegen CSRF-aanvallen met Rails standaard beveiligingen. 2. Autorisatievereisten: - Klanten kunnen alleen hun eigen gegevens bekijken en bestellen plaatsen. - Beheerders hebben toegang tot het dashboard en beheertaken. 3. Voorbeeldimplementatie: a. Gem installatie (Gemfile) ```ruby gem 'devise' gem 'pundit' ``` b. Devise setup ```bash bundle install rails generate devise:install rails generate devise User rails db:migrate ``` c. Rollen toewijzen (bijvoorbeeld via een kolom 'role' in User model) ```bash rails generate migration AddRoleToUsers role:string rails db:migrate ``` d. User model aanpassen voor rollen ```ruby class User < ApplicationRecord # Devise modules devise :database_authenticatable, :registerable, :recoverable, :rememberable, :validatable # Rollen beheren enum role: { klant: 0, beheerder: 1 } # Validatie validates :role, presence: true # Beveiliging: wachtwoord hashing en authenticatie worden door Devise afgehandeld end ``` e. Authenticatie en autorisatie in controllers ```ruby class ApplicationController < ActionController::Base include Pundit # Bescherming tegen CSRF protect_from_forgery with: :exception # Gebruiker moet ingelogd zijn before_action :authenticate_user! # Fouten bij autorisatie afhandelen rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized private def user_not_authorized flash[:alert] = "Je hebt geen toestemming om deze actie uit te voeren." redirect_to(request.referrer || root_path) end end ``` f. Pundit policies voor autorisatie ```ruby class ApplicationPolicy attr_reader :user, :record def initialize(user, record) @user = user @record = record end def index? false end def show? scope.where(id: record.id).exists? end def create? false end def new? create? end def update? false end def edit? update? end def destroy? false end class Scope attr_reader :user, :scope def initialize(user, scope) @user = user @scope = scope end def resolve scope.all end end end # Voor een voorbeeldmodel: Order class OrderPolicy < ApplicationPolicy def show? user.beheerder? || record.user_id == user.id end def create? user.klant? end def update? user.beheerder? end def destroy? user.beheerder? end end # Voor beheerder-only toegang tot dashboard class DashboardPolicy < ApplicationPolicy def access? user.beheerder? end end ``` g. Beveiliging tegen veelvoorkomende kwetsbaarheden: - **Wachtwoordbeveiliging:** Devise gebruikt bcrypt voor hashing. - **Inputvalidatie:** Validaties in models voorkomen onjuiste data. - **CSRF-bescherming:** Rails beschermt standaard tegen CSRF-aanvallen. - **Session-beveiliging:** Secure cookies en sessiebeheer via Rails. - **Toegangscontrole:** Pundit zorgt dat gebruikers alleen toegang krijgen tot hun eigen data of beheerdersfuncties. - **HTTPS:** Zorg dat de applicatie via HTTPS draait (instellen op serverniveau). Door bovenstaande opzet te gebruiken, implementeer je een veilige en best practice gebruikersauthenticatie en autorisatie systeem voor je online winkel. Heeft u verdere vragen of specifieke codevoorbeelden?

Zeker, hier is een uitgebreide implementatie van veilige authenticatie en autorisatie in Ruby (Rails) voor een online winkel: --- ### **Authenticatiemethoden** 1. **E-mail/wachtwoord** (met beveiligde hashing) 2. **Sessiegebaseerde authenticatie** (secure cookies) 3. **Multi-factor authenticatie** (optioneel voor admins) --- ### **Autorisatie & Gebruikersrollen** ```ruby # app/models/user.rb class User < ApplicationRecord enum role: { customer: 0, admin: 1, moderator: 2 } has_secure_password validates :password, length: { minimum: 12 }, allow_nil: true validates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP } end ``` --- ### **Beveiligde Authenticatie Implementatie** ```ruby # app/controllers/sessions_controller.rb class SessionsController < ApplicationController def create user = User.find_by(email: params[:email].downcase) if user&.authenticate(params[:password]) if user.confirmed? session[:user_id] = user.id session[:role] = user.role redirect_to dashboard_path, notice: "Succesvol ingelogd" else redirect_to login_path, alert: "Bevestig eerst uw e-mailadres" end else flash.now[:alert] = "Ongeldige inloggegevens" render :new end end def destroy reset_session redirect_to root_path, notice: "Uitgelogd" end end ``` --- ### **Autorisatie Middleware** ```ruby # app/controllers/application_controller.rb class ApplicationController < ActionController::Base before_action :require_login before_action :authorize_user! private def require_login redirect_to login_path unless current_user end def authorize_user! return if current_user&.admin? case action_name when 'destroy', 'update', 'create' redirect_to root_path, alert: "Toegang geweigerd" unless current_user&.admin? end end def current_user @current_user ||= User.find_by(id: session[:user_id]) end end ``` --- ### **Beheerdersdashboard Beveiliging** ```ruby # app/controllers/admin_controller.rb class AdminController < ApplicationController before_action :require_admin private def require_admin unless current_user&.admin? redirect_to root_path, alert: "Alleen beheerders hebben toegang tot deze pagina" end end end ``` --- ### **Beveiligingsmaatregelen tegen veelvoorkomende kwetsbaarheden** 1. **Tegen SQL Injection:** ```ruby # Veilig - gebruik altijd query parameters Product.where("name LIKE ?", "%#{sanitize_sql_like(params[:search])}%") ``` 2. **Tegen XSS:** ```erb <!-- Auto-escaping in Rails views --> <%= content_tag :div, user_input_content %> ``` 3. **Tegen CSRF:** ```ruby # application_controller.rb protect_from_forgery with: :exception ``` 4. **Wachtwoordbeveiliging:** ```ruby # Gemfile gem 'bcrypt', '~> 3.1.7' ``` 5. **Sessiebeveiliging:** ```ruby # config/initializers/session_store.rb Rails.application.config.session_store :cookie_store, secure: Rails.env.production?, httponly: true, same_site: :strict ``` 6. **Rate Limiting:** ```ruby # app/controllers/application_controller.rb class ApplicationController < ActionController::Base before_action :check_rate_limit private def check_rate_limit if Rails.cache.read("login_attempts:#{request.remote_ip}").to_i > 5 render plain: "Te veel pogingen", status: 429 end end end ``` --- ### **Aanvullende Beveiliging** 1. **E-mailbevestiging:** ```ruby # app/models/user.rb after_create :send_confirmation_email def send_confirmation_email ConfirmationMailer.confirmation_email(self).deliver_later end ``` 2. **Wachtwoordreset:** ```ruby # Secure token generation def generate_password_reset_token self.reset_password_token = SecureRandom.urlsafe_base64 self.reset_password_sent_at = Time.current end ``` 3. **Logging en Monitoring:** ```ruby # config/application.rb config.filter_parameters += [:password, :password_confirmation] ``` --- ### **Belangrijkste Beveiligingsprincipes** 1. **Principle of Least Privilege**: Gebruikers krijgen alleen de rechten die ze nodig hebben 2. **Defense in Depth**: Meerdere beveiligingslagen 3. **Regular Updates**: Houd dependencies up-to-date 4. **Security Headers**: Implementeer CSP, HSTS headers 5. **Regular Audits**: Voer security scans uit Deze implementatie voldoet aan OWASP-richtlijnen en bevat bescherming tegen de meest voorkomende webkwetsbaarheden. Voor productiegebruik raad ik aan aanvullende security audits uit te voeren en een WAF (Web Application Firewall) te overwegen.