MSSQL Hardening

SQL Zonder Slaaptekort

In netwerkbeveiliging wint structuur van improvisatie: duidelijke paden, minder privileges en expliciete trust-grenzen.

Bij MSSQL Hardening gaat het om strikte invoergrenzen, parameterized queries en reviews die query-risico vroeg stoppen.

Zo beperk je niet alleen de kans op incidenten, maar vooral ook de omvang en duur als er iets misgaat.

Directe maatregelen (15 minuten)

• Start met MFA, least privilege en tiering voor beheeraccounts.
• Voer segmentatie en expliciete firewallregels door op kritieke paden.
• Borg logging, detectie en hersteltests als structurele operatie.

Waarom dit telt

De kern van MSSQL Hardening is risicoreductie in de praktijk. Technische context ondersteunt de maatregelkeuze, maar implementatie en borging staan centraal.

Installatie & configuratie

Een SQL Server-installatie begint met keuzes die de rest van het beveiligingsverhaal bepalen. De meeste organisaties klikken door de wizard heen alsof het een EULA is — niemand leest het, iedereen klikt “Next”.

Minimale installatie

Installeer alleen de features die daadwerkelijk nodig zijn. De standaard “selecteer alles” aanpak levert een aanvalsoppervlak op dat groter is dan nodig:

Features die je waarschijnlijk NIET nodig hebt:
- SQL Server Replication (tenzij je het echt gebruikt)
- Full-Text and Semantic Extractions for Search
- Analysis Services
- Reporting Services
- Integration Services
- Machine Learning Services (R/Python)
- PolyBase Query Service for External Data
- Data Quality Services

Elke feature die geinstalleerd is maar niet gebruikt wordt, is een potentieel aanvalsoppervlak dat gepatcht moet worden maar door niemand gemonitord wordt.

Named instances en poorten

Gebruik named instances in plaats van de default instance, en wijzig de standaard TCP-poort:

-- Controleer de huidige poortconfiguratie
SELECT local_tcp_port
FROM sys.dm_exec_connections
WHERE session_id = @@SPID;

# TCP-poort wijzigen via SQL Server Configuration Manager
# Of via registry (pas op: dit vereist een restart)
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Microsoft SQL Server\MSSQL16.MSSQLSERVER\MSSQLServer\SuperSocketNetLib\Tcp\IPAll" `
    -Name "TcpPort" -Value "41433"

# SQL Browser service uitschakelen als je geen named instances discovert
Set-Service -Name "SQLBrowser" -StartupType Disabled
Stop-Service -Name "SQLBrowser"

Standaardpoort 1433 is het eerste dat elke scanner controleert. Het wijzigen ervan is geen beveiligingsmaatregel op zich — security through obscurity is geen security — maar het filtert wel het achtergrondlawaai van geautomatiseerde scanners.

Patch management

# Controleer de huidige versie en patch level
SELECT @@VERSION;
SELECT SERVERPROPERTY('ProductVersion') AS Version,
       SERVERPROPERTY('ProductLevel') AS PatchLevel,
       SERVERPROPERTY('Edition') AS Edition;

Houd SQL Server altijd up-to-date met de laatste Cumulative Updates. Microsoft brengt maandelijks CU’s uit. Veel organisaties patchen hun Windows-servers braaf, maar vergeten SQL Server — alsof de database-engine op magische wijze immuun is voor kwetsbaarheden.

Authenticatie

Windows Authentication vs Mixed Mode

SQL Server biedt twee authenticatie-modi:

Windows Authentication is altijd de voorkeur: - Kerberos-authenticatie met ticket-gebaseerde tokens - Geen wachtwoorden over het netwerk - Centrale wachtwoordpolicies via Active Directory - Account lockout en audit via bestaande AD-infrastructuur

Mixed Mode is soms nodig voor legacy-applicaties die SQL-logins verwachten. Documenteer waarom Mixed Mode nodig is en beperk het aantal SQL-logins tot het absolute minimum.

Het sa-account

Het sa-account is de heilige graal voor elke aanvaller. Standaard aanwezig, altijd sysadmin, en bij veel organisaties geconfigureerd met het wachtwoord “sa”, “P@ssw0rd”, of gewoon leeg.

-- Stap 1: Hernoem het sa-account
ALTER LOGIN sa WITH NAME = [sql_disabled_admin];

