- SQL Server Reference Guide
- Introduction
- SQL Server Reference Guide Overview
- Table of Contents
- Microsoft SQL Server Defined
- SQL Server Editions
- SQL Server Access
- Informit Articles and Sample Chapters
- Online Resources
- Microsoft SQL Server Features
- SQL Server Books Online
- Clustering Services
- Data Transformation Services (DTS) Overview
- Replication Services
- Database Mirroring
- Natural Language Processing (NLP)
- Analysis Services
- Microsot SQL Server Reporting Services
- XML Overview
- Notification Services for the DBA
- Full-Text Search
- SQL Server 2005 - Service Broker
- Using SQL Server as a Web Service
- SQL Server Encryption Options Overview
- SQL Server 2008 Overview
- SQL Server 2008 R2 Overview
- SQL Azure
- The Utility Control Point and Data Application Component, Part 1
- The Utility Control Point and Data Application Component, Part 2
- Microsoft SQL Server Administration
- The DBA Survival Guide: The 10 Minute SQL Server Overview
- Preparing (or Tuning) a Windows System for SQL Server, Part 1
- Preparing (or Tuning) a Windows System for SQL Server, Part 2
- Installing SQL Server
- Upgrading SQL Server
- SQL Server 2000 Management Tools
- SQL Server 2005 Management Tools
- SQL Server 2008 Management Tools
- SQL Azure Tools
- Automating Tasks with SQL Server Agent
- Run Operating System Commands in SQL Agent using PowerShell
- Automating Tasks Without SQL Server Agent
- Storage – SQL Server I/O
- Service Packs, Hotfixes and Cumulative Upgrades
- Tracking SQL Server Information with Error and Event Logs
- Change Management
- SQL Server Metadata, Part One
- SQL Server Meta-Data, Part Two
- Monitoring - SQL Server 2005 Dynamic Views and Functions
- Monitoring - Performance Monitor
- Unattended Performance Monitoring for SQL Server
- Monitoring - User-Defined Performance Counters
- Monitoring: SQL Server Activity Monitor
- SQL Server Instances
- DBCC Commands
- SQL Server and Mail
- Database Maintenance Checklist
- The Maintenance Wizard: SQL Server 2000 and Earlier
- The Maintenance Wizard: SQL Server 2005 (SP2) and Later
- The Web Assistant Wizard
- Creating Web Pages from SQL Server
- SQL Server Security
- Securing the SQL Server Platform, Part 1
- Securing the SQL Server Platform, Part 2
- SQL Server Security: Users and other Principals
- SQL Server Security – Roles
- SQL Server Security: Objects (Securables)
- Security: Using the Command Line
- SQL Server Security - Encrypting Connections
- SQL Server Security: Encrypting Data
- SQL Server Security Audit
- High Availability - SQL Server Clustering
- SQL Server Configuration, Part 1
- SQL Server Configuration, Part 2
- Database Configuration Options
- 32- vs 64-bit Computing for SQL Server
- SQL Server and Memory
- Performance Tuning: Introduction to Indexes
- Statistical Indexes
- Backup and Recovery
- Backup and Recovery Examples, Part One
- Backup and Recovery Examples, Part Two: Transferring Databases to Another System (Even Without Backups)
- SQL Profiler - Reverse Engineering An Application
- SQL Trace
- SQL Server Alerts
- Files and Filegroups
- Partitioning
- Full-Text Indexes
- Read-Only Data
- SQL Server Locks
- Monitoring Locking and Deadlocking
- Controlling Locks in SQL Server
- SQL Server Policy-Based Management, Part One
- SQL Server Policy-Based Management, Part Two
- SQL Server Policy-Based Management, Part Three
- Microsoft SQL Server Programming
- An Outline for Development
- Database
- Database Services
- Database Objects: Databases
- Database Objects: Tables
- Database Objects: Table Relationships
- Database Objects: Keys
- Database Objects: Constraints
- Database Objects: Data Types
- Database Objects: Views
- Database Objects: Stored Procedures
- Database Objects: Indexes
- Database Objects: User Defined Functions
- Database Objects: Triggers
- Database Design: Requirements, Entities, and Attributes
- Business Process Model Notation (BPMN) and the Data Professional
- Business Questions for Database Design, Part One
- Business Questions for Database Design, Part Two
- Database Design: Finalizing Requirements and Defining Relationships
- Database Design: Creating an Entity Relationship Diagram
- Database Design: The Logical ERD
- Database Design: Adjusting The Model
- Database Design: Normalizing the Model
- Creating The Physical Model
- Database Design: Changing Attributes to Columns
- Database Design: Creating The Physical Database
- Database Design Example: Curriculum Vitae
- NULLs
- The SQL Server Sample Databases
- The SQL Server Sample Databases: pubs
- The SQL Server Sample Databases: NorthWind
- The SQL Server Sample Databases: AdventureWorks
- The SQL Server Sample Databases: Adventureworks Derivatives
- UniversalDB: The Demo and Testing Database, Part 1
- UniversalDB: The Demo and Testing Database, Part 2
- UniversalDB: The Demo and Testing Database, Part 3
- UniversalDB: The Demo and Testing Database, Part 4
- Getting Started with Transact-SQL
- Transact-SQL: Data Definition Language (DDL) Basics
- Transact-SQL: Limiting Results
- Transact-SQL: More Operators
- Transact-SQL: Ordering and Aggregating Data
- Transact-SQL: Subqueries
- Transact-SQL: Joins
- Transact-SQL: Complex Joins - Building a View with Multiple JOINs
- Transact-SQL: Inserts, Updates, and Deletes
- An Introduction to the CLR in SQL Server 2005
- Design Elements Part 1: Programming Flow Overview, Code Format and Commenting your Code
- Design Elements Part 2: Controlling SQL's Scope
- Design Elements Part 3: Error Handling
- Design Elements Part 4: Variables
- Design Elements Part 5: Where Does The Code Live?
- Design Elements Part 6: Math Operators and Functions
- Design Elements Part 7: Statistical Functions
- Design Elements Part 8: Summarization Statistical Algorithms
- Design Elements Part 9:Representing Data with Statistical Algorithms
- Design Elements Part 10: Interpreting the Data—Regression
- Design Elements Part 11: String Manipulation
- Design Elements Part 12: Loops
- Design Elements Part 13: Recursion
- Design Elements Part 14: Arrays
- Design Elements Part 15: Event-Driven Programming Vs. Scheduled Processes
- Design Elements Part 16: Event-Driven Programming
- Design Elements Part 17: Program Flow
- Forming Queries Part 1: Design
- Forming Queries Part 2: Query Basics
- Forming Queries Part 3: Query Optimization
- Forming Queries Part 4: SET Options
- Forming Queries Part 5: Table Optimization Hints
- Using SQL Server Templates
- Transact-SQL Unit Testing
- Index Tuning Wizard
- Unicode and SQL Server
- SQL Server Development Tools
- The SQL Server Transact-SQL Debugger
- The Transact-SQL Debugger, Part 2
- Basic Troubleshooting for Transact-SQL Code
- An Introduction to Spatial Data in SQL Server 2008
- Performance Tuning
- Performance Tuning SQL Server: Tools and Processes
- Performance Tuning SQL Server: Tools Overview
- Creating a Performance Tuning Audit - Defining Components
- Creating a Performance Tuning Audit - Evaluation Part One
- Creating a Performance Tuning Audit - Evaluation Part Two
- Creating a Performance Tuning Audit - Interpretation
- Creating a Performance Tuning Audit - Developing an Action Plan
- Understanding SQL Server Query Plans
- Performance Tuning: Implementing Indexes
- Performance Monitoring Tools: Windows 2008 (and Higher) Server Utilities, Part 1
- Performance Monitoring Tools: Windows 2008 (and Higher) Server Utilities, Part 2
- Performance Monitoring Tools: Windows System Monitor
- Performance Monitoring Tools: Logging with System Monitor
- Performance Monitoring Tools: User Defined Counters
- General Transact-SQL (T-SQL) Performance Tuning, Part 1
- General Transact-SQL (T-SQL) Performance Tuning, Part 2
- General Transact-SQL (T-SQL) Performance Tuning, Part 3
- Performance Monitoring Tools: An Introduction to SQL Profiler
- Performance Tuning: Introduction to Indexes
- Performance Monitoring Tools: SQL Server 2000 Index Tuning Wizard
- Performance Monitoring Tools: SQL Server 2005 Database Tuning Advisor
- Performance Monitoring Tools: SQL Server Management Studio Reports
- Performance Monitoring Tools: SQL Server 2008 Activity Monitor
- The SQL Server 2008 Management Data Warehouse and Data Collector
- Performance Monitoring Tools: Evaluating Wait States with PowerShell and Excel
- Practical Applications
- Choosing the Back End
- The DBA's Toolbox, Part 1
- The DBA's Toolbox, Part 2
- Scripting Solutions for SQL Server
- Building a SQL Server Lab
- Using Graphics Files with SQL Server
- Enterprise Resource Planning
- Customer Relationship Management (CRM)
- Building a Reporting Data Server
- Building a Database Documenter, Part 1
- Building a Database Documenter, Part 2
- Data Management Objects
- Data Management Objects: The Server Object
- Data Management Objects: Server Object Methods
- Data Management Objects: Collections and the Database Object
- Data Management Objects: Database Information
- Data Management Objects: Database Control
- Data Management Objects: Database Maintenance
- Data Management Objects: Logging the Process
- Data Management Objects: Running SQL Statements
- Data Management Objects: Multiple Row Returns
- Data Management Objects: Other Database Objects
- Data Management Objects: Security
- Data Management Objects: Scripting
- Powershell and SQL Server - Overview
- PowerShell and SQL Server - Objects and Providers
- Powershell and SQL Server - A Script Framework
- Powershell and SQL Server - Logging the Process
- Powershell and SQL Server - Reading a Control File
- Powershell and SQL Server - SQL Server Access
- Powershell and SQL Server - Web Pages from a SQL Query
- Powershell and SQL Server - Scrubbing the Event Logs
- SQL Server 2008 PowerShell Provider
- SQL Server I/O: Importing and Exporting Data
- SQL Server I/O: XML in Database Terms
- SQL Server I/O: Creating XML Output
- SQL Server I/O: Reading XML Documents
- SQL Server I/O: Using XML Control Mechanisms
- SQL Server I/O: Creating Hierarchies
- SQL Server I/O: Using HTTP with SQL Server XML
- SQL Server I/O: Using HTTP with SQL Server XML Templates
- SQL Server I/O: Remote Queries
- SQL Server I/O: Working with Text Files
- Using Microsoft SQL Server on Handheld Devices
- Front-Ends 101: Microsoft Access
- Comparing Two SQL Server Databases
- English Query - Part 1
- English Query - Part 2
- English Query - Part 3
- English Query - Part 4
- English Query - Part 5
- RSS Feeds from SQL Server
- Using SQL Server Agent to Monitor Backups
- Reporting Services - Creating a Maintenance Report
- SQL Server Chargeback Strategies, Part 1
- SQL Server Chargeback Strategies, Part 2
- SQL Server Replication Example
- Creating a Master Agent and Alert Server
- The SQL Server Central Management System: Definition
- The SQL Server Central Management System: Base Tables
- The SQL Server Central Management System: Execution of Server Information (Part 1)
- The SQL Server Central Management System: Execution of Server Information (Part 2)
- The SQL Server Central Management System: Collecting Performance Metrics
- The SQL Server Central Management System: Centralizing Agent Jobs, Events and Scripts
- The SQL Server Central Management System: Reporting the Data and Project Summary
- Time Tracking for SQL Server Operations
- Migrating Departmental Data Stores to SQL Server
- Migrating Departmental Data Stores to SQL Server: Model the System
- Migrating Departmental Data Stores to SQL Server: Model the System, Continued
- Migrating Departmental Data Stores to SQL Server: Decide on the Destination
- Migrating Departmental Data Stores to SQL Server: Design the ETL
- Migrating Departmental Data Stores to SQL Server: Design the ETL, Continued
- Migrating Departmental Data Stores to SQL Server: Attach the Front End, Test, and Monitor
- Tracking SQL Server Timed Events, Part 1
- Tracking SQL Server Timed Events, Part 2
- Patterns and Practices for the Data Professional
- Managing Vendor Databases
- Consolidation Options
- Connecting to a SQL Azure Database from Microsoft Access
- SharePoint 2007 and SQL Server, Part One
- SharePoint 2007 and SQL Server, Part Two
- SharePoint 2007 and SQL Server, Part Three
- Querying Multiple Data Sources from a Single Location (Distributed Queries)
- Importing and Exporting Data for SQL Azure
- Working on Distributed Teams
- Professional Development
- Becoming a DBA
- Certification
- DBA Levels
- Becoming a Data Professional
- SQL Server Professional Development Plan, Part 1
- SQL Server Professional Development Plan, Part 2
- SQL Server Professional Development Plan, Part 3
- Evaluating Technical Options
- System Sizing
- Creating a Disaster Recovery Plan
- Anatomy of a Disaster (Response Plan)
- Database Troubleshooting
- Conducting an Effective Code Review
- Developing an Exit Strategy
- Data Retention Strategy
- Keeping Your DBA/Developer Job in Troubled Times
- The SQL Server Runbook
- Creating and Maintaining a SQL Server Configuration History, Part 1
- Creating and Maintaining a SQL Server Configuration History, Part 2
- Creating an Application Profile, Part 1
- Creating an Application Profile, Part 2
- How to Attend a Technical Conference
- Tips for Maximizing Your IT Budget This Year
- The Importance of Blue-Sky Planning
- Application Architecture Assessments
- Transact-SQL Code Reviews, Part One
- Transact-SQL Code Reviews, Part Two
- Cloud Computing (Distributed Computing) Paradigms
- NoSQL for the SQL Server Professional, Part One
- NoSQL for the SQL Server Professional, Part Two
- Object-Role Modeling (ORM) for the Database Professional
- Business Intelligence
- BI Explained
- Developing a Data Dictionary
- BI Security
- Gathering BI Requirements
- Source System Extracts and Transforms
- ETL Mechanisms
- Business Intelligence Landscapes
- Business Intelligence Layouts and the Build or Buy Decision
- A Single Version of the Truth
- The Operational Data Store (ODS)
- Data Marts – Combining and Transforming Data
- Designing Data Elements
- The Enterprise Data Warehouse — Aggregations and the Star Schema
- On-Line Analytical Processing (OLAP)
- Data Mining
- Key Performance Indicators
- BI Presentation - Client Tools
- BI Presentation - Portals
- Implementing ETL - Introduction to SQL Server 2005 Integration Services
- Building a Business Intelligence Solution, Part 1
- Building a Business Intelligence Solution, Part 2
- Building a Business Intelligence Solution, Part 3
- Tips and Troubleshooting
- SQL Server and Microsoft Excel Integration
- Tips for the SQL Server Tools: SQL Server 2000
- Tips for the SQL Server Tools – SQL Server 2005
- Transaction Log Troubles
- SQL Server Connection Problems
- Orphaned Database Users
- Additional Resources
- Tools and Downloads
- Utilities (Free)
- Tool Review (Free): DBDesignerFork
- Aqua Data Studio
- Microsoft SQL Server Best Practices Analyzer
- Utilities (Cost)
- Quest Software's TOAD for SQL Server
- Quest Software's Spotlight on SQL Server
- SQL Server on Microsoft's Virtual PC
- Red Gate SQL Bundle
- Microsoft's Visio for Database Folks
- Quest Capacity Manager
- SQL Server Help
- Visual Studio Team Edition for Database Professionals
- Microsoft Assessment and Planning Solution Accelerator
- Aggregating Server Data from the MAPS Tool
The best security method for a database system is to limit its exposure, removing it completely from the network. Of course, for most of the applications you need to run this isn't an option. Most database server systems are connected directly to the corporate network, if not the network at large. This isn't the most secure operation available, of course. A better approach is to connect the database server only to the local network, and even better if you limit its connection to a middle tier. Although this isn't perfect security, it allows a greater level of control over connections.
Sometimes that isn't possible. You simply have to connect the server to the full campus network, or even worse, directly to the Internet. Some applications, especially those distributed applications for the sales force or in a global environment, require this kind of access.
Although SQL Server is quite secure (especially SQL Server 2005) when you follow the instructions from Microsoft and those I've outlined in this guide, there are times when you need to take the security level higher, especially if you have these more open connections.
In this tutorial I'll explain one of the uses for encryption — which means to "hide" or "bury" a secret. Although SQL Server can encrypt data, in this case I'll explain how to encrypt the communications between the server and the client machines across the network. I'll use SQL Server 2005 for this demonstration, which actually has better security than SQL Server 2000.
Keep in mind that you should really need to encrypt data or connections to go to all this trouble. Anything you add to a connection makes it slightly slower, and if you lose or corrupt the encryption mechanism (keys or certificates, or both), you're pretty much out of luck. There's no magic key, or backdoor, that will get your data back or allow you to transfer encrypted data without it. This brings us up to a very important warning I need to give to you:
Here's the process we're going to follow, on that test server:
- Create and export a certificate
- Set up SQL Server to use the certificate
- Import the certificate on the client system
- Set up encrypted connections between the two systems
Create and Export a Certificate
A certificate is actually just a long string of numbers used to scramble data. It's actually a bit more complicated than that, because it includes information like the source of the certificate, its level, and how long it is valid for.
Normally you get a certificate from a Certificate Authority, or CA. Several commercial Certificate Authorities will sell you a certificate. But why use a third party at all? Why not just generate your own certificate?
In fact, we will generate and use our own certificate, but that's normally a bad idea. Let's take a look at this in more concrete terms. Let's assume that someone shows up at your house and asks to come in and take some personal data that belongs to you. You don't know this person, so you might hesitate to do that. He tells you, "but I know your address, and I know the secret name your family uses for your dog." Even though this person knew how to find you and knows some information you think is private, you're still probably not going to let him in. But In fact, that's what you do every time someone uses a simple password to access your application. All they need is the TCP/IP address of your server and a password and they are free to access your data.
But assume that your mother calls you one day and says "I'm sending a man named Jon over to your house to pick up some information I need from your bank." Someone shows up at your door (knows your address), tells you his name is Jon (knows a secret between you and your mother), and you let him in to get the paperwork. The difference between the first encounter and the second is that this time someone you trusted told you it was alright to let him in. That's the same purpose as purchasing a certificate from a CA. Each party is known by a third and that authority is trusted by both.
We're going to do something like that on SQL Server. Actually, the SQL Server Native Client in 2005 always encrypts logins — it's just part of the protocol. That's why it's inherently more secure than SQL Server 2000. What we're working on is the data encryption once the connection is made. It's sort of like giving that person that shows up at the door some personal data from your house, but it's written in a strong code in case he loses it on the train. That way no one else can read it. The certificate is the "key to the code" that lets the person (the server and client, in this case) read the data.
First we're going to check and export a certificate, so that we can use it both in SQL Server and on the remote connections. Click on the Start button and type MMC and press Return.
Then click File | Add/Remove Snap-in..., and click the Add button that shows up on that panel. Then find and click Certificates from the menu, and then the Add button again.
You'll be asked a question as to which kind of Certificates you want to manage. Select Computer Account and then click Next, and then select the Local Computer when asked. Now you're dropped back in the Snap-in panel again.
Now double-click the Certificates (Local Computer) | Personal | Certificates icons in the left side of the MMC Snap-in.
On my Windows 2003 Server system, a certificate has automatically been generated for me. It only lasts a day, but that's good enough for this demonstration.
There are some other caveats here. SQL Server requires certain settings for a certificate, so you'll need to read further in SQL Server Books Online about the requirements for the certificate options. Look up "Encryption" in Books Online for a complete rundown of what the requirements are.
Next, right-click the name of the certificate and then select All Tasks | Export... from the menu that appears. A wizard will guide you through exporting the certificate to a file. When you're asked about the file format, select the first option. Name the certificate and keep that file location handy. You'll want to delete that file when you're through with this exercise. When the wizard finishes you can close the panel and the MMC. If you want to revisit this process, you can save the settings to open them up again; just note what you call it and where you save that file. Double-clicking that file again will open up the Certificates Snap-in for you.
Set up SQL Server to use the certificate
Now we need to tell the server to user encrypted communications. Still on the test server (you ARE doing this on a TEST server, right?) open the SQL Server Configuration Manager from the Windows Start button | All Programs item. It's in the Configuration Tools submenu.
We're going to make two changes here. Double-click the SQL Server 2005 Network Configuration item, and then right-click the Protocols for (your instance name here). Click Properties from the menu that pops up. Once you do that, you'll see a panel similar to this one:
In the Flags panel, set the Force Encryption setting to Yes. After you restart the service, no one will be able to connect unless they use the certificate you exported. Now let's click the Certificate tab, and set that to the certificate name we exported earlier. Pull down the certificate name and then click the OK button.
You'll get a message that you have to stop and start the service for everything to take effect. You can do that now, by using the same tool you're already in. Just click the SQL Server 2005 Services item on the left and use the Restart icon in the button bar when you're on the SQL Server object.
Import the certificate on the client system
You'll need to copy the certificate we created earlier to the workstation you're going to connect from. Once again, click on the Start button, type MMC, and follow the same process we did earlier on the server – with one exception.
This time, navigate to exactly the same location in the Certificates MMC that we did on the server earlier, but this time, you may not have any certificates in the Personal area. Right-click the word Certificates underneath the Personal item, and select Import from the menu that appears. Just follow the defaults here, and point at the file you exported from the server.
Once you're done, you can close the MMC, once again saving it if you want to repeat the process.
Set up encrypted connections between the two systems
Now we have the certificate on the server, and the server is set to only listen to encrypted connections. We also have the same certificate installed on the workstation. There's only one step left: we need to tell the client application that we want to encrypt the transmissions.
We can do that for the applications that use the SQL Native Client communications by opening the SQL Server Configuration Manager tool on the client workstation.
In the Configuration Manager tool, right-click the SQL Native Client Configuration object and select Properties from the menu that appears. In the Flags panel change the Force Protocol setting to Yes. Now anything that uses the SQL Server Native Client will use encryption — for data. There are also settings in code that your developers can use to set an encryption call, and the SQL Server Management Studio tool also has an Options button that allows you to encrypt the connection.
Finally we need to put everything back the way it was. If you're using a virtual machine, as I am, you can just reset the image back to what it was when you started. If you're using a physical machine, you can just return to the Configuration Manager and change the settings for the connections back to allow unencrypted connections. Do the same on the workstation client component and you're back to normal. Also, remember to delete the certificate file from all the locations where you have it!
Informit Articles and Sample Chapters
As always, there are some fantastic security references right here on InformIT. You can read one of them on Secure Sockets Layer (SSL) here.
Online Resources
Those "extra" settings I told you about for certificates that SQL Server 2005 requires are described here.
There's more about the various settings I described between the server and the client here.