-- Stap 2: Stel een sterk wachtwoord in (minimaal 30 tekens)
ALTER LOGIN [sql_disabled_admin] WITH PASSWORD = 'HIER-EEN-LANG-RANDOM-WACHTWOORD-VAN-30+-TEKENS!';

-- Stap 3: Schakel het account uit
ALTER LOGIN [sql_disabled_admin] DISABLE;

-- Verifieer dat sa uitgeschakeld is
SELECT name, is_disabled, is_policy_checked, is_expiration_checked
FROM sys.sql_logins
WHERE principal_id = 1;

Password policy enforcement

Voor SQL-logins die wel nodig zijn, forceer wachtwoordbeleid:

-- Maak een login met password policy enforcement
CREATE LOGIN [app_service]
WITH PASSWORD = 'SterkWachtwoord!ComplexGenoeg123',
    CHECK_POLICY = ON,
    CHECK_EXPIRATION = ON;

-- Controleer bestaande logins op policy-status
SELECT name,
       is_policy_checked,
       is_expiration_checked,
       create_date,
       modify_date
FROM sys.sql_logins
WHERE is_policy_checked = 0 OR is_expiration_checked = 0;

CHECK_POLICY = ON dwingt de Windows-wachtwoordpolicy af op SQL-logins. CHECK_EXPIRATION = ON zorgt ervoor dat wachtwoorden verlopen. Beide staan standaard aan voor nieuwe logins, maar worden regelmatig uitgeschakeld “omdat de applicatie anders niet meer kan verbinden.”

Autorisatie & least privilege

Service accounts

De SQL Server-service zelf draait onder een account. Gebruik hiervoor: - Een Group Managed Service Account (gMSA) — automatische wachtwoord-rotatie, geen menselijke interventie - Of een dedicated domain service account met minimale rechten - Nooit: LocalSystem, NT AUTHORITY\SYSTEM, of een domain admin-account

Database-level vs server-level roles

Least privilege in de praktijk

-- Stap 1: Maak een server login
CREATE LOGIN [app_reader] WITH PASSWORD = 'SterkWachtwoord!456';

-- Stap 2: Maak een database user
USE [ProductieDB];
CREATE USER [app_reader] FOR LOGIN [app_reader];

-- Stap 3: Ken ALLEEN de minimale rechten toe
-- NIET: ALTER ROLE db_datareader ADD MEMBER [app_reader];
-- WEL: granulaire permissies op schema-niveau
GRANT SELECT ON SCHEMA::dbo TO [app_reader];

-- Of nog specifieker: alleen bepaalde tabellen
GRANT SELECT ON dbo.Products TO [app_reader];
GRANT SELECT ON dbo.Categories TO [app_reader];

-- Expliciet weigeren wat niet mag
DENY SELECT ON dbo.AuditLog TO [app_reader];
DENY SELECT ON dbo.UserCredentials TO [app_reader];

-- Verifieer effectieve permissies
EXECUTE AS USER = 'app_reader';
SELECT * FROM fn_my_permissions(NULL, 'DATABASE');
REVERT;

GRANT, DENY, REVOKE

De volgorde van prioriteit: DENY wint altijd van GRANT. Gebruik DENY bewust en spaarzaam:

-- REVOKE verwijdert een eerder toegekende permissie
REVOKE EXECUTE ON dbo.sp_GetSensitiveData FROM [app_user];

-- DENY blokkeert expliciet, zelfs als een andere rol GRANT heeft
DENY VIEW DEFINITION ON SCHEMA::dbo TO [app_user];

Gevaarlijke features uitschakelen

Dit is waar de meeste SQL Server-installaties falen. Features die “voor het gemak” aanstaan en die een aanvaller directe code-executie op het besturingssysteem geven.

xp_cmdshell

De beroemdste. Voert willekeurige OS-commando’s uit vanuit SQL Server. Er is geen legitieme reden om dit in productie aan te hebben staan.

-- Controleer de huidige status
EXEC sp_configure 'show advanced options', 1;
RECONFIGURE;
EXEC sp_configure 'xp_cmdshell';

-- Uitschakelen
EXEC sp_configure 'xp_cmdshell', 0;
RECONFIGURE;

-- Verifieer
EXEC sp_configure 'xp_cmdshell';
-- run_value moet 0 zijn

OLE Automation

sp_OACreate, sp_OAMethod, en aanverwanten bieden een alternatieve route naar OS-commando-executie:

-- Uitschakelen
EXEC sp_configure 'Ole Automation Procedures', 0;
RECONFIGURE;

CLR Integration

Staat toe om .NET-assemblies te laden en uit te voeren in SQL Server. Legitiem voor complexe stored procedures, maar ook een aanvalsvector:

-- Uitschakelen als niet nodig
EXEC sp_configure 'clr enabled', 0;
RECONFIGURE;

-- Als CLR wel nodig is: beperk tot SAFE assemblies
-- en gebruik CLR strict security (SQL 2017+)
EXEC sp_configure 'clr strict security', 1;
RECONFIGURE;

Ad Hoc Distributed Queries

Maakt OPENROWSET en OPENDATASOURCE mogelijk — handig voor aanvallers om data te exfiltreren:

EXEC sp_configure 'Ad Hoc Distributed Queries', 0;
RECONFIGURE;

Database Mail

Als Database Mail nodig is, beveilig het dan:

-- Beperk wie Database Mail mag gebruiken
-- Verwijder onnodige gebruikers uit de DatabaseMailUserRole
USE msdb;
EXEC sp_droprolemember 'DatabaseMailUserRole', 'onnodige_user';

-- Controleer huidige leden
SELECT dp.name
FROM sys.database_role_members drm
JOIN sys.database_principals dp ON drm.member_principal_id = dp.principal_id
JOIN sys.database_principals dr ON drm.role_principal_id = dr.principal_id
WHERE dr.name = 'DatabaseMailUserRole';

Overzicht gevaarlijke features

Linked Servers beveiligen

Linked servers zijn een van de meest onderschatte risico’s in SQL Server-omgevingen. Ze creeren vertrouwensrelaties tussen servers die zelden worden geauditeerd.

-- Toon alle geconfigureerde linked servers
EXEC sp_linkedservers;

-- Gedetailleerde informatie over linked server logins
SELECT s.name AS LinkedServer,
       s.data_source,
       s.provider,
       ll.uses_self_credential,
       ll.remote_name
FROM sys.servers s
LEFT JOIN sys.linked_logins ll ON s.server_id = ll.server_id
WHERE s.is_linked = 1;

Best practices voor linked servers

1. Gebruik dedicated accounts — nooit sa of sysadmin-leden als remote login
2. Minimale permissies — de remote login heeft alleen de rechten nodig die de query vereist
3. Verwijder ongebruikte linked servers — als niemand weet waarom een linked server bestaat, is het waarschijnlijk niet nodig
4. Beperk RPC — schakel RPC uit op linked servers waar het niet nodig is

-- Beperk een linked server: schakel RPC uit
EXEC sp_serveroption @server = 'LINKED_SRV01', @optname = 'rpc out', @optvalue = 'false';

-- Wijzig de login mapping naar een dedicated account
EXEC sp_addlinkedsrvlogin
    @rmtsrvname = 'LINKED_SRV01',
    @useself = 'false',
    @locallogin = NULL,
    @rmtuser = 'linked_readonly',
    @rmtpassword = 'SterkWachtwoord!789';

Het gevaar van linked servers is de kettingreactie: Server A vertrouwt Server B, Server B vertrouwt Server C. Compromitteer A en je hebt een pad naar C. Linked server chains zijn een favoriete techniek bij laterale beweging in database-omgevingen.

Netwerk-isolatie

Firewall-regels

SQL Server hoort niet direct bereikbaar te zijn vanaf het internet. Punt.

# Windows Firewall: alleen specifieke subnets toestaan
New-NetFirewallRule -DisplayName "SQL Server - App Servers" `
    -Direction Inbound -Protocol TCP -LocalPort 41433 `
    -RemoteAddress "10.1.2.0/24" -Action Allow

New-NetFirewallRule -DisplayName "SQL Server - Management" `
    -Direction Inbound -Protocol TCP -LocalPort 41433 `
    -RemoteAddress "10.1.0.0/24" -Action Allow

# Blokkeer al het andere SQL-verkeer
New-NetFirewallRule -DisplayName "SQL Server - Block All Other" `
    -Direction Inbound -Protocol TCP -LocalPort 41433 `
    -Action Block

TLS/SSL afdwingen

# SQL Server Configuration Manager > SQL Server Network Configuration
# > Protocols > Properties > Flags tab
# Stel "Force Encryption" in op "Yes"

# Of via registry
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Microsoft SQL Server\MSSQL16.MSSQLSERVER\MSSQLServer\SuperSocketNetLib" `
    -Name "ForceEncryption" -Value 1

Installeer een geldig TLS-certificaat (niet het zelf-gegenereerde certificaat dat SQL Server standaard aanmaakt). Gebruik minimaal TLS 1.2:

# Schakel oudere TLS-versies uit op OS-niveau
# TLS 1.0 uitschakelen
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.0\Server" -Force
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.0\Server" `
    -Name "Enabled" -Value 0

Audit & logging

SQL Server Audit

SQL Server heeft een ingebouwd audit-framework dat granulaire logging biedt:

-- Stap 1: Maak een Server Audit aan
CREATE SERVER AUDIT [SecurityAudit]
TO FILE (
    FILEPATH = 'D:\SQLAudit\',
    MAXSIZE = 256 MB,
    MAX_ROLLOVER_FILES = 20,
    RESERVE_DISK_SPACE = OFF
)
WITH (
    QUEUE_DELAY = 1000,
    ON_FAILURE = CONTINUE
);

-- Stap 2: Schakel de audit in
ALTER SERVER AUDIT [SecurityAudit] WITH (STATE = ON);

-- Stap 3: Maak een Server Audit Specification
CREATE SERVER AUDIT SPECIFICATION [LoginAuditSpec]
FOR SERVER AUDIT [SecurityAudit]
ADD (FAILED_LOGIN_GROUP),
ADD (SUCCESSFUL_LOGIN_GROUP),
ADD (LOGIN_CHANGE_PASSWORD_GROUP),
ADD (SERVER_ROLE_MEMBER_CHANGE_GROUP),
ADD (DATABASE_ROLE_MEMBER_CHANGE_GROUP),
ADD (AUDIT_CHANGE_GROUP);

ALTER SERVER AUDIT SPECIFICATION [LoginAuditSpec] WITH (STATE = ON);

-- Stap 4: Database-level audit (per database)
USE [ProductieDB];
CREATE DATABASE AUDIT SPECIFICATION [DataAccessAudit]
FOR SERVER AUDIT [SecurityAudit]
ADD (SELECT, INSERT, UPDATE, DELETE ON SCHEMA::dbo BY public),
ADD (EXECUTE ON SCHEMA::dbo BY public);

ALTER DATABASE AUDIT SPECIFICATION [DataAccessAudit] WITH (STATE = ON);

Login auditing

Minimaal moeten failed logins gelogd worden. Bij voorkeur ook successful logins:

-- Stel login auditing in (0=geen, 1=failed, 2=success, 3=beide)
EXEC xp_instance_regwrite
    N'HKEY_LOCAL_MACHINE',
    N'Software\Microsoft\MSSQLServer\MSSQLServer',
    N'AuditLevel',
    REG_DWORD, 3;

Key events om te monitoren

Backup-beveiliging

Backups bevatten dezelfde data als de productiedatabase. Als de backup niet beveiligd is, is de data niet beveiligd.

Backup-encryptie

-- Stap 1: Maak een Database Master Key
USE master;
CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'MasterKeyWachtwoord!Complex789';

-- Stap 2: Maak een certificaat voor backup-encryptie
CREATE CERTIFICATE BackupEncryptCert
WITH SUBJECT = 'Database Backup Encryption Certificate',
    EXPIRY_DATE = '2030-12-31';

-- Stap 3: Maak een versleutelde backup
BACKUP DATABASE [ProductieDB]
TO DISK = 'D:\Backups\ProductieDB_encrypted.bak'
WITH COMPRESSION,
    ENCRYPTION (
        ALGORITHM = AES_256,
        SERVER CERTIFICATE = BackupEncryptCert
    );

-- BELANGRIJK: Backup het certificaat zelf ook!
BACKUP CERTIFICATE BackupEncryptCert
TO FILE = 'D:\CertBackup\BackupEncryptCert.cer'
WITH PRIVATE KEY (
    FILE = 'D:\CertBackup\BackupEncryptCert.pvk',
    ENCRYPTION BY PASSWORD = 'CertBackupWachtwoord!456'
);

Transparent Data Encryption (TDE)

TDE versleutelt de database-bestanden op disk, inclusief de tempdb:

-- Stap 1: Master Key (als die nog niet bestaat)
USE master;
CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'TDEMasterKey!Complex123';

-- Stap 2: Certificaat
CREATE CERTIFICATE TDECert WITH SUBJECT = 'TDE Certificate';

-- Stap 3: Database Encryption Key
USE [ProductieDB];
CREATE DATABASE ENCRYPTION KEY
WITH ALGORITHM = AES_256
ENCRYPTION BY SERVER CERTIFICATE TDECert;

-- Stap 4: Schakel TDE in
ALTER DATABASE [ProductieDB] SET ENCRYPTION ON;

-- Controleer de status
SELECT db.name, db.is_encrypted,
       dek.encryption_state, dek.key_algorithm, dek.key_length
FROM sys.databases db
LEFT JOIN sys.dm_database_encryption_keys dek
    ON db.database_id = dek.database_id;

NTFS-permissies op backup-bestanden

# Beperk toegang tot de backup-directory
$acl = Get-Acl "D:\Backups"
$acl.SetAccessRuleProtection($true, $false)

# Alleen SQL Server service account en backup-operators
$rule1 = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "NT SERVICE\MSSQLSERVER", "FullControl", "ContainerInherit,ObjectInherit", "None", "Allow")
$rule2 = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "DOMAIN\SQL-BackupOperators", "Read,Write", "ContainerInherit,ObjectInherit", "None", "Allow")

$acl.AddAccessRule($rule1)
$acl.AddAccessRule($rule2)
Set-Acl "D:\Backups" $acl

Veelvoorkomende fouten

Checklist

Er is een specifiek type DBA dat SQL Server beheert in de meeste organisaties. Je herkent hem aan de volgende kenmerken: hij heeft de installatie uitgevoerd door vijftien keer op “Next” te klikken, Mixed Mode geselecteerd “voor het geval dat”, en het sa-wachtwoord ingesteld op iets dat hij kan onthouden — wat in de praktijk betekent: “sa”, “Password1”, of de naam van het bedrijf met een uitroepteken erachter.

xp_cmdshell staat aan. Niet omdat iemand het nodig heeft, maar omdat er ooit, in 2014, een applicatie was die het nodig had. Die applicatie is drie jaar geleden gedecommissioneerd. De xp_cmdshell-configuratie is gebleven, als een soort digitale fossiel.

De linked servers zijn het mooiste. Server A vertrouwt Server B met het sa-account. Server B vertrouwt Server C met het sa-account. Server C vertrouwt Server D met — je raadt het al — het sa-account. Niemand weet waarom deze chain bestaat. Niemand durft er iets aan te veranderen. “Het werkt, en als ik er iets aan verander breekt de productie.” De DBA is niet incompetent. Hij is pragmatisch. En pragmatisch betekent in de IT: “het werkt, dus we raken het niet aan.”

Het resultaat is een omgeving waarin een enkele SQL injection in een webapplicatie niet leidt tot het uitlezen van een tabel, maar tot volledige OS-command execution via xp_cmdshell, gevolgd door laterale beweging via linked servers naar drie andere database-servers, gevolgd door credential harvesting, gevolgd door domain admin. Allemaal omdat iemand ooit “de applicatie heeft het nodig” heeft gezegd en niemand het ooit heeft geverifieerd.

Maar goed, de backups draaien. Onversleuteld, op een network share waar iedereen bij kan. Maar ze draaien.

Samenvatting

MSSQL-hardening draait om een beperkt aantal fundamentele maatregelen die samen het verschil maken tussen een database-server en een open deur naar je hele netwerk. Schakel gevaarlijke features uit (xp_cmdshell, OLE Automation, CLR), beveilig authenticatie (Windows Auth, sa uitschakelen, CHECK_POLICY), pas least privilege toe op elk niveau (server roles, database roles, schema-permissies), isoleer de server op netwerkniveau (firewall, TLS, geen directe internettoegang), audit alles (SQL Server Audit, login logging, SIEM-integratie), en beveilig je backups (encryptie, NTFS-permissies, TDE). Geen van deze maatregelen is revolutionair. Ze zijn allemaal gedocumenteerd, allemaal beschikbaar in de standaard SQL Server-installatie, en allemaal standaard uitgeschakeld of niet geconfigureerd. Het enige dat nodig is, is iemand die de tijd neemt om ze in te schakelen.

In het volgende hoofdstuk behandelen we netwerksegmentatie — de kunst van het opdelen van je netwerk in zones zodat een compromittatie in het ene segment niet automatisch betekent dat de aanvaller overal bij kan.