Windows Kernel Programming Second Edition Pavel Yosifovich

Windows Kernel Programming Second Edition Pavel
Yosifovich install download
https://ebookmeta.com/product/windows-kernel-programming-second-
edition-pavel-yosifovich/
Download more ebook from https://ebookmeta.com

We believe these products will be a great fit for you. Click
the link to download now, or visit ebookmeta.com
to discover even more!
Windows Kernel Programming 2nd Edition Pavel Yosifovich
https://ebookmeta.com/product/windows-kernel-programming-2nd-
edition-pavel-yosifovich/
Windows 10 System Programming Part 2 Pavel Yosifovich
https://ebookmeta.com/product/windows-10-system-programming-
part-2-pavel-yosifovich/
Windows registry forensics advanced digital forensic
analysis of the Windows registry Second Edition Carvey
https://ebookmeta.com/product/windows-registry-forensics-
advanced-digital-forensic-analysis-of-the-windows-registry-
second-edition-carvey/
Sorcery or Science Contesting Knowledge and Practice in
West African Sufi Texts 1st Edition Ariela Marcus-Sells
https://ebookmeta.com/product/sorcery-or-science-contesting-
knowledge-and-practice-in-west-african-sufi-texts-1st-edition-
ariela-marcus-sells/

The Routledge History of Loneliness 1st Edition Katie
Barclay
https://ebookmeta.com/product/the-routledge-history-of-
loneliness-1st-edition-katie-barclay/
A Case-Based Approach to Neck Pain: A Pocket Guide to
Pathology, Diagnosis and Management Michael Harbus
(Editor)
https://ebookmeta.com/product/a-case-based-approach-to-neck-pain-
a-pocket-guide-to-pathology-diagnosis-and-management-michael-
harbus-editor/
Red Blooded Assassin A Dark Mafia Romance King of Clubs
Book 3 1st Edition London Kingsley Margo Bond Collins
https://ebookmeta.com/product/red-blooded-assassin-a-dark-mafia-
romance-king-of-clubs-book-3-1st-edition-london-kingsley-margo-
bond-collins/
Legal Research in a Nutshell Kent C. Olson
https://ebookmeta.com/product/legal-research-in-a-nutshell-kent-
c-olson/
World of Art Turner 2nd Edition Graham Reynolds
https://ebookmeta.com/product/world-of-art-turner-2nd-edition-
graham-reynolds/

Technosignatures for Detecting Intelligent Life in Our
Universe 1st Edition Anamaria Berea
https://ebookmeta.com/product/technosignatures-for-detecting-
intelligent-life-in-our-universe-1st-edition-anamaria-berea/

Windows Kernel Programming,
Second Edition
Pavel Yosifovich
This book is for sale at
http://leanpub.com/windowskernelprogrammingsecondedition
This version was published on 2022-01-22
* * * * *
This is a Leanpub book. Leanpub empowers authors and publishers
with the Lean Publishing process. Lean Publishing is the act of
publishing an in-progress ebook using lightweight tools and many
iterations to get reader feedback, pivot until you have the right book
and build traction once you do.
* * * * *
© 2020 - 2022 Pavel Yosifovich

Table of Contents
Introduction
Who Should Read This Book
What You Should Know to Use This Book
Book Contents
Sample Code
Chapter 1: Windows Internals Overview
Processes
Virtual Memory
Page States
System Memory
Threads
Thread Stacks
System Services (a.k.a. System Calls)
General System Architecture
Handles and Objects
Object Names
Accessing Existing Objects
Chapter 2: Getting Started with Kernel
Development
Installing the Tools
Creating a Driver Project
The DriverEntry and Unload Routines
Deploying the Driver
Simple Tracing
Summary
Chapter 3: Kernel Programming Basics
General Kernel Programming Guidelines
Unhandled Exceptions
Termination

Function Return Values
IRQL
C++ Usage
Testing and Debugging
Debug vs. Release Builds
The Kernel API
Functions and Error Codes
Strings
Dynamic Memory Allocation
Linked Lists
The Driver Object
Object Attributes
Device Objects
Opening Devices Directly
Summary
Chapter 4: Driver from Start to Finish
Introduction
Driver Initialization
Passing Information to the Driver
Client / Driver Communication Protocol
Creating the Device Object
Client Code
The Create and Close Dispatch Routines
The Write Dispatch Routine
Installing and Testing
Summary
Chapter 5: Debugging and Tracing
Debugging Tools for Windows
Introduction to WinDbg
Tutorial: User mode debugging basics
Kernel Debugging
Local Kernel Debugging
Local kernel Debugging Tutorial
Full Kernel Debugging
Using a Virtual Serial Port
Using the Network

Kernel Driver Debugging Tutorial
Asserts and Tracing
Asserts
Extended DbgPrint
Other Debugging Functions
Trace Logging
Viewing ETW Traces
Summary
Chapter 6: Kernel Mechanisms
Interrupt Request Level (IRQL)
Raising and Lowering IRQL
Thread Priorities vs. IRQLs
Deferred Procedure Calls
Using DPC with a Timer
Asynchronous Procedure Calls
Critical Regions and Guarded Regions
Structured Exception Handling
Using __try/__except
Using __try/__finally
Using C++ RAII Instead of __try / __finally
System Crash
Crash Dump Information
Analyzing a Dump File
System Hang
Thread Synchronization
Interlocked Operations
Dispatcher Objects
Mutex
Fast Mutex
Semaphore
Event
Named Events
Executive Resource
High IRQL Synchronization
The Spin Lock
Queued Spin Locks
Work Items
Summary

Chapter 7: The I/O Request Packet
Introduction to IRPs
Device Nodes
IRP Flow
IRP and I/O Stack Location
Viewing IRP Information
Dispatch Routines
Completing a Request
Accessing User Buffers
Buffered I/O
Direct I/O
User Buffers for IRP_MJ_DEVICE_CONTROL
Putting it All Together: The Zero Driver
Using a Precompiled Header
The DriverEntry Routine
The Create and Close Dispatch Routines
The Read Dispatch Routine
The Write Dispatch Routine
Test Application
Read/Write Statistics
Summary
Chapter 8: Advanced Programming Techniques
(Part 1)
Driver Created Threads
Memory Management
Pool Allocations
Secure Pools
Overloading the new and delete Operators
Lookaside Lists
The “Classic” Lookaside API
The Newer Lookaside API
Calling Other Drivers
Putting it All Together: The Melody Driver
Client Code
Invoking System Services
Example: Enumerating Processes
Summary

Chapter 9: Process and Thread Notifications
Process Notifications
Implementing Process Notifications
The DriverEntry Routine
Handling Process Exit Notifications
Handling Process Create Notifications
Providing Data to User Mode
The User Mode Client
Thread Notifications
Image Load Notifications
Final Client Code
Remote Thread Detection
The Detector Client
Summary

Introduction
Windows kernel programming is considered by many a dark art,
available to select few that manage to somehow unlock the
mysteries of the Windows kernel. Kernel development, however, is
no different than user-mode development, at least in general terms.
In both cases, a good understanding of the platform is essential for
producing high quality code.
The book is a guide to programming within the Windows kernel,
using the well-known Visual Studio integrated development
environment (IDE). This environment is familiar to many developers
in the Microsoft space, so that the learning curve is restricted to
kernel understanding, coding and debugging, with less friction from
the development tools.
The book targets software device drivers, a term I use to refer to
drivers that do not deal with hardware. Software kernel drivers have
full access to the kernel, allowing these to perform any operation
allowed by the kernel. Some software drivers are more specific, such
as file system mini filters, also described in the book.
Who Should Read This Book
The book is intended for software developers that target the
Windows kernel, and need to write kernel drivers to achieve their
goals. Common scenarios where kernel drivers are employed are in
the Cyber Security space, where kernel drivers are the chief
mechanism to get notified of important events, with the power to
intercept certain operations. The book uses C and C++ for code
examples, as the kernel API is all C. C++ is used where it makes
sense, where its advantages are obvious in terms of maintenance,
clarity, resource management, or any combination of these. The

book does not use complex C++ constructs, such as template
metaprogramming. The book is not about C++, it’s about Windows
kernel drivers.
What You Should Know to Use This
Book
Readers should be very comfortable with the C programming
language, especially with pointers, structures, and its standard
library, as these occur very frequently when working with kernel
APIs. Basic C++ knowledge is highly recommended, although it is
possible to traverse the book with C proficiency only.

Book Contents
Here is a quick rundown of the chapters in the book:
Chapter 1 (“Windows Internals Overview) provides the
fundamentals of the internal workings of the Windows OS at a
high level, enough to get the fundamentals without being
bogged down by too many details.
Chapter 2 (“Getting Started with Kernel Development”)
describes the tools and procedures needed to set up a
development environment for developing kernel drivers. A very
simple driver is created to make sure all the tools and
procedures are working correctly.
Chapter 3 (“Kernel Programming Basics) looks at the
fundamentals of writing drivers, including bssic kernel APIs,
handling of common programming tasks involving strings, linked
lists, dynamic memory allocations, and more.
Chapter 4 (“Driver from Start to Finish”) shows how to build a
complete driver that performs some useful functionality, along
with a client application to drive it.
If you are new to Windows kernel development, you should read
chapters 1 to 7 in order. Chapter 8 contains some advanced material
you may want to go back to after you have built a few simple
drivers. Chapters 9 onward describe specialized techniques, and in
theory at least, can be read in any order.
Sample Code
All the sample code from the book is freely available on the book’s
Github repository at
https://github.com/zodiacon/windowskernelprogrammingbook2e.
Updates to the code samples will be pushed to this repository. It’s

recommended the reader clone the repository to the local machine,
so it’s easy to experiment with the code directly.
All code samples have been compiled with Visual Studio 2019. It’s
possible to compile most code samples with earlier versions of Visual
Studio if desired. There might be few features of the latest C++
standards that may not be supported in earlier versions, but these
should be easy to fix.
Happy reading!
Pavel Yosifovich
June 2022

Chapter 1: Windows Internals
Overview
This chapter describes the most important concepts in the internal
workings of Windows. Some of the topics will be described in greater
detail later in the book, where it’s closely related to the topic at hand.
Make sure you understand the concepts in this chapter, as these make
the foundations upon any driver and even user mode low-level code, is
built.
In this chapter:
Processes
Virtual Memory
Threads
System Services
System Architecture
Handles and Objects
Processes
A process is a containment and management object that represents a
running instance of a program. The term “process runs” which is used
fairly often, is inaccurate. Processes don’t run – processes manage.
Threads are the ones that execute code and technically run. From a
high-level perspective, a process owns the following:
An executable program, which contains the initial code and data
used to execute code within the process. This is true for most
processes, but some special ones don’t have an executable image
(created directly by the kernel).

A private virtual address space, used for allocating memory for
whatever purposes the code within the process needs it.
An access token (called primary token), which is an object that
stores the security context of the process, used by threads
executing in the process (unless a thread assumes a different token
by using impersonation).
A private handle table to executive objects, such as events,
semaphores, and files.
One or more threads of execution. A normal user-mode process is
created with one thread (executing the classic main/WinMain
function). A user mode process without threads is mostly useless,
and under normal circumstances will be destroyed by the kernel.
These elements of a process are depicted in figure 1-1.
Figure 1-1: Important ingredients of a process
A process is uniquely identified by its Process ID, which remains unique
as long as the kernel process object exists. Once it’s destroyed, the
same ID may be reused for new processes. It’s important to realize that
the executable file itself is not a unique identifier of a process. For
example, there may be five instances of notepad.exe running at the
same time. Each of these Notepad instances has its own address space,
threads, handle table, process ID, etc. All those five processes are using
the same image file (notepad.exe) as their initial code and data. Figure
1-2 shows a screenshot of Task Manager’s Details tab showing five
instances of Notepad.exe, each with its own attributes.

Figure 1-2: Five instances of notepad
Virtual Memory
Every process has its own virtual, private, linear address space. This
address space starts out empty (or close to empty, since the executable
image and NtDll.Dll are the first to be mapped, followed by more
subsystem DLLs). Once execution of the main (first) thread begins,
memory is likely to be allocated, more DLLs loaded, etc. This address
space is private, which means other processes cannot access it directly.
The address space range starts at zero (technically the first and last
64KB of the address space cannot be committed), and goes all the way
to a maximum which depends on the process “bitness” (32 or 64 bit)
and the operating system “bitness” as follows:
For 32-bit processes on 32-bit Windows systems, the process
address space size is 2 GB by default.
For 32-bit processes on 32-bit Windows systems that use the
increase user virtual address space setting, can be configured to
have up to 3GB of address space per process. To get the extended
address space, the executable from which the process was created
must have been marked with the LARGEADDRESSAWARE linker flag in its
PE header. If it was not, it would still be limited to 2 GB.
For 64-bit processes (on a 64-bit Windows system, naturally), the
address space size is 8 TB (Windows 8 and earlier) or 128 TB
(Windows 8.1 and later).

For 32-bit processes on a 64-bit Windows system, the address
space size is 4 GB if the executable image has the
LARGEADDRESSAWARE flag in its PE header. Otherwise, the size remains
at 2 GB.
The requirement of the LARGEADDRESSAWARE flag stems from the fact that a 2 GB
address range requires 31 bits only, leaving the most significant bit (MSB) free
for application use. Specifying this flag indicates that the program is not using
bit 31 for anything and so having that bit set (which would happen for
addresses larger than 2 GB) is not an issue.
Each process has its own address space, which makes any process
address relative, rather than absolute. For example, when trying to
determine what lies in address 0x20000, the address itself is not
enough; the process to which this address relates to must be specified.
The memory itself is called virtual, which means there is an indirect
relationship between an address and the exact location where it’s found
in physical memory (RAM). A buffer within a process may be mapped to
physical memory, or it may temporarily reside in a file (such as a page
file). The term virtual refers to the fact that from an execution
perspective, there is no need to know if the memory about to be
accessed is in RAM or not; if the memory is indeed mapped to RAM, the
CPU will perform the virtual-to-physical translation before accessing the
data. if the memory is not resident (specified by a flag in the translation
table entry), the CPU will raise a page fault exception that causes the
memory manager’s page fault handler to fetch the data from the
appropriate file (if indeed it’s a valid page fault), copy it to RAM, make
the required changes in the page table entries that map the buffer, and
instruct the CPU to try again. Figure 1-3 shows this conceptual mapping
from virtual to physical memory for two processes.

Figure 1-3: virtual memory mapping
The unit of memory management is called a page. Every attribute
related to memory is always at a page’s granularity, such as its
protection or state. The size of a page is determined by CPU type (and
on some processors, may be configurable), and in any case, the memory
manager must follow suit. Normal (sometimes called small) page size is
4 KB on all Windows-supported architectures.
Apart from the normal (small) page size, Windows also supports large
pages. The size of a large page is 2 MB (x86/x64/ARM64) or 4 MB
(ARM). This is based on using the Page Directory Entry (PDE) to map the
large page without using a page table. This results in quicker translation,
but most importantly better use of the Translation Lookaside Buffer
(TLB) – a cache of recently translated pages maintained by the CPU. In
the case of a large page, a single TLB entry maps significantly more
memory than a small page.

The downside of large pages is the need to have the memory contiguous in
RAM, which can fail if memory is tight or very fragmented. Also, large pages
are always non-pageable and can only use read/write protection.
Huge pages of 1 GB in size are supported on Windows 10 and Server
2016 and later. These are used automatically with large pages if an
allocation is at least 1 GB in size, and that size can be located as
contiguous in RAM.
Page States
Each page in virtual memory can be in one of three states:
Free – the page is not allocated in any way; there is nothing there.
Any attempt to access that page would cause an access violation
exception. Most pages in a newly created process are free.
Committed – the reverse of free; an allocated page that can be
accessed successfully (assuming non-conflicting protection
attributes; for example, writing to a read-only page causes an
access violation). Committed pages are mapped to RAM or to a file
(such as a page file).
Reserved – the page is not committed, but the address range is
reserved for possible future commitment. From the CPU’s
perspective, it’s the same as Free – any access attempt raises an
access violation exception. However, new allocation attempts using
the VirtualAlloc function (or NtAllocateVirtualMemory, the related
native API) that does not specify a specific address would not
allocate in the reserved region. A classic example of using reserved
memory to maintain contiguous virtual address space while
conserving committed memory usage is described later in this
chapter in the section “Thread Stacks”.

System Memory
The lower part of the address space is for user-mode processes use.
While a particular thread is executing, its associated process address
space is visible from address zero to the upper limit as described in the
previous section. The operating system, however, must also reside
somewhere – and that somewhere is the upper address range that’s
supported on the system, as follows:
On 32-bit systems running without the increase user virtual address
space setting, the operating system resides in the upper 2 GB of
virtual address space, from address 0x80000000 to 0xFFFFFFFF.
On 32-bit systems configured with the increase user virtual address
space setting, the operating system resides in the address space
left. For example, if the system is configured with 3 GB user address
space per process (the maximum), the OS takes the upper 1 GB
(from address 0xC0000000 to 0xFFFFFFFF). The component that
suffers mostly from this address space reduction is the file system
cache.
On 64-bit systems running Windows 8, Server 2012 and earlier, the
OS takes the upper 8 TB of virtual address space.
On 64-bit systems running Windows 8.1, Server 2012 R2 and later,
the OS takes the upper 128 TB of virtual address space.
Figure 1-4 shows the virtual memory layout for the two “extreme” cases:
32-bit process on a 32-bit system (left) and a 64-bit process on a 64-bit
system (right).
Figure 1-4: virtual memory layout

System space is not process-relative – after all, it’s the same system, the
same kernel, the same drivers that service every process on the system
(the exception is some system memory that is on a per-session basis but
is not important for this discussion). It follows that any address in
system space is absolute rather than relative, since it “looks” the same
from every process context. Of course, actual access from user mode
into system space results in an access violation exception.
System space is where the kernel itself, the Hardware Abstraction Layer
(HAL), and kernel drivers reside once loaded. Thus, kernel drivers are
automatically protected from direct user mode access. It also means
they have a potentially system-wide impact. For example, if a kernel
driver leaks memory, that memory will not be freed even after the driver
unloads. User-mode processes, on the other hand, can never leak
anything beyond their lifetime. The kernel is responsible for closing and
freeing everything private to a dead process (all handles are closed and
all private memory is freed).
Threads
The actual entities that execute code are threads. A Thread is contained
within a process, using the resources exposed by the process to do work
(such as virtual memory and handles to kernel objects). The most
important information a thread owns is the following:
Current access mode, either user or kernel.
Execution context, including processor registers and execution state.
One or two stacks, used for local variable allocations and call
management.
Thread Local Storage (TLS) array, which provides a way to store
thread-private data with uniform access semantics.
Base priority and a current (dynamic) priority.
Processor affinity, indicating on which processors the thread is
allowed to run on.
The most common states a thread can be in are:

Running – currently executing code on a (logical) processor.
Ready – waiting to be scheduled for execution because all relevant
processors are busy or unavailable.
Waiting – waiting for some event to occur before proceeding. Once
the event occurs, the thread goes to the Ready state.
Figure 1-5 shows the state diagram for these states. The numbers in
parenthesis indicate the state numbers, as can be viewed by tools such
as Performance Monitor. Note that the Ready state has a sibling state
called Deferred Ready, which is similar, and exists to minimize internal
locking.
Figure 1-5: Common thread states
Thread Stacks
Each thread has a stack it uses while executing, used to store local
variables, parameters passed to functions (in some cases), and where
return addresses are stored prior to making function calls. A thread has
at least one stack residing in system (kernel) space, and it’s pretty small
(default is 12 KB on 32-bit systems and 24 KB on 64-bit systems). A
user-mode thread has a second stack in its process user-space address
range and is considerably larger (by default can grow to 1 MB). An
example with three user-mode threads and their stacks is shown in
figure 1-6. In the figure, threads 1 and 2 are in process A and thread 3
is in process B.

The kernel stack always resides in RAM while the thread is in the
Running or Ready states. The reason for this is subtle and will be
discussed later in this chapter. The user-mode stack, on the other hand,
may be paged out, just like any other user-mode memory.
The user-mode stack is handled differently than the kernel-mode stack
in terms of its size. It starts out with a certain amount of committed
memory (could be as small as a single page), where the next page is
committed with a PAGE_GUARD attribute. The rest of the stack address
space memory is reserved, thus not wasting memory. The idea is to
grow the stack in case the thread’s code needs to use more stack space.
If the thread needs more stack space it would access the guard page
which would throw a page-guard exception. The memory manager then
removes the guard protection, and commits an additional page, marking
it with a PAGE_GUARD attribute. This way, the stack grows as needed,
avoiding the entire stack memory being committed upfront. Figure 1-7
shows this layout.
Figure 1-6: User mode threads
and their stacks
Technically, Windows uses 3 guard pages rather than one in most cases.

Figure 1-7: Thread’s stack in user space
The sizes of a thread’s user-mode stack are determined as follows:
The executable image has a stack commit and reserved values in its
Portable Executable (PE) header. These are taken as defaults if a
thread does not specify alternative values. These are always used
for the first thread in the process.
When a thread is created with CreateThread (or similar functions),
the caller can specify its required stack size, either the upfront
committed size or the reserved size (but not both), depending on a
flag provided to the function; specifying zero uses the defaults set in
the PE header.
Curiously enough, the functions CreateThread and CreateRemoteThread(Ex) only
allow specifying a single value for the stack size and can be the committed or
the reserved size, but not both. The native (undocumented) function,
NtCreateThreadEx allows specifying both values.
System Services (a.k.a. System Calls)
Applications need to perform various operations that are not purely
computational, such as allocating memory, opening files, creating
threads, etc. These operations can only be ultimately performed by code
running in kernel mode. So how would user-mode code be able to
perform such operations?

Let’s take a common (simple) example: a user running a Notepad
process uses the File / Open menu to request opening a file. Notepad’s
code responds by calling the CreateFile documented Windows API
function. CreateFile is documented as implemented in kernel32.Dll,
one of the Windows subsystem DLLs. This function still runs in user
mode, so there is no way it can directly open a file. After some error
checking, it calls NtCreateFile, a function implemented in NTDLL.dll, a
foundational DLL that implements the API known as the Native API, and
is the lowest layer of code which is still in user mode. This function
(documented in the Windows Driver Kit for device driver developers) is
the one that makes the transition to kernel mode. Before the actual
transition, it puts a number, called system service number, into a CPU
register (EAX on Intel/AMD architectures). Then it issues a special CPU
instruction (syscall on x64 or sysenter on x86) that makes the actual
transition to kernel mode while jumping to a predefined routine called
the system service dispatcher.
The system service dispatcher, in turn, uses the value in that EAX register
as an index into a System Service Dispatch Table (SSDT). Using this
table, the code jumps to the system service (system call) itself. For our
Notepad example, the SSDT entry would point to the NtCreateFile
function, implemented by the kernel’s I/O manager. Notice the function
has the same name as the one in NTDLL.dll, and has the same
parameters as well. On the kernel side is the real implementation. Once
the system service is complete, the thread returns to user mode to
execute the instruction following sysenter/syscall. This sequence of
calls is depicted in figure 1-8.

Figure 1-8: System service function call flow
General System Architecture
Figure 1-9 shows the general architecture of Windows, comprising of
user-mode and kernel-mode components.

Figure 1-9: Windows system architecture
Here’s a quick rundown of the named boxes appearing in figure 1-9:
User processes
These are normal processes based on image files, executing on the
system, such as instances of Notepad.exe, cmd.exe, explorer.exe,
and so on.
Subsystem DLLs
Subsystem DLLs are dynamic link libraries (DLLs) that implement
the API of a subsystem. A subsystem is a particular view of the
capabilities exposed by the kernel. Technically, starting from
Windows 8.1, there is only a single subsystem – the Windows
Subsystem. The subsystem DLLs include well-known files, such as
kernel32.dll, user32.dll, gdi32.dll, advapi32.dll, combase.dll, and
many others. These include mostly the officially documented API of
Windows.
NTDLL.DLL
A system-wide DLL, implementing the Windows native API. This is
the lowest layer of code which is still in user mode. Its most
important role is to make the transition to kernel mode for system
call invocation. NTDLL also implements the Heap Manager, the
Image Loader and some part of the user mode thread pool.

Service Processes
Service processes are normal Windows processes that communicate
with the Service Control Manager (SCM, implemented in
services.exe) and allow some control over their lifetime. The SCM
can start, stop, pause, resume and send other messages to
services. Services typically execute under one of the special
Windows accounts – local system, network service or local service.
Executive
The Executive is the upper layer of NtOskrnl.exe (the “kernel”). It
hosts most of the code that is in kernel mode. It includes mostly the
various “managers”: Object Manager, Memory Manager, I/O
Manager, Plug & Play Manager, Power Manager, Configuration
Manager, etc. It’s by far larger than the lower Kernel layer.
Kernel
The Kernel layer implements the most fundamental and time-
sensitive parts of kernel-mode OS code. This includes thread
scheduling, interrupt and exception dispatching, and implementation
of various kernel primitives such as mutexes and semaphores. Some
of the kernel code is written in CPU-specific machine language for
efficiency and for getting direct access to CPU-specific details.
Device Drivers
Device drivers are loadable kernel modules. Their code executes in
kernel mode and so has the full power of the kernel. This book is
dedicated to writing certain types of kernel drivers.
Win32k.sys
This is the kernel-mode component of the Windows subsystem.
Essentially, it’s a kernel module (driver) that handles the user
interface part of Windows and the classic Graphics Device Interface
(GDI) APIs. This means that all windowing operations
(CreateWindowEx, GetMessage, PostMessage, etc.) are handled by this
component. The rest of the system has little-to-none knowledge of
UI.

Hardware Abstraction Layer (HAL)
The HAL is a software abstraction layer over the hardware closest to
the CPU. It allows device drivers to use APIs that do not require
detailed and specific knowledge of things like Interrupt Controllers
or DMA controller. Naturally, this layer is mostly useful for device
drivers written to handle hardware devices.
System Processes
System processes is an umbrella term used to describe processes
that are typically “just there”, doing their thing where normally
these processes are not communicated with directly. They are
important nonetheless, and some in fact, critical to the system’s
well-being. Terminating some of them is fatal and causes a system
crash. Some of the system processes are native processes, meaning
they use the native API only (the API implemented by NTDLL).
Example system processes include Smss.exe, Lsass.exe,
Winlogon.exe, and Services.exe.
Subsystem Process
The Windows subsystem process, running the image Csrss.exe, can
be viewed as a helper to the kernel for managing processes running
under the Windows subsystem. It is a critical process, meaning if
killed, the system would crash. There is one Csrss.exe instance per
session, so on a standard system two instances would exist – one
for session 0 and one for the logged-on user session (typically 1).
Although Csrss.exe is the “manager” of the Windows subsystem
(the only one left these days), its importance goes beyond just this
role.
Hyper-V Hypervisor
The Hyper-V hypervisor exists on Windows 10 and server 2016 (and
later) systems if they support Virtualization Based Security (VBS).
VBS provides an extra layer of security, where the normal OS is a
virtual machine controlled by Hyper-V. Two distinct Virtual Trust
Levels (VTLs) are defined, where VTL 0 consists of the normal user-
mode/kernel-mode we know of, and VTL 1 contains the secure

kernel and Isolated User Mode (IUM). VBS is beyond the scope of
this book. For more information, check out the Windows Internals
book and/or the Microsoft documentation.
Windows 10 version 1607 introduced the Windows Subsystem for Linux (WSL).
Although this may look like yet another subsystem, like the old POSIX and
OS/2 subsystems supported by Windows, it is not like that at all. The old
subsystems were able to execute POSIX and OS/2 apps if these were compiled
using a Windows compiler to use the PE format and Windows system calls.
WSL, on the other hand, has no such requirement. Existing executables from
Linux (stored in ELF format) can be run as-is on Windows, without any
recompilation.
To make something like this work, a new process type was created – the Pico
process together with a Pico provider. Briefly, a Pico process is an empty
address space (minimal process) that is used for WSL processes, where every
system call (Linux system call) must be intercepted and translated to the
Windows system call(s) equivalent using that Pico provider (a device driver).
There is a true Linux (the user-mode part) installed on the Windows machine.
The above description is for WSL version 1. Starting with Windows 10 version
2004, Windows supports a new version of WSL known as WSL 2. WSL 2 is not
based on pico processes anymore. Instead, it’s based on a hybrid virtual
machine technology that allows installing a full Linux system (including the
Linux kernel), but still see and share the Windows machine’s resources, such as
the file system. WSL 2 is faster than WSL 1 and solves some edge cases that
didn’t work well in WSL 1, thanks to the real Linux kernel handling Linux
system calls.
Handles and Objects
The Windows kernel exposes various types of objects for use by user-
mode processes, the kernel itself and kernel-mode drivers. Instances of
these types are data structures in system space, created by the Object
Manager (part of the executive) when requested to do so by user-mode
or kernel-mode code. Objects are reference counted – only when the

last reference to the object is released will the object be destroyed and
freed from memory.
Since these object instances reside in system space, they cannot be
accessed directly by user mode. User mode must use an indirect access
mechanism, known as handles. A handle is an index to an entry in a
table maintained on a process by process basis, stored in kernel space,
that points to a kernel object residing in system space. There are various
Create* and Open* functions to create/open objects and retrieve back
handles to these objects. For example, the CreateMutex user-mode
function allows creating or opening a mutex (depending on whether the
object is named and exists). If successful, the function returns a handle
to the object. A return value of zero means an invalid handle (and a
function call failure). The OpenMutex function, on the other hand, tries to
open a handle to a named mutex. If the mutex with that name does not
exist, the function fails and returns null (0).
Kernel (and driver) code can use either a handle or a direct pointer to an
object. The choice is usually based on the API the code wants to call. In
some cases, a handle given by user mode to the driver must be turned
into a pointer with the ObReferenceObjectByHandle function. We’ll discuss
these details in a later chapter.
Most functions return null (zero) on failure, but some do not. Most notably, the
CreateFile function returns INVALID_HANDLE_VALUE (-1) if it fails.
Handle values are multiples of 4, where the first valid handle is 4; Zero is
never a valid handle value.
Kernel-mode code can use handles when creating/opening objects, but
they can also use direct pointers to kernel objects. This is typically done
when a certain API demands it. Kernel code can get a pointer to an
object given a valid handle using the ObReferenceObjectByHandle

function. If successful, the reference count on the object is incremented,
so there is no danger that if the user-mode client holding the handle
decided to close it while kernel code holds a pointer to the object would
now hold a dangling pointer. The object is safe to access regardless of
the handle-holder until the kernel code calls ObDerefenceObject, which
decrements the reference count; if the kernel code missed this call,
that’s a resource leak which will only be resolved in the next system
boot.
All objects are reference counted. The object manager maintains a
handle count and total reference count for objects. Once an object is no
longer needed, its client should close the handle (if a handle was used to
access the object) or dereference the object (if kernel client using a
pointer). From that point on, the code should consider its handle/pointer
to be invalid. The Object Manager will destroy the object if its reference
count reaches zero.
Each object points to an object type, which holds information on the
type itself, meaning there is a single type object for each type of object.
These are also exposed as exported global kernel variables, some of
which are defined in the kernel headers and are needed in certain cases,
as we’ll see in later chapters.
Object Names
Some types of objects can have names. These names can be used to
open objects by name with a suitable Open function. Note that not all
objects have names; for example, processes and threads don’t have
names – they have IDs. That’s why the OpenProcess and OpenThread
functions require a process/thread identifier (a number) rather than a
string-base name. Another somewhat weird case of an object that does
not have a name is a file. The file name is not the object’s name – these
are different concepts.

Threads appear to have a name (starting from Windows 10), that can be set
with the user-mode API SetThreadDescription. This is not, however, a true
name, but rather a friendly name/description most useful in debugging, as
Visual Studio shows a thread’s description, if there is any.
From user-mode code, calling a Create function with a name creates the
object with that name if an object with that name does not exist, but if it
exists it just opens the existing object. In the latter case, calling
GetLastError returns ERROR_ALREADY_EXISTS, indicating this is not a new
object, and the returned handle is yet another handle to an existing
object.
The name provided to a Create function is not actually the final name of
the object. It’s prepended with SessionsxBaseNamedObjects where x
is the session ID of the caller. If the session is zero, the name is
prepended with BaseNamedObjects. If the caller happens to be
running in an AppContainer (typically a Universal Windows Platform
process), then the prepended string is more complex and consists of the
unique AppContainer SID: SessionsxAppContainerNamedObjects
{AppContainerSID}.
All the above means is that object names are session-relative (and in the
case of AppContainer – package relative). If an object must be shared
across sessions it can be created in session 0 by prepending the object
name with Global; for example, creating a mutex with the CreateMutex
function named GlobalMyMutex will create it under
BaseNamedObjects. Note that AppContainers do not have the power to
use session 0 object namespace.
This hierarchy can be viewed with the Sysinternals WinObj tool (run
elevated) as shown in figure 1-10.

Figure 1-10: Sysinternals WinObj tool
The view shown in figure 1-9 is the object manager namespace,
comprising of a hierarchy of named objects. This entire structure is held
in memory and manipulated by the Object Manager (part of the
Executive) as required. Note that unnamed objects are not part of this
structure, meaning the objects seen in WinObj do not comprise all the
existing objects, but rather all the objects that were created with a
name.
Every process has a private handle table to kernel objects (whether
named or not), which can be viewed with the Process Explorer and/or
Handles Sysinternals tools. A screenshot of Process Explorer showing
handles in some process is shown in figure 1-11. The default columns
shown in the handles view are the object type and name only. However,
there are other columns available, as shown in figure 1-11.

Figure 1-11: Viewing handles in processes with
Process Explorer
By default, Process Explorer shows only handles for objects, which have
names (according to Process Explorer’s definition of a name, discussed
shortly). To view all handles in a process, select Show Unnamed Handles
and Mappings from Process Explorer’s View menu.
The various columns in the handle view provide more information for
each handle. The handle value and the object type are self explanatory.
The name column is tricky. It shows true object names for Mutexes
(Mutants), Semaphores, Events, Sections, ALPC Ports, Jobs, Timers,
Directory (object manager Directories, not file system directories), and
other, less used object types. Yet others are shown with a name that has
a different meaning than a true named object:
Process and Thread objects, the name is shown as their unique ID.
For File objects, it shows the file name (or device name) pointed to
by the file object. It’s not the same as an object’s name, as there is
no way to get a handle to a file object given the file name - only a
new file object may be created that accesses the same underlying
file or device (assuming sharing settings for the original file object
allow it).
(Registry) Key objects names are shown with the path to the
registry key. This is not a name, for the same reasoning as for file
objects.
Token object names are shown with the user name stored in the
token.

Accessing Existing Objects
The Access column in Process Explorer’s handles view shows the access
mask which was used to open or create the handle. This access mask is
key to what operations are allowed to be performed with a specific
handle. For example, if client code wants to terminate a process, it must
call the OpenProcess function first, to obtain a handle to the required
process with an access mask of (at least) PROCESS_TERMINATE, otherwise
there is no way to terminate the process with that handle. If the call
succeeds, then the call to TerminateProcess is bound to succeed.
Here’s a user-mode example for terminating a process given a process
ID:
bool KillProcess(DWORD pid) {
//
// open a powerful-enough handle to the process
//
HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
if (!hProcess)
return false;
//
// now kill it with some arbitrary exit code
//
BOOL success = TerminateProcess(hProcess, 1);
//
// close the handle
//
CloseHandle(hProcess);
return success != FALSE;
}
The Decoded Access column provides a textual description of the access
mask (for some object types), making it easier to identify the exact
access allowed for a particular handle.
Double-clicking a handle entry (or right-clicking and selecting Properties)
shows some of the object’s properties. Figure 1-12 shows a screenshot
of an example event object properties.

Figure 1-12: Object properties in Process Explorer
Notice that the dialog shown in figure 1-12 is for the object’s properties,
rather than the handle’s. In other words, looking at an object’s properties
from any handle that points to the same object shows the same
information.
The properties in figure 1-12 include the object’s name (if any), its type,
a short description, its address in kernel memory, the number of open
handles, and some specific object information, such as the state and
type of the event object shown. Note that the References shown do not
indicate the actual number of outstanding references to the object (it
does prior to Windows 8.1). A proper way to see the actual reference
count for the object is to use the kernel debugger’s !trueref command,
as shown here:
lkd> !object 0xFFFFA08F948AC0B0
Object: ffffa08f948ac0b0 Type: (ffffa08f684df140) Event
ObjectHeader: ffffa08f948ac080 (new version)

HandleCount: 2 PointerCount: 65535
Directory Object: ffff90839b63a700 Name: ShellDesktopSwitchEvent
lkd> !trueref ffffa08f948ac0b0
ffffa08f948ac0b0: HandleCount: 2 PointerCount: 65535 RealPointerCount: 3
We’ll take a closer look at the attributes of objects and the kernel
debugger in later chapters.
In the next chapter, we’ll start writing a very simple driver to show and
use many of the tools we’ll need later in this book.

Chapter 2: Getting Started with
Kernel Development
This chapter deals with the fundamentals needed to get up and running
with kernel driver development. During the course of this chapter, you’ll
install the necessary tools and write a very basic driver that can be
loaded and unloaded.
In this chapter:
The DriverEntry and Unload routines
Simple Tracing
In the old days (pre-2012), the process of developing and building
drivers included using a dedicated build tool from the Device Driver Kit
(DDK), without having an integrated development experience developers
were used to when developing user-mode applications. There were
some workarounds, but none of them was perfect nor officially
supported by Microsoft.
Fortunately, starting with Visual Studio 2012 and Windows Driver Kit 8,
Microsoft officially supports building drivers with Visual Studio (with
msbuild), without the need to use a separate compiler and build tools.
To get started with driver development, the following tools must be
installed (in this order) on your development machine:

Visual Studio 2019 with the latest updates. Make sure the C++
workload is selected during installation. Note that any SKU will do,
including the free Community edition.
Windows 11 SDK (generally, the latest is recommended). Make sure
at least the Debugging Tools for Windows item is selected during
installation.
Windows 11 Driver Kit (WDK) - it supports building drivers for
Windows 7 and later versions of Windows. Make sure the wizard
installs the project templates for Visual Studio at the end of the
installation.
The Sysinternals tools, which are invaluable in any “internals” work,
can be downloaded for free from http://www.sysinternals.com. Click
on Sysinternals Suite on the left of that web page and download the
Sysinternals Suite zip file. Unzip to any folder, and the tools are
ready to go.
The SDK and WDK versions must match. Follow the guidelines in the WDK
download page to load the corresponding SDK with the WDK.
A quick way to make sure the WDK templates are installed correctly is to open
Visual Studio and select New Project and look for driver projects, such as
“Empty WDM Driver”.
With the above installations in place, a new driver project can be
created. The template you’ll use in this section is “WDM Empty Driver”.
Figure 2-1 shows what the New Project dialog looks like for this type of
driver in Visual Studio 2019. Figure 2-2 shows the same initial wizard
with Visual Studio 2019 if the Classic Project Dialog extension is installed
and enabled. The project in both figures is named “Sample”.

Figure 2-1: New WDM Driver Project in Visual Studio
2019
Figure 2-2: New WDM Driver Project in Visual Studio
2019 with the Classic Project Dialog extension
Once the project is created, the Solution Explorer shows a single file
within the Driver Files filter - Sample.inf. You won’t need this file in this
example, so simply delete it (right-click and select Remove or press the
Del key).
Now it’s time to add a source file. Right-click the Source Files node in
Solution Explorer and select Add / New Item… from the File menu.

Select a C++ source file and name it Sample.cpp. Click OK to create it.
The DriverEntry and Unload Routines
Every driver has an entry point called DriverEntry by default. This can
be considered the “main” function of the driver, comparable to the
classic main of a user-mode application. This function is called by a
system thread at IRQL PASSIVE_LEVEL (0). (IRQLs are discussed in detail
in chapter 8.)
DriverEntry has a predefined prototype, shown here:
NTSTATUS
DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING
RegistryPath
);
The _In_ annotations are part of the Source (Code) Annotation
Language (SAL). These annotations are transparent to the compiler, but
provide metadata useful for human readers and static analysis tools. I
may remove these annotations in code samples to make it easier to
read, but you should use SAL annotations whenever possible.
A minimal DriverEntry routine could just return a successful status, like
so:
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath) {
return STATUS_SUCCESS;
}
This code would not yet compile. First, you’ll need to include a header
that has the required definitions for the types present in DriverEntry.
Here’s one possibility:
#include <ntddk.h>

Now the code has a better chance of compiling, but would still fail. One
reason is that by default, the compiler is set to treat warnings as errors,
and the function does not make use of its given arguments. Removing
treat warnings as errors from the compiler’s options is not
recommended, as some warnings may be errors in disguise. These
warnings can be resolved by removing the argument names entirely (or
commenting them out), which is fine for C++ files. There is another,
more “classic” way to solve this, which is to use the
UNREFERENCED_PARAMETER macro:
NTSTATUS
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath) {
UNREFERENCED_PARAMETER(DriverObject);
UNREFERENCED_PARAMETER(RegistryPath);
}
As it turns out, this macro actually references the argument given just
by writing its value as is, and this shuts the compiler up, making the
argument technically “referenced”.
Building the project now compiles fine, but causes a linker error. The
DriverEntry function must have C-linkage, which is not the default in
C++ compilation. Here’s the final version of a successful build of the
driver consisting of a DriverEntry function only:
extern "C" NTSTATUS
}
At some point, the driver may be unloaded. At that time, anything done
in the DriverEntry function must be undone. Failure to do so creates a
leak, which the kernel will not clean up until the next reboot. Drivers can
have an Unload routine that is automatically called before the driver is

unloaded from memory. Its pointer must be set using the DriverUnload
member of the driver object:
DriverObject->DriverUnload = SampleUnload;
The unload routine accepts the driver object (the same one passed to
DriverEntry) and returns void. As our sample driver has done nothing in
terms of resource allocation in DriverEntry, there is nothing to do in the
Unload routine, so we can leave it empty for now:
void SampleUnload(_In_ PDRIVER_OBJECT DriverObject) {
}
Here is the complete driver source at this point:
#include <ntddk.h>
void SampleUnload(_In_ PDRIVER_OBJECT DriverObject) {
}
extern "C" NTSTATUS
DriverObject->DriverUnload = SampleUnload;
}
Now that we have a successfully compiled Sample.sys driver file, let’s
install it on a system and then load it. Normally, you would install and
load a driver on a virtual machine, to remove the risk of crashing your
primary machine. Feel free to do so, or take the slight risk with this
minimalist driver.
Installing a software driver, just like installing a user-mode service,
requires calling the CreateService API with proper arguments, or using a

comparable tool. One of the well-known tools for this purpose is Sc.exe
(short for Service Control), a built-in Windows tool for managing
services. We’ll use this tool to install and then load the driver. Note that
installation and loading of drivers is a privileged operation, normally
available for administrators.
Open an elevated command window and type the following (the last part
should be the path on your system where the SYS file resides):
sc create sample type= kernel binPath= c:devsamplex64debugsample.sys
Note there is no space between type and the equal sign, and there is a
space between the equal sign and kernel; same goes for the second
part.
If all goes well, the output should indicate success. To test the
installation, you can open the registry editor (regedit.exe) and look for
the driver details at HKLMSystemCurrentControlSetServicesSample.
Figure 2-3 shows a screenshot of the registry editor after the previous
command.
Figure 2-3: Registry for an installed driver
To load the driver, we can use the Sc.exe tool again, this time with the
start option, which uses the StartService API to load the driver (the

same API used to load services). However, on 64 bit systems drivers
must be signed, and so normally the following command would fail:
sc start sample
Since it’s inconvenient to sign a driver during development (maybe even
not possible if you don’t have a proper certificate), a better option is to
put the system into test signing mode. In this mode, unsigned drivers
can be loaded without a hitch.
With an elevated command window, test signing can be turned on like
so:
bcdedit /set testsigning on
Unfortunately, this command requires a reboot to take effect. Once
rebooted, the previous start command should succeed.
If you are testing on a Windows 10 (or later) system with Secure Boot enabled,
changing the test signing mode will fail. This is one of the settings protected by
Secure Boot (local kernel debugging is also protected by Secure Boot). If you
can’t disable Secure Boot through BIOS setting, because of IT policy or some
other reason, your best option is to test on a virtual machine.
There is yet another setting that you may need to specify if you intend
to test the driver on pre-Windows 10 machine. In this case, you have to
set the target OS version in the project properties dialog, as shown in
figure 2-4. Notice that I have selected all configurations and all
platforms, so that when switching configurations (Debug/Release) or
platforms (x86/x64/ARM/ARM64), the setting is maintained.

Figure 2-4: Setting Target OS Platform in the project
properties
Once test signing mode is on, and the driver is loaded, this is the output
you should see:
c:/>sc start sample
SERVICE_NAME: sample
TYPE : 1 KERNEL_DRIVER
STATE : 4 RUNNING
(STOPPABLE, NOT_PAUSABLE, IGNORES_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
PID : 0
FLAGS :
This means everything is well, and the driver is loaded. To confirm, we
can open Process Explorer and find the Sample.Sys driver image file.
Figure 2-5 shows the details of the sample driver image loaded into
system space.

Other documents randomly have
different content

stolze Zeit war hier versammelt, neu hervorgezaubert trotz
Carmagnole und Marseillaise.
Rundum saßen Herren in Seidenstrümpfen und Damen mit
Spitzentüchern, elegant in all der entsetzlichen Notdurft dessen, was
man ihnen, den gefangenen Opfern der Volksrache, gelassen hatte.
Knie über Knie geschlagen die Herren, graziöse Köpfchen in schlanke
Hände gelegt die Damen, eine einzige große Erlauchtheit.
Und darüber hin schmeichelte wie Weihrauchwolken Wolfgang
Amadés wundervolle Grazie.
Es kommt gegen das Ende des Allegro eine Stelle ganz
unvermittelt, lieblicher als aller bisheriger Fluß süßer Melodie, ganz
wider Schule und Hergang, als dächte plötzlich einer der Spieler an
ein leises Zofenhändchen, das ihm hinterrücks neckisch zärtelnd
über die Wange streichelte. Als diese Stelle kam, hörte Herr Primus
hinter sich ein wohlgefällig leises: Ah!
Er drehte sich um — Blanchefleure. Sie hatte ihn erkannt, hob
aber sachte die Hand, nicht zu stören. Bald danach war der Satz zu
Ende und während die Herren und Damen vom Adel entzückt zu den
Spielern traten, reichte Herr Kapitän Thaller der armen, reizend
blassen Blanchefleure seine ehrlichen Hände, um ihr seinen Antrag
zu machen.
Sie hörte ihn mit hochgezogenen erstaunten Augenbrauen an,
als er begann: „Sie sind jetzt Witwe und arm wie eine Appenzeller
Kuhdirn, Gott sei Dank.“
„Oh!“ zweifelte sie: „Ah?“
„In jetziger Zeit aber sind wir Soldaten alles. Die Revolution
glaubt den Offizier zu vernichten und macht ihn zum Herrgott.
Unsereins krabbelt es in den Händen, so stark sind wir jetzt! Ich
werde Sie also aus dem Höhlenloch herausholen: wie, das werden
Quintus und ich schon zuwege bringen.“

„Warten Sie,“ sagte Blanchefleure, „da kommt eine Menuett.“
Wirklich begannen die vier Musikanten einen jener reizenden
Tänze der eleganten Zeit zu spielen, bei dem man sich mit Augen
und Fingerspitzen Dinge sagte, für die sich der plebejisch
umschlingende Walzer keinen Rat weiß. Und die ganz leichtsinnigen
von den Herren und Damen ordneten sich zum Antritt.
„Es ist vielleicht die letzte Menuett,“ entschuldigte Blanchefleure
mit reizendem Lächeln; „und ich würde es sehr beklagen, sie nicht
getanzt zu haben: — mit Ihnen, Herr Kapitän,“ fügte sie
herzbezwingend hinzu, als der arme Junge tiefbetrübt zurücktrat,
und sie nahm ihn bei der Hand. „Scheuen Sie sich doch nicht,“ fuhr
sie fort. „Wir haben doch Egalité, Fraternité. Was, Sie glauben auch
nicht recht daran? Immerhin; ich tanze gern mit Ihnen.“
Und der süße, schwermütig kokette Tanz des todesnahen
Leichtsinns begann. Kein Totentanz war so wie der. So voll
leichtfertiger Absage an das Ende. Es war die Melodie der Menuett
aus dem Don Giovanni und sie spielte wie diese kurz vor dem ersten
Zuschlagen des Schicksals; übermütig frivol und graziös wie diese.
Im Annähern fuhr Primus Thaller mit seiner ehrlich heißen
Werbung fort. „Ich habe Sie lieb wie keine andere und Sie sollen
meine Frau sein.“
Das neckische Zurückweichen des Tanzes der Koketterie führte
Blanchefleure von ihm weg. Ihre Augen lachten, aber sie sagte:
„Was Ihnen nicht einfällt. Sie sind geschmacklos, mein Freund.“
Wieder schwemmten sie die weichen Wogen des Tanzrhythmus
zu ihm; ihre Hände umschlangen sich. „Mein Geliebter wären Sie
vielleicht worden, dort unten in La Réole, wo die Herdenglocken
süße, befreite Natur predigen. Ich hatte immer meine Saison der
Naturrückkehr.“

Und sie neigte sich zurück und schritt im neckenden Taktschritt
davon, während das Herz des armen Primus in Flammen tobte,
gebändigt vom Tanzgesetz, von der allgemeinen Grazie, innerlich
aber unbändig, als ob die ganze Revolution in ihm gefesselt läge und
gefoppt würde. Und wieder kam sie zurück: „Aber Madame Thaller
zu werden — mein lieber, ehrlicher Freund aus Appenzell! Was
denken Sie? Man könnte Sie küssen für so viel Naivetät! Ach, daß wir
nicht mehr in La Réole unsere Komödie haben durften. Welche
Bêtise! Nun müssen wir sogar auf den Kuß verzichten! Außer Sie
wollten mit einem Handkuß vorlieb nehmen?“
Es kam nun die Stelle in der Menuett, da auf dem Theater der
Wehschrei Zerlinens den süßen Leichtsinn zerreißt. Und obwohl die
galanten Herren Miradoux, Vicomte Chantigny, Avenarius und Abbé
Mervioli die Noten für eine kleine ununterbrochene Rückkehr zu
einem fröhlichen Dacapo überarbeitet hatten, gebot doch das
Schicksal den Originalsatz. Die Tür wurde aufgerissen und eine arge
Branntweinstimme zerriß das Blumengewinde eines kurzen Traumes.
„Ihr da, Bürger und Bürgerinnen! Ruhe im Namen der
Republik!“
Der Reigen erstarrte zu Eis, hinhorchten Herren und Damen,
denn jene Unterbrechung kannten sie. Es war die alltägliche
Verlesung der Namen jener, welche vor Gericht geladen waren, um
— recht oft — verurteilt zu werden. Aus dem Temple ging der Weg
besonders leicht in die Sackgasse mit dem einzigen Fenster nach der
Ewigkeit, dem Loch der Guillotine.
Diesmal wurde auch der Name der kleinen Bürgerin Massimel
verlesen. „Hier,“ rief sie, aber sie war erbleicht.
„Denken Sie jetzt an meinen Antrag?“ fragte Primus Thaller,
angstvoll hinter sie tretend.

Die arme, blasse Blanchefleure sah ihn mit ihren erschrockenen
Augen an, über denen verwunderte Augenbrauen standen. „Ach
Gott, mein Freund,“ sagte sie kläglich. „Ihre Republikaner lassen
einem nicht einmal sein bißchen Tanzfreude. Dort in der Ecke steht
meine kleine Zofe, die sich mit mir einsperren hat lassen. Zénobe!
Du darfst mit diesem Herrn weitertanzen. Bitte, entschuldigen Sie
mich wegen dieser fatalen Verhinderung und nehmen Sie mit ihr
vorlieb; sie ist ein reizendes Kind.
Adieu, mein Freund!“
Und Herr Miradoux, der Unverbesserliche des ancien régime,
begann von neuem auf der Geige die Schmeichelweise Mozarts zu
streichen, ganz piano ....., leise lachend ordneten sich etliche Paare,
wie früher. Aber die kleine Zénobe wagte nicht, mit anzutreten. Sie
weinte vor Schreck und meinem Großvater war es gar nicht um den
Tanz mit der Zofe. Er drehte ihnen allen, schwerblütig fortwandelnd,
den Rücken.
Das war die denkwürdige Menuett gewesen, die der bürgerliche
Kapitän Primus Thaller in einer Reihe mit einem hochansehnlichen
Adel getanzt hatte.
Es war die letzte Menuett des Rokoko gewesen, mitten in ihrer
graziösen Süßigkeit zerrissen durch den Ruf des Jakobinertribunals.
In eigenartig gemischter Betrübtheit stieg Herr Kapitän Primus
wieder in den Tag hinauf und auch die kleine Blanchefleure verließ
ihr Gefängnis, um vor Gericht zu treten.
Dessen Barriere glich einem Branntweinschanktisch. Vier oder
fünf unordentliche Rohlinge lauerten dort, schmutzig und bösartig
wie gesträubte Bauernhunde.
„Bürgerin Blanchefleure Massimel? Witwe?“ knurrte sie einer an.
„Da Sie es so wünschen — — —“
„Vom ehemaligen Hofstaat der Bürgerin Antoinette Capet?“

„Wessen? Der Königin, wollen Sie sagen?“
„Ach, so? Notieren Sie das genau, Bürger Pouprac! Königin
sagte sie.“
„Ich denke, das genügt schon,“ murrte Pouprac gleichmütig.
Dann aber sah er boshaft auf. „Warum lächeln Sie, Bürgerin? Sie
beleidigen das Gericht damit! Warum lächeln Sie?“
„Mein Gott, wie sehen Sie denn aus!“ platzte die arme
Blanchefleure tiefrot im ganzen Antlitz hervor. „Wenn man solche
Pantalons anhat wie Sie!“ Und sie drückte die Hände vors Gesicht
und lachte wie ein dummer Backfisch.
Pouprac warf einen Blick auf seine Hosen aus blau-weiß-
rotgestreiftem Kattun, auf diese stolze Flagge und Schaustellung
seiner republikanischen Gesinnung. Dann sprang er wütend auf
seine beiden nationalgetigerten Beine: „Sie sind des Todes schuldig,
Bürgerin Massimel,“ brüllte er. „Des Todes wegen Beleidigung der
französischen Nationalfahne!“
Da zog die kleine Marquise die Hände von ihrem Antlitz und sah
ihn an, hohe, erstaunte, drollige Augenbrauen, gerümpfte Nase:
„Sie, Sie wollen mich richten! Waschen Sie sich und ziehen Sie
Strümpfe an, bevor Sie mich nur bedienen wollen!“
Und sie ging. Sie hatte sich auf das Schafott gelacht.
Mein Großvater hörte nur noch von ihr, wie sie nicht zulassen
wollte, daß man ihr die Haare abschneide. „Meinen Sie,“ hatte sie
den Gerichtsbeamten gefragt, „daß das unbedingt nötig ist? Der
Mann auf dem Gerüst kann sie gebrauchen, um das Haupt daran in
die Höhe zu heben: — nachher; wie das so eine Ihrer Gewohnheiten
sein soll.“

Und als der Sansculotte mit grober Kürze darauf bestand, hatte
sie die lieblichen Schultern gezuckt: „Meinetwegen. Ich wußte schon,
als Sie kamen, mich zu köpfen, daß Sie keinen ästhetischen Sinn
haben. Und ich habe recht behalten.“
Nach diesen letzten, befreit geistigen Worten starb sie aber
dennoch als armes, zitterndes Weib.
Sie starben und alle, die um sie hätten weinen können, waren
tot oder hatten an das eigene Sterben zu denken. So verstand keine
Seele, was mit der schönen Blanchefleure zu Ende gegangen war,
die ihr Lebelang recht behalten hatte.
Auch mein armer Großvater hat sie nie verstanden.
Nur ich, nur ich! Ich verstehe sie, der ich ihr Bild erst vom
Trödler loskaufen mußte, wie zur Rache des Nachgebornen an der,
die durchaus nicht seine Urgroßmutter werden wollte.
Gut, daß sie es nicht wurde. Sie ist dabei jung geblieben, ewig
jung und begehrenswert.
Und ich darf sie lieben, wie der ehrliche Primus Thaller sie
liebte, nur besser noch: Verständiger, luxuriöser.
Sie hatte in allem recht und ich sehne mich nach ihr ...

Es bedurfte in der Geschichte der Kultur des Herrn Chevalier von
Landry, um zu beweisen, daß man, vom Königshofe Frankreichs an
die frische Vogesenluft versetzt, sterben müßte.
Nur das Vorbild seines Oheims, des Kardinals und Erzbischofs
von Straßburg, Rohan, hatte ihm vorläufig das Leben gerettet,
jedoch nur auf kurze Zeit.
Rohan und der Chevalier waren vom Hofe weg nach dem Elsaß,
dem ihrer Meinung nach brutalsten Lande der Welt, verbannt
worden, in dem man kaum erst das Französische zu erlernen
begann, geschweige denn die Sprache von Versailles. Die
berüchtigte Halsbandgeschichte war schuld gewesen. Der Kardinal
und der Chevalier hatten beide die entzückend leichtfertige Königin
sehr geliebt, und der Chevalier hatte gehofft, bald der Nachfolger
des beschränkten Rohan in der Gunst Marie Antoinettes zu werden.
Die reizende Geschichte war mit dem ärgerlichsten Skandalprozeß zu
Ende gegangen, und weil der Kardinal in Bergzabern das Schloß
seiner Väter aus größter Langeweile von neuem aufzubauen begann,
folgte der Chevalier seinem Beispiel, den gewaltigen Versuch zu
wagen, aus einem Stück Elsaß ein Stück Versailles zu machen.
Es war entsetzlich, zu Beginn der Verbannung!

Die Landry hatten ihren Stammsitz seit drei Generationen nicht
gesehen. Großvater Landry, Vater Landry und Landry Sohn hatten,
ähnlich den Seligen des Himmelreichs, im Angesicht des Königs Zeit
und Ewigkeit vergessen. Louis quatorze, Louis quinze, Louis seize,
vor jedem lächelte ein Landry, hinter jedem flüsterte ein Landry. Die
Landry waren erbangesessen hinter dem oeil de boeuf. Alles, was
ihnen von ihrem Vogesenbesitz bewußt war, bildeten die
hunderttausend Ecus jährlich: Hunderttausend fröhliche, leichtfertige
Taler, die dem Elsaß gänzlich unnötig waren und die darauf
brannten, an Karossen, Puder, Pferde, Sängerinnen, Samt, Tressen,
Jagdpartien, Festschmäuse und Trinkgelder verwendet zu werden.
Und nun saß er, der erste Landry seit fast einem Jahrhundert,
wieder auf dem Schlosse. Von der Wasserscheide der Vogesen bis
weit ins ebene Land hinein gehörte ein Stück Erde ihm, schön, mild,
reich und still wie eine Insel der Seligen. Er aber starb beinahe
daran.
Er taufte sein Schloß um; er nannte es Schloß Patmos, weil Jean
Evangeliste de Landry hier verbannt saß. Er, der niemals einen Berg
erstiegen, ächzte dreimal die Woche zum Kamm der Vogesen empor,
schaute nach Westen und wünschte im Graben der einzigen Straße
Frankreichs sein Leben zu beschließen, der Straße von Paris nach
Versailles.
Er sah sie: ein beständiger, leuchtender Königszug. Karosse an
Karosse. Die hochfrisierten Damen mußten sich oft weit vorbeugen,
lachend oder vor Schreck aufschreiend, weil zwei Pferdehäupter
hinter ihnen über dem Fond des Wagens nickten. So voll, so
rauschend war der Verkehr. — Die ganze Straße war ein Trab, ein
Geplauder, ein Lächeln, Winken, Nicken, sie war Frankreichs Salon,
Stelldichein und einziger Ausflug ins Freie zugleich.
Nach einiger Zeit lernte Herr von Landry infolge der vielen
Seufzer die Bergluft atmen und sie machte ihn etwas stärker. Er

sagte mit einem Teil jenes Trotzes, der die Landry vor über hundert
Jahren geziert hatte: Schön: Kann ich nicht nach Versailles kommen,
so soll Versailles zu mir kommen. Hunderttausend Taler Rente
bedeuten hier mitten in der Naivetät dieser Gegend das Dreifache.
Ich will mir meine eigene Hofhaltung schaffen.
Nach einem Jahr stand Schloß Patmos da, wie aus Zucker und
Tragant gebildet. Herr von Landry lud ein, was jemals im Leben
einen Strahl von Versailles erhascht hatte, und ein unendlicher Jubel
entstand unter dem französischen Pfründenadel zu Straßburg. Ach,
wie atmeten diese Franzosen auf! Mit den Elsässern war keine
Anspielung und kein Lächeln zu tauschen. Sie verstanden kein
Parfüm, keinen Schnitt, keine Mode, kein Kompliment und keine
Bosheit. Eine reich bezahlte Stelle und ein sorgenloses Amt hatte viel
entzückende Leute nach diesem Straßburg gelockt. Voll tanzender
Hoffnung waren sie gekommen und sahen hier Menschen mit
Rosetten an den Hosen, mit ungepudertem Haar, ja sogar Menschen
in Stiefeln, Menschen, die den Hut dazu mißbrauchten, ihn auf den
Kopf zu stülpen, statt ihn unter dem Arme zu tragen. Es waren hier
Leute, die nicht einmal wußten, den Spazierstock graziös auf den
Boden zu setzen, geschweige denn ihre Beine. Alles war aus!
Da eröffnete ihnen dieser schwermütige Halbgott Landry sein
neu umgebautes, zuckernes, filigranes und brokatnes Patmos. Ein
kleines Versailles, neuester Mode. Ach, die Welt war wieder
wohnlich!
Es kamen in Scharen, die es mit Grazie verstanden, unnütz zu
sein. Nicht ein Zimmer im Schlosse war unbesetzt, und was von den
Bewohnern nicht dem Adel angehörte, war mindestens Blumenstaub
aus der feinsten Blüte des geistigen Frankreich. — Dichter, Musiker,
Philosophen und zwei Maler waren von Paris verschrieben worden.
Das leichte Geistesvolk weilte gern in Patmos. In Paris war große
Rivalität und allzuviel Angebot; hier schmückte es Schloß und Park
wie Halbgötter auf ehrfurchtsvollen Postamenten.

Nun hatte man schon das zweite Jahr im ältern Versailler Stil
Konversation gemacht, hatte musiziert, getanzt, Komödie gespielt,
gejagt und geliebt, da fuhr der Schreck in Herrn von Landry, ob man
in Paris und Versailles nicht inzwischen längst eine neue Mode hätte?
Es war ein großes Wagnis; er fuhr trotz des königlichen Verbots
in einer sehr vollkommenen Verkleidung nach Paris; als ein
deutscher Gelehrter, um dort von den Intimsten seines Briefwechsels
zu erfahren, wie man inzwischen seine Kleider, seinen Geist, seine
Perücke und seine Gefühle trug.
Da ward ihm eine große Überraschung. Schon seit Herr
Benjamin Franklin dagewesen war, versuchte man sich ein wenig in
Aufrichtigkeit; nun aber war Herr Jean Jacques Rousseau
unwiderstehlich in Mode gekommen, und man spielte geradezu
Natur! Man versuchte die Natur genau so zu sehen wie Herr
Rousseau und entdeckte hiedurch mehr als ein Dutzend ungeahnte,
gänzlich neue Gefühle. Ganz Paris und Versailles waren entzückt. Der
König schob eigenhändig einen Bauernkarren aus dem Dreck, die
Königin buk eine Omelette, ja Madame de France spielte einmal den
guten, aufrichtigen Bauern unter der Dorflinde auf der Geige zum
Tanz auf. In allen Salons bewunderten sie das Gefühlsleben der
Kohlenbrenner und Wilddiebe, und der Herzog von Orléans brach in
Freudentränen aus, als er in dem Dorfe Saint Léger ein bäurisches
Ehepaar streiten fand und hierbei die erste Ohrfeige sah und hörte.
Mit einem köstlichen Gefühl eilte Chevalier Landry nach dem
Elsaß zurück und brachte der reizendsten aller Gastgesellschaften
den unerhörten Vorsatz mit, sie werde sich von nun an der Natur
gemäß zu verhalten und zu unterhalten haben.
Herren und Damen überboten sich von da ab in Erfindungen
und Entdeckungen, aber vollkommen wurde man erst, als der
Chevalier zur größten Ergötzung der erlauchten Gesellschaft ein

Naturkind eingeladen hatte, das die Feinheiten der übrigen
vergangnen Moden noch gar nicht erst kennen gelernt hatte.
Das war ein deutscher Jüngling.
Hans Georg von Hirschbach kam aus dem Thüringer Walde und
hatte soeben in Straßburg die Philosophie zu Ende studiert. Er war
ein Prachtjunge, aber nur für Deutschland. Aufmerksam und
nachdenklich, von einer zusammengehaltenen Resolutheit, etwas
schweigsam, etwas einsam, etwas holperig. Er hatte eine warme,
tiefe, herzliche Stimme, lachte stets nur aus Freude und nie über
Bosheiten, schlug und balgte sich ein wenig gern, scheute sehr die
Damen, war hellbraun, krausköpfig, stämmig und hatte einen festen
Nacken, schiefgeneigten Kopf, starke Stirne und starke Kinnbacken.
Sein Teint war kräftig wie Roggenbrot, sein Gang etwas werfend und
schleuderhaft, wenn er allein die Landstraße maß, und höchst
befangen und stolperbedroht in Gesellschaft.
Er hatte zu Hause nichts getrieben als Vogelfang und Pirschjagd.
In Straßburg war er ein bißchen im Fechten, Schießen und Reiten
fortgefahren, hatte das Zechen, das Singen und Radaumachen
erlernt, war dann über die Bücher geraten und hatte sich mit seiner
ganzen Waldburschenseele dem Shakespeare verschrieben.
Und gerade Hans Georg geriet in die diskrete, lächelnde,
wespenboshafte und bis zum Überschwang liebenswürdige
Gesellschaft im Schlosse des Chevaliers Landry!
Er geriet mit Wissen und Willen seiner Mama hinein, die
außerordentlich viel auf die feingeschliffene Kultur von Versailles
gab. Hans Georgs Mama war zärtlich, geistvoll, belesen und sprach
das delikateste Französisch, alles mitten im Thüringer Wald. Sie
wünschte sehr, daß ihr Sohn diese Eigenschaften von ihr geerbt
haben möchte, die er an einer bessern Stelle verwerten sollte. Ihr
Bittgesuch hatte der alte Freund der Familie, ein Straßburger
Gelehrter und Gast Landrys, dem Hausherrn von Schloß Patmos

gebracht und eine Einladung voll Honigseim erfloß nach Straßburg
„an den Chevalier Jean de Hirsbac“.
In der Fahrpost, in welcher der junge Thüringer nach dem
Schlosse fuhr, saß nur noch eine Reisende, nebst unermeßlich vielen
Koffern und Schachteln. Diese Dame war so jung, so graziös, so
schön und in jeder Bewegung so sicher, daß Hans Georg vor Scheu
fast die Beine unter sich auf den Sitz gezogen hätte. Denn es waren
Beine, die in Stulpenstiefeln steckten, was ihn zum erstenmal sehr
genierte. Wenn man zierlich sein wollte, dann trug man ohne
Nachsicht Kniehosen und Seidenstrümpfe.
Er fürchtete sich vor ihrer Bekanntschaft. Er betrachtete sie
lange Zeit nur ganz versteckt, gelegentlich aus dem Profil
hinüberhuschend. Sie war königlich blaß, hatte eine kapitale Frisur,
breiten Hut à la Schäferin, eine wunderbar reine Stirn, und der Mund
wie das Profil waren fein und von gefaßtem Schwung. Die Augen
hatte sie durch die stolz und nachlässig geschlossenen Lider
verdeckt, aber man sah durch diese zarten Lider, daß sie tief und
groß und braun waren.
Das wird eine respektvolle, traurige Reise werden, dachte der
junge Hirschbach, zog die Füße nach hinten, legte die Hände
gleichmäßig auf die Knie und schaute den wundervollen, bläulich
violetten Lichtreflex auf dem ungepuderten schwarzen Haar der
jungen Dame an, der direkt vom Himmel durch das Fenster auf sie
kam, bei jeder Pappel am Weg aufhüpfte, bei jeder Sonnenbiegung
mit Goldbraun tauschte und langsam unter dem puderfeinen
Straßenstaub erstickte.
In Molsheim fragte er den Postmeister, ob er über Schloß
Patmos etwas wisse.
„Wir nennen es anders,“ sagte der Postmeister mürrisch. Der
Herr von Landry war bei Bürger und Bauer gleich unbeliebt. Alles
Geld ging nach Paris, die Handhabung der Gerichte war von den

ärgsten Mißbräuchen begleitet, und die Bauern wurden von den
Pächtern auf das empörendste ausgesogen, denn Landry brauchte
entsetzlich viel Geld und kümmerte sich trotz seines weichen
Herzens ganz und gar nicht darum, woher es kam. Er wußte gar
nicht, daß Geld manchmal sehr schwer wog, Lebenskraft und Blut
bedeutete. Für ihn war der Louisdor eine Spielmarke.
Die Dame im Fond des Wagens blickte auf. „Ah, Sie wollen nach
Patmos?“
„Ja, Madame,“ sagte der gute Junge ängstlich, da er soeben für
den Postmeister eine Grobheit fertig hatte und nun nicht wußte,
wohin damit.
„Als Gast?“
„Ja, Madame.“
„Da sind wir Kameraden.“
„Sie auch, Madame?“ Und Johann Georg Freiherr von
Hirschbach übersetzte sich, seinen Namen und Titel ins Französische
und stellte sich vor.
„Ei, Herr Baron. Und Ihr Alter?“
„Vierundzwanzig.“
„Nur?“ sagte die schöne Dame bedauernd. „Ich bin schon
zwanzig. Ich habe auch schon sehr viel erlebt, denn ich bin Witwe.“
„Ach, gnädigste Frau,“ rief der gute Georg in vorwurfsvollem
Bedauern.
Sie erzählte kurz und ruhig ein wenig von ihrem Mann, der sehr
alt, sehr elegant und graziös gewesen war. Herr Vicomte de
Maintignon. Sie selbst heiße Dorette. Der Vicomte war stets leise
parfümiert, stets zärtlich, von immer gleich gelassener Heiterkeit,
zeigte es nie, wenn er krank war, liebte die Fröhlichkeit und sagte ihr
einmal sehr unvermittelt: „Mein Kind, lebe lang und amüsiere dich,“

neigte sich danach hinten in seinen Stuhl und starb lächelnd, die
letzte Prise Schnupftabak noch in der herabsinkenden Hand, welche
von den zierlichsten Manschetten umrahmt war, die man in jenem
Jahre trug.
Der junge Hirschbach stieß einen leisen Ruf der Hochachtung
vor solcher Kultur aus und meinte, daß er selbst sich wie ein Wilder
vorkäme. Die Dame lächelte und die weitere Fahrt ward sehr
angenehm, da der junge Thüringer sehr schnell seine Scheu verlor.
Es war das die Schuld ihrer Stimme; früher, beim Betrachten ihrer
klar geschwungenen Linien hatte er eine metallkühle, klavierharte
Altstimme von ihr erwartet. Aber nein. Ihr Organ war weich,
verdeckt und zutraulich; nicht hoch, aber warm.
Als zwei gute Freunde kamen sie in Patmos an und brachten
den Kammerdiener des leichtfertigen Grafen in siedend heiße
Verlegenheit. Es stand nämlich nur mehr ein Mansardenzimmer frei.
Die beiden unten im Flur hörten die Stimme des sorglosen
Landry auf dem Balkon über der Einfahrt, von dem er ihnen schon
entgegengewinkt hatte: „Aber dieses Mansardenzimmer hat ohnehin
zwei Betten!“
„Gewiß,“ zögerte der Kammerdiener, „jedoch Madame de
Maintignon und dieser junge Deutsche ...“
„Seht doch, sind sie nicht einen Tag lang in derselben
Postkutsche gefahren?“ fragte der Graf.
„Allerdings, aber —“
„Vor dem Auge der Natur sind Tag und Nacht gleich. Wir dürfen
hier in Patmos der Natur keine Schande machen.“
Von den beiden Leuten unten war eines tief dunkelrot
geworden, und das hieß Johann Georg. Er sah nach Dorette hinüber
und nach ihrem ruhigen Lächeln.

„Madame!“ flehte er.
Dorette zuckte die Achseln. „Man hat jetzt diese Sitte, natürlich
zu sein,“ sagte sie. „Ich, ich fürchte viel zu sehr, mich lächerlich zu
machen, und finde überdies nichts Arges an dem Gedanken des
Herrn von Landry. Hören Sie doch nur, daß man Kammerdiener sein
muß, um Einwendungen zu machen.“
In der Tat erklang nochmals die verschüchterte Stimme des
Dieners: „Ob aber die Dame einverstanden sein möchte?“
„Daß ihr beschränkten Tölpel auch gleich immer an das
Schlimmste denken müßt,“ rief Landry. „Geh hinunter und du wirst
sehen, daß sie sich als Leute von Welt gar nicht zieren werden.“
Wirklich machten weder die Dame noch der junge Baron aus
Deutschland eine Einwendung. Sie begrüßten bald danach den
Grafen, der sich mit der Abendtoilette etwas verspätet hatte, im
großen Salon und trafen ein Bürschlein von etwa zwölf Jahren bei
ihm, sorgfältig frisiert, gepudert, Hut und Degen auf einem Tisch
und ein aufgeschlagenes Buch vor sich. Es war ein außerehelicher
Sohn des Kardinals Rohan, den Landry bei sich hatte.
Da Madame de Maintignon an ihrem Reifrock einen Schaden
bemerkte, der beim Aussteigen durch Darauftreten eines
Hirschbachschen Stiefels entstanden war, stellte Landry seinen
Cousin dem jungen Deutschen zuerst vor.
Das kleine Herrlein machte eine Verbeugung, schlank, biegsam,
fein und weltmännisch zum Staunen. „Sie beehren mich zur besten
Stunde, mein Herr,“ hub er an, „da ich gerade des Tacitus Germania
las und Sie mir also Gelegenheit gewähren, Ihnen meine
Bewunderung für Ihre Vorfahren auszusprechen, und Ihren
Vorfahren meine größten und entzücktesten Komplimente über einen
Erben ihrer Tugenden zu machen, wie Sie es sind, mein Herr!“

Der gute Johann Georg stand wie vor einem Mirakel. Wenn ein
zwölfjähriger Knabe also mit ihm begann, wie würde er den
Erwachsenen antworten müssen? Dorette war es, die ihn durch eine
rasche Zwischenfrage des Stammelns und Suchens überhob.
Sie kam herbei und sagte freundlich: „Wie glücklich sind Sie,
mein Herr, die Gedanken der alten Klassiker Ihr eigen nennen zu
können. Darf ich fragen, welche von jenen bewundernswerten
Dichtern sich schon Ihr Herz zu gewinnen verstanden?“
„Seit Sie vor mir stehen, Madame,“ sagte der Knabe mit einer
reizend gespielten Verlegenheit und einem zärtlich schüchternen
Blick, „weiß ich mich an keinen mehr zu entsinnen; es — es müßte
denn Anakreon sein.“
Johann Georg machte, daß er davon kam. Er hatte eine
Heidenangst vor den Überirdischen dieses Schlosses bekommen, die
er noch kennen lernen würde.
Aber nein; es wurde reizend.
Johann Georg ward noch am selben Abend von den Damen
umdrängt wie ein reifes Obstbäumlein, und sie hätten ihm sehr heiß
gemacht, wenn nicht die großen Reifröcke gebieterisch einen weiten
Kreis bedingten, so oft nur vier oder fünf der reizenden Geschöpfe
sich um ihn gruppieren wollten.
Herr von Landry hatte ihn als Meister in der Natur vorgestellt,
und Johann Georg war überglücklich, den entzückten Schönen von
den Köhlern des Thüringer Waldes, vom Hörselberg und vom
Vogelfang mit Sprenkel und Dohne erzählen zu können. Alles war vor
solchen Neuigkeiten außer sich: Johann Georg kam aus einer
gänzlich andern Welt.
An diesem Abend standen herrlich getürmte Wolken fern über
den Auen des Rheins, und die verliebte Abschiedsglut des
Untergangshimmels jenseits vom Wasgau warf ihnen Rosen über

Rosen hinüber. Formvoll und massig standen sie, ein Gekröse von
Blaßblau, Veilchenhauch, Pfirsichblüte und zartem Fraise.
„Dort oben ist Traumburg und Schloß Glück. Dort wohnen die
Seelen aller Gefangenen, und um die Taubenschläge dieser
Luftschlösser fliegen als Vögel die Seufzer der Liebe, des Heimwehs
und der Freiheit.“ Hans Georg hatte es leise zu Demoiselle Eliante
gesagt und dabei sehnsuchtsvoll nach Madame Maintignon geblickt,
die heute Nacht mit ihm das Zimmer teilen würde. Aber die lebhafte
Eliante schlug einen silbernen Jubel auf, rief das ganze Schloß herbei
und erzählte ihnen, Wort für Wort, die wunderbaren Sätze des
wilden, schwermütigen Waldjungen, der sich für einsame Stunden
solchen Stil als eine Mischung von Shakespeare und Ossian
angewöhnt hatte.
Die schöne Heloise brach in Tränen aus, die stolze Amante mit
der stählernen Stimme rief „herrlich“, die zärtliche Céleste warf ihm
einen süßen, schmachtenden Blick zu, und Glycère, die leise
Zweideutige, flüsterte: „Ich gestatte Ihnen, Herr Baron, für dieses
entzückende Gedicht noch kühnere Träume, als dort oben in den
Wolken möglich sind.“
Frau Dorette neigte ganz reizend den hochfrisierten Kopf, der
jetzt blühweiß vor Puder wallte, und sah ihn links an und sah ihn
rechts an. Dem armen Jungen schwoll das Herz im Leib zu
unerträglicher Größe an.
Nach Mitternacht dann führte er seine Dame mit zitternden
Knien und würgender Kehle in ihr Gemach.
Dort sah es inzwischen seltsam aus. Mitten durch das Zimmer
war eine starke Kordel in Mannshöhe gespannt und daran hingen
Reifröcke: fünf Reifröcke, einer hart an dem andern. Sie bildeten
eine Mauer von sechs Fuß Dicke und waren undurchdringlich für
jeden Blick. Madame Dorette schlüpfte dahinter und sagte dann:

„Adieu, mein Freund. Erzählen Sie mir, bis ich eingeschlafen bin,
hübsche Geschichten, und sodann gute Nacht.“
Der arme Georg setzte sich auf sein Bett, zog die Strümpfe
herab und begann von Tannhäuser zu berichten, der im Venusberge
mehr schöne Dinge erlebte, als ihm angenehm war. Er hörte hinter
der Rockwand ein leises Schlürfen, ein Knistern von Seide, ein
Rascheln von Wäsche und das Knicken eines Bettes. Als er eben
Beziehungen zwischen dem glücklichen Sänger und seiner eignen,
unfruchtbaren Lage beginnen wollte, hörte er den leisen, schnellen
Atem der schönen Dorette. Sie war eingeschlafen.
Er zerwarf und zerwühlte noch lange Zeit sein Lager. Endlich
strafte er seinen bangen Durst, verehrte Dorettens Reinheit, verhielt
sich still, dachte, sie ist ein Engel; ich will ihrer würdig sein, und
schlief ein.
Am anderen Tage verzog er sich leise und schnell aus dem
Zimmer, um Dorette bei den heiligen, langen Stunden der Toilette
nicht zu stören. Im Garten weilte noch keine Seele, denn sie standen
im Schlosse vor zehn Uhr nicht auf. Da setzte er sich auf die wölbige
Rasenbank vor dem Bassin bei der arkadischen Tempelruine und
horchte dem Rieseln des Wasserfädchens zu, das aus der
moosgrünen Urne eines verliebten Götterpaares lief. Da seine
Nachtruhe kurz gewesen war, schlief er wieder ein und wurde erst
von dem verwunderten Gelächter eines ganzen Taubenflugs junger
Damen und Herren geweckt, die eine halbe Stunde vor Mittag den
schattigen Weg daherkamen.
„Reizend,“ sagte Landry. „Er hat recht, auch wir halten von
heute ab nach dem Frühstück eine Siesta im Grünen.“
Georg war sehr froh, daß sie ihn überrascht hatten. Wie, wenn
er etwa gar mit Dorette am Arm vor die Gesellschaft hintreten hätte
müssen? Nun hielten sie doch alle Dorette für seine Geliebte!

Aber kein Mensch schien sich viel um das kleine Ereignis zu
kümmern; kaum daß ihn die zweideutige Glycère mit einem leisen
Blitzlein unter seinen Augen prüfte. Der Deutsche erkannte bald, daß
es überhaupt nur Pärchen gab auf Schloß Patmos. Diese
behandelten sich zart und fein wie höfliche Fremde und nannten sich
mit solch milder Ruhe „Sie“ und „Freund“ und „Freundin“, daß nur
eine starke Neugierde vermocht hätte, hier mehr als bloße
Kameradschaft zu erkennen. Aber es schien niemand neugierig;
vielleicht, weil man genau wußte: Alles ist, wie ich bin.
Nur dieser Deutsche ahnte nicht, was die Mode über Menschen
vermag. Das Kind Shakespeares glaubte wahrlich selbst hier noch an
originale Charaktere und an Individualitäten!
Der heitere Landry nahm ihn ein wenig beiseite und ließ
Glycère, seine Freundin, mit der schönen Dorette in den Park
ausschwärmen. „Heute nachmittag ist ländliches Fest,“ sagte er zu
seinem Gast. „Besitzen Sie irgendein bukolisches Kostüm? Bauer,
Schäfer oder ähnliches?“
„Ich habe meine deutsche Jägertracht,“ gestand der junge
Baron zögernd.
Landry lachte. „Wo denken Sie hin, mein Freund? Ein Galarock,
das geht doch nicht!“
„Ach, da ist nichts von Frack und Parforcepeitsche dran,“
erklärte ihm Georg. „Sehen Sie, teurer Chevalier, die französische
Jagd, das ist die Jagd der Geselligkeit. Die deutsche Pirsch, das ist
die Jagd des einsamen Träumers. Wir sind gekleidet wie das
schattenleise, graue Wild, wie der tausendjährige Baumgreis, wie
der uralte Fels. Wir fühlen uns am geselligsten, wenn wir allein sind;
denn dann sind wir den stillen Geschwistern nahe; dem Busch und
dem Stein, dem kleinen Waldestümpel, diesem dunklen Auge der
träumenden Berghöhe, um das die scheuen, nächtigen Wildfährten
geschrieben sind, die wir lesen als die Schrift der Natur. Wir wissen

alles, von der leisen, huschenden Dämmerungsvogelliebe in den
Nächten Oculi und Lätare, bis zu den verschwiegenen Winternächten
des Fuchses, von der Erregung des Rehs bis zu dem wilden Aufschrei
des eifersüchtigen Hirsches. Wir hegen und pflegen diese Liebe und
töten nur zögernd, als Bevollmächtige des großen Zeugers und
Zerstörers allen Lebens. Bis in die Seele des Wildes schleichen wir, in
sein geheimstes Weben. So sind wir einsam und dennoch reich
gesellt.“
„Ach,“ rief der eifrige Landry, „das ist köstlich, das müssen Sie
uns lehren. Bitte, zeigen Sie mir doch jenes waldfarbene Kostüm!“
Der junge Hirschbach nahm seinen Wirt mit sich, und während
Landry schwermütig in den Anblick des Walles von aufgehängten
Reifröcken versank, hinter dem sein junger Freund so glücklich sein
mußte, packte der junge Deutsche sein graugrünes Jägerkleid aus.
„Wenn Sie gestatteten, daß ich mich darin sähe?“ bat Landry.
Lachend half ihm Georg beim Anlegen jener Stücke.
Landry war ein schöner Kerl, und das schlichte Grau und Grün
mit dem Federgesteck saß ihm keck und fein zugleich. Es ließ ihn
frischer und dennoch nachdenklicher erscheinen, und mit
unverhohlener Liebe besah sich der Chevalier in seiner Verkleidung
vor dem Spiegel. Dann ging er in den Park, um von seinen Gästen
lauten Jubel zu ernten. Er verkündete die entzückende Neuheit der
deutschen Jagd. „Denken Sie sich, meine Freundinnen, es gibt da
eine Methode, die heißt ‚der Anstand’. Diese werden wir üben, in den
Vogesen. Jeder von den Messieurs nimmt sich die Dame, der es
gefällig sein wird, und übt mit ihr in den stillen Hainen den Anstand.
Sie sehen,“ wandte er sich zu dem entsetzten Hirschbach, „welche
Reize wir Ihren Jagdmethoden abzugewinnen verstehen.“
„Aber so wird die Methode ganz erfolglos sein, ohne jede
Beute,“ rief Georg.

„Meinen Sie,“ lächelte Landry.
Der arme Junge errötete. „Ich meinte, vom Wilde werden wir
nichts sehen, noch hören,“ verbesserte er sich.
„Ach, das ist doch Sache der gemeinen Jägerei,“ tröstete der
Schloßherr.
So wurde entzückend viel Natur getrieben in den Waldhöhen
über Schloß Patmos. Landry selbst war unerschöpflich in neuen
Entdeckungen und sorgte eifrig, daß man dem lieblichen,
schuldlosen Urzustande, wie er sagte, möglichst nahe kam.
„Die Urnatur ist weder lieblich, noch schuldlos,“ seufzte Georg
bei solch einem Geplauder ernst; aber da kam er schön an. Herren
und Damen bewiesen ihm an der Hand Rousseaus, daß die
Kinderjahre der Menschheit in rührendster Eintracht und Reinheit
hingeflossen seien. „Sehen Sie doch unsere guten, demütigen,
redlichen und einfachen Bauern an,“ riefen sie ihm zu. „Wie sind sie
glücklich, wie naiv, zufrieden, fromm und dankbar!“
„Und wer wagt es, Ihnen das zu sagen?“ staunte der Deutsche,
der einzige von der ganzen Versammlung, der die Bauern
heimgesucht, beobachtet und ehrlich mit ihnen gesprochen hatte.
„Aber mein Gott, sie selber,“ hieß es.
Zum erstenmal fühlte sich der Deutsche nicht mehr klein und
bedeutungslos vor dieser leuchtenden Gesellschaft. Er schwieg und
dachte sich sein Teil.
Den Nachmittag verbrachte er mit Madame Dorette allein im
Walde. Sie verzagte vor jeder Wurzel und fürchtete jedes Bächlein.
Er mußte sie heben, stützen, tragen, und nur sehr langsam erlernten
die kleinen Füßlein auf ihren hohen Absätzen im weichen Grunde das
Gehen.

Sie hatte Angst; sie schalt, daß diese Natur ungefällig,
unverständlich, rauh, verschlossen und dornig sei wie ein Deutscher.
Nur wenn er sagte: „Aber Madame, sie ist jetzt modern,“ dann
seufzte sie, nahm sich glatt zusammen und sagte wieder
aufgerichtet: „Es ist wahr, Sie haben recht, lieber Baron.“
Als sie müde war, nahm er behutsam ihr Köpflein in seinen
Schoß und ließ sie da schlummern. Ach, er liebte sie schon ein
wenig. Aber seine scheue Art wagte keine Kühnheit.
Beim Schlafengehen war es wie gestern. Er berichtete von den
Tieren des Waldes und brachte sie mit der köstlichen Fabel von
Reineke Fuchs dreimal, viermal zum Lachen. Aber als er erzählte,
wie Reineke die Wölfin im Eise festfrieren und an der Wehrlosen
seine Liebe ausließ, da tat sie empört, obwohl sie hinter ihren
Reifröcken vor Lachen fast erstickte.
„So etwas konnte auch nur ein Deutscher erfinden,“ rief die
drollig zornige Stimme aus ihrem Versteck.
„Dorette,“ bat Georg.
„Ach, gehen Sie mir.“
„Dorette!“ flehte Georg.
Sie schwieg.
„Schönste Dorette!“
„Gut Nacht,“ sagte sie kurz. Bald darauf schlief sie, und der
aufgewühlte Junge atmete sich vor Verlangen nahezu die Brust in
Stücke.
Allen bekam die neue Mode der Natur in den nächsten Tagen
sehr gut, nur der Deutsche wurde blaß und übernächtig.
Landry glaubte ihn warnen zu müssen, sich mit Maß an der
Güte der Natur zu freuen, und Georg hätte beinahe vor Schmerz
aufgeschrien. Jedoch schwieg er und überlegte: Was hat nur diese

Dorette? Sie wußte, daß alle Welt sie für seine Geliebte hielt, und
wurde es nicht.
Er machte sie darauf aufmerksam, was man von ihnen beiden
dächte.
„Ach ja,“ lächelte sie, „aber man findet es äußerst nett, und ich
hatte nie etwas dagegen, für nett gehalten zu werden.“
„Man, man, man!“ rief er verzweifelt. „Das ist ein Wort, das ich
nur in Frankreich hörte und das mich tötet! Ich habe noch nie von
einem so unheimlichen Tyrannen und Dämon aller Welt gehört, wie
Ihr Begriff ‚man’ es ist.“
„Man schreit eine Dame auch nicht so an,“ sagte Dorette ruhig.
„Sie sind gar nicht mehr nett, mein Freund. Man erträgt alles mit
heiterer Gelassenheit; auch die Liebe. Man verbirgt es, wenn man
erregt ist, und schließlich tröstet man sich anderswo.“
„Der erste gute Gedanke, den dieses ‚man’ hat,“ fuhr Georg wild
heraus.
Und er begann der schwärmerischen, kleinen Heloise den Hof
zu machen. Aber wie ein Schatten glitt deren bisheriger Freund, der
kleine Vicomte Bareilles, zu der schönen Dorette hinüber. Er dachte,
Georg wolle tauschen, und war hierüber sehr zufrieden.
Nun hatte der arme Junge es obendrein mit der Eifersucht zu
tun.
Inzwischen lief die ganze Gesellschaft fröhlich weiter auf den
Fährten der Natur. Landry vergötterte seinen naiven Gast, dessen
seltsames Wesen er für feinste Berechnung und künstliche Mode
hielt.
„Ich bin so glücklich,“ gestand er ihm. „Sie reißen mich bis zu
den originellsten Entdeckungen und Erfindungen hin. Wir schmausen
und tafeln im Grünen, wir tanzen im Mondschein wie die Elfen ihres

maître Chequespire, wir leben gesellig wie die wilden Kaninchen.
Nach dem Mahle schlummern wir im Rauschen der Bäume und
Quellen und beenden unsere Verdauung im trauten Busch, zwischen
nickenden Wiesenhalmen und auf dem von Mohnblumen errötenden
Feldrain, bis in ihre letzten Konsequenzen. Es ist das meine
glücklichste Erfindung. Weiter kann man sie doch nicht treiben, die
Natur. Nicht wahr, Freund meiner Seele!?“
Zum ersten Male seit langen Tagen lachte Georg aus vollem
Herzen über die Bemühungen seines Wirtes, der Natur näher zu
kommen.
Und Landry lachte eitel, silbern und glücklich mit ihm.
Dann aber kamen trotz des Juli lange Regentage über Schloß
Patmos, und mit der Natur war es aus für alle, außer für den
einsamen Deutschen. Der stieg hinauf in die eintönig rauschenden
Bergwälder und schaute nach versiegtem Regen mit einer Seele voll
Brudergrüßen über die stille Landschaft, über Waldberge hinter
Waldbergen, aus deren Falten sich der geisterstille Wolkenrauch
erhob und langsam über die Fichtenhöhen hinstreifend rückkehrte zu
den ziehenden, grauen und weißen Geschwistern der Luft.
Da fragte er auch wohl bei den Bauern umher und fand nichts
vom „bon villageois“, von dem die lächelnden Damen schwärmten.
Finsterer Groll, abwartende Tücke, verhaltene Drohung, das war die
Stimmung gegen die Gesellschaft in Schloß Patmos. Dieselbe
schlichte, fast bürgerliche Kleidung, die dort unten Madame Dorette
über ihn die reizenden Achseln zucken machte, führte ihn hier näher
an das Geheimnis der Volksseele.
Furchtbares brütete da.
Er warnte oft seinen Gastherrn, warnte Dorette und die andern,
aber man schalt ihn: „Sie Geisterseher, Sie Mondbewohner, wollen

Sie nicht schweigen und mit aller Welt vergnügt sein, wie es sich
schickt?“
Da schwieg er, aber er ließ sich Zeitungen kommen. In dieser
ganzen Gegend von Straßburg bis Metz, bis Toul, Verdun und Nancy
umher gab es kein Dutzend Zeitungen. Wozu auch?
Wie hätte es Zeitungen geben sollen, wenn keine Ereignisse da
waren, sie zu füllen! Man amüsierte sich allerorten auf gleiche
Weise; das wußte jedermann ohnedas. Zwar war die
Nationalversammlung schon einberufen, und der Volkszorn begann
dumpf aufzugrollen. Aber solange die Revolution nur theoretisch
blieb, wurden die Journale sehr langweilig gefunden. Man wußte
ohnehin besser über Menschenrechte zu plaudern als darüber
geschrieben werden konnte.
Erst die abgeschlagenen Köpfe machten Zeitungen notwendig.
Und während der junge Hirschbach in tiefer Bewegung von der
Erstürmung der Bastille las, zupften die Damen in der Langeweile
der grauen Regentage Goldscharpie. Es war das ein beliebter
Zeitvertreib und zugleich eine angenehme Gelegenheit für junge
Mädchen, sich ein kleines Nadelgeld zu schaffen. Jeder Herr hatte
die Pflicht, alle Goldtressen von veralteten Garderobestücken letzter
und vorletzter Mode an die Freundin abzuliefern, und den ganzen
Tag über zerrten die kleinen Händchen an den feinen Golddrähten
und häuften ganze Hügel von der edlen, graulich gekräuselten
Metallwolle, aus der die hellgebliebenen Fädchen blitzten, wie feine
Kinderhaare.
Georgs Erzählung von der Erstürmung der Bastille erregte nur
lebhafte Genugtuung.
„Ach Gott,“ sagte Dorette, „nun endlich können diese Ärmsten
auch etwas modern werden, und den Wald und das Land genießen.“

Die schöne Heloise schluchzte vor Rührung, und die Herren
applaudierten vor Freude über die vielen erlösten Opfer der
Tyrannei.
Als ihnen dann Georg von den Aufständen der Bauern, von
erstürmten Schlössern, von Adelsmorden und rauchenden
Feudaltrümmern erzählte, meinten sie allesamt: „Gott, müssen die
es arg getrieben haben, daß sie den gutmütigen Landmann so
schwer zu reizen vermochten!“
„Und Sie, Chevalier,“ fragte Georg den guten Landry, „fürchten
Sie denn nichts?“
„Mein Gott, ich tat doch niemandem etwas,“ lächelte der
glänzende Seigneur beruhigt, „und überdies muß man mit den
Tugenden der Menschen rechnen.“
Als zu Paris die Menschenrechte verkündigt waren, gab man den
Bauern der Gegend ein prachtvolles Fest mit Feuerwerk und warf
nach dem Gelage Konfekt, Obst und Geld zum Fenster hinaus unter
das Volk.
Georg war nicht beim Bankett. Er beobachtete das Bauernzeug,
das sich um den Abfall der übermütigen Tafel balgte.
„So gut haben die's da oben,“ murrte der eine.
Und ein andrer summte: „Wir werden das alles bald besitzen.
Das Schloß ist nicht so fest wie die Bastille.“
Diese ganzen drei Wochen mußte der ärmste junge Baron in
einem Zimmer mit der blassen Dorette schlafen. Seine Hoffnung und
seine Verzweiflung stiegen und fielen in regelmäßigen Gezeiten; nur
seine Liebe wuchs beständig.
Dorette, die hatte gar wohl bemerkt, daß die zärtliche Heloise in
süß schmachtender Neigung zu dem hübschen Deutschen

entglommen sei und bangte ein wenig um ihren braven
Schlafkameraden, so hoch sie auch sonst auf ihn herabsah, als auf
das Kind einer minderwertigen Rasse. Nur Georg merkte nichts. An
einem milden, dampfenden Abende stand er mit Dorette und Heloise
an einem Fenster und hörte, wie auf den Dächern der Ställe ein
Kater inbrünstig um Liebe sang.
Das Mädchen, der Georg sehr gut gefiel, brach in Tränen aus.
„Was ist Ihnen nur, liebste Heloise?“ fragte der arme Hirschbach
bestürzt.
„Ach die Natur, diese Natur! Sie ist zu erschütternd,“ schluchzte
Heloise.
„Ja, die Natur,“ seufzte der junge Deutsche und sah mit dem
sanftesten Vorwurf die feine, kühle Dorette an. Der Kater sang
weiter, und Dorette lächelte.
Am Abend dann, als sie wieder hinter ihrer Festung von
Reifröcken zu Bette gegangen war, bat er innigst, sie in allen Ehren
besuchen zu dürfen.
„Da Sie mir das Wort eines Edelmanns verpfänden, nun denn,
kommen Sie, mein Freund.“
Dorette in ihren Kissen, den Arm auf dem Herzen, im milden Rot
der Ampel war schöner als je, und schluchzend fiel der arme Junge
vor ihrem Lager auf die Knie.
„Ach, Madame, ich liebe Sie derart, daß es mich verbrennt und
auffrißt; und Sie, Sie machen sich gar nichts aus mir. Sie sehen mich
wie einen Knaben an und darum, ja nur darum lassen Sie mich auch
hier sein. Was ist es, das Sie so kühl gegen mich sein läßt!?“
„Sie sind so unmodern, wenn Sie erlauben, daß ich eine so
schwere Sache ausspreche,“ seufzte Dorette und sah die Amoretten
und Schäfer auf dem Plafond an, die sich geradezu frei benahmen.

„Aber Landry ruft mich doch als neueste Mode aus.“
„Ja, das ist im Wald und auf der Flur. Aber im Salon, mein
Lieber! Diese drei Wochen Regen taten Ihnen sehr viel Schaden. Ich
hätte Sie fast ein wenig lieb gewonnen, weil es wirklich schien, als
seien Sie der Neueste des neuen Tages. Aber, mein Freund, Sie
tragen eine Kleidung wie ein tüchtiger Kaufmannssohn, — die
Locken sind nur lose gewickelt, das Haar zu schwach gepudert, und
Sie erfinden eine Sprache, als ob die Académie française sich seit
1750 umsonst bemüht hätte; — eine Sprache voll altertümlicher
Kraftworte, wie ein Musketier Ludwigs des Dreizehnten. Mein
Freund, das tut man nicht. Sie kompromittieren geradezu mich.“
„Soll ich Sie denn wirklich jenem Vicomte Bareilles überlassen
und mein Glück bei Heloise versuchen?“ verzweifelte Hirschbach.
Dorette stützte sich plötzlich auf den schönen Arm und sah ihn
tief und reizvoll an. „Wenn Sie es vermögen?“ sagte sie mit dunklem,
warmen Ton.
Nun warf der Ärmste alle Fassung von sich, drückte den heißen
Kopf, der voll tobender Gedanken war, gegen die Decke seiner
Freundin und begann haltlos und erbärmlich zu weinen.
Sein Schluchzen und sein Zucken durchrieselten Madame als ein
ungeheures Kompliment. Sie hatte einen Hauch, eine Ahnung von
Zärtlichkeit für diesen Jungen, und sein Schmerz tat ihr unendlich
wohl.
„Ah,“ sagte sie. „Hier dürfen Sie weinen. Hier dürfen Sie es, da
niemand Ihnen eine Fassungslosigkeit zu verzeihen hat.“
Und die feinnervige Frau fing mit allen Poren den süßen
Schmerz ihres jungen Freundes auf und trank ihn, endlos geöffnet,
in dürstender Schweigsamkeit. Sie zitterte leise vor rieselndem
Wohlsein, und es war ein narkotischer Zauber, köstlich wie kein
zweiter. Nie hatte ihr Liebe so gut getan, und sie ließ den Glühenden

und Fiebernden über sich weinen, bis leise Lähmung über beide
kam.
Halb in Zorn, halb in Hoffnung richtete sich Georg auf, als sie
ganz still blieb. Schlief sie oder verstellte sie sich? O, wenn sie sich
verstellte, dann war es ein Glück ohnegleichen. Angstvoll betrachtete
er ihre durchscheinenden Lider und die wundervollen Wimpern.
Zuckte sie nur einmal, so war sie wach.
Aber nein; Madame Dorette schlief. Süß und vertrauensvoll.
Da bettete er sich zu ihren Füßen wie ein Hund.
Am nächsten Morgen erlaubte sie ihm einen leisen, flüchtigen
Kuß, und das war alles. Auch durfte er nie mehr zu ihr kommen. Er
hatte sie das Gruseln gelehrt.
Nach dieser Lektion bemühte er sich, einen vollendeten Kavalier
aus sich zu machen. Als nach einigen Tagen die liebe Sonne wieder
so innig aus blauem Himmel lachte, als wäre sie froh, nun endlich
wieder das wunderliche grüne Erdensternlein zu küssen, da erschien
der Herr Baron Johann Georg von Hirschbach in gänzlich neuer
Verfassung auf dem Blumenparterre vor dem Schlosse. Er war
angetan wie des Königs feinster Hofmann und strahlte vor Seide
schöner als ein Nußhäher im Brautkleid. Gottes allerblaueste
Seidenstrümpfe, die himmelfarbigsten Culots und die
gelbbrokatenste Weste der ganzen Schöpfung umschlossen ihn; er
war frisiert wie ein Dauphin, und sein Frack warf nach allen Seiten
die stolzen Lichter verschwendungsjubelreicher Goldtressen.
Alle Damen brachen in ein entzücktes „Ah!“ aus, und Dorette
blieb lächelnd stehen und sah ihn an wie eine neue, allergnädigst
begrüßte Bekanntschaft.
Die kleine Heloise wäre beinahe abermals in Tränen
ausgebrochen. Zur Unzeit aber geriet Eliante, es war die mit dem
perlenden Lachen, auf eine reizende Idee. Kein Mensch wußte,

woher sie so schnell ihren Arbeitsbeutel hatte, aber sie wischte eilig
mit ihrer Schere hervor und trennte dem Herrn Baron die schönste
Tresse vom Rocksaum.
„Goldscharpie, Goldscharpie! Wie reizend!“ riefen alle jungen
Damen durcheinander und stürzten sich auf Hans Georg. Ihre
Reifröcke bogen sich aneinander und knickten, aber jede wollte die
erste sein. Wie ein Gnadentum von heilwütigen Pilgern, so ward er
am Kragen, an den Schultern, Schößen und Taschenklappen erfaßt
und begeistert hin und her gezerrt. Die kleinen Scheren knippten
behende, und in einem Hui war der Herr von Hirschbach tressenlos.
Wie ein Flug Vöglein um einen Bussard waren sie herangezwitschert
gekommen und wieder verflattert, — und kahl und gerupft stand der
gute Deutsche da.
Dorette hatte die Arme sinken lassen, als die reizenden
Freundinnen sich ihres Kameraden bemächtigten und hatte untätig
und lächelnd zugesehen. Nun bekam sie den ersten, verlegenen
Blick des Beraubten, der über die Gnade der jungen Damen sehr
glücklich schien. Lang schaute sie zu ihm hinüber mit willenlos
gesenkten Armen.
Dann sagte sie nach tiefem und langsamem Atemzug: „Es ist Ihr
Schicksal, mein Herr Baron, schlicht zu bleiben, in alle Ewigkeit.“
Und wahrlich, der Baron von Hirschbach blieb fortan schlicht
und gut. Er verehrte die klare Dorette, die vor aller Augen als seine
Geliebte galt, fortab so keusch und gefaßt und demütig, wie es
kaum ein deutscher Herr in den blumenreinen Tagen des Herrn
Walter Vogelweide vermocht hätte. Er bewachte ihren leichten,
leisen Atemzug, wenn sie schlief, und war in entlegenster
Waldeinsamkeit wie ein goldenes, zutrauliches Kind mit ihr.
Keine Bitte sagte er mehr und träumte auch keine. Sie war ihm
durch ihre verständigen Worte tief heilig geworden: „Es ist Ihr
Schicksal, schlicht zu bleiben.“

Die ganze Gesellschaft amüsierte sich also köstlich an ihrem
Naturburschen. Er aber, nachdem es ihm mißglückt war, einem
hochbegnadeten Adel die Augen für den trotzigen Blick der Bauern
und die Ohren für das unterirdische Volksgrollen zu öffnen,
versuchte ihnen die Schönheit der ewig jungen Wiese und des
ernsten, greisen Waldes, des seelenvoll bewegten Wassers und der
ambrosischen Wolken zu erschließen.
Aber es verstanden ihn fast nur Heloise und Dorette. Heloise
brach zumeist in Tränen aus, und Dorette schwieg lächelnd, aber
ihre kleine Seele wuchs und wurde ernst und nachdenklich.
Dann, an einem Herbsttage bekam der Chevalier Landry einen
sehr unerwarteten Brief.
Dieser Brief war von seiner Gattin aus Paris verfaßt, die dort,
zum eignen Amüsement und dem ihrer Freunde, zurückgeblieben
war. Herr von Landry hatte diese, seiner würdige Gattin seit der
Halsbandgeschichte der Königin, seit über drei Jahren also, nicht
gesehen!
Madame Landry schrieb, sie fürchte sehr, ihrem Herrn Gemahl
ein Geständnis zuflüstern zu müssen. Was Herr von Landry darüber
denke?
Herr von Landry sagte sich: Ei, wenn das Geständnis nur flüstert
und noch nicht selber schreit, dann ist alles gut, schmunzelte über
die Unvorsichtigkeit seiner Frau Gemahlin, setzte sich mit graziöser
Unbefangenheit an den Tisch und schrieb, ein Paladin der Galanterie
bis in die Fingerspitzen, folgenden Brief:
„Meine Teure! Ich freue mich unendlich, von Ihnen zu
vernehmen, daß die gütige Vorsehung endlich unsern Bund gesegnet
hat! Ich werde mir die Ehre nehmen, Ihnen, Madame, noch in diesen
Tagen meine Aufwartung zu machen in der Überzeugung, daß Sie

die Güte gehabt haben werden, mich zu solch richtiger Zeit von der
mir widerfahrenen Freude zu benachrichtigen, daß der künftige Erbe
des Namens Landry das Wappen dieser Familie an seinem Coupé
wird führen dürfen, ohne ein Lächeln zu erregen.
Beten wir zur Mutter Natur, Madame, daß es ein Sohn sei.
Tausend entzückte Grüße meinerseits. Bis dahin Ihr
ergebenster Diener
Jean Ch. de Landry.“
Und der Chevalier rüstete sich von neuem zur Abreise nach
Paris, indem er sich bei seinen Gästen entschuldigte, die neue Mode
der Menschenrechte dort zu studieren. Er versprach, sie
mitzubringen. Er bat seine Gäste, sich bis dahin gut zu unterhalten,
und empfahl Glycère inzwischen der Zärtlichkeit seines jungen
Freundes „'ans ioeurgue“, wie sämtliche Damen den Thüringer
nannten, da sie den Namen Hirschbach nicht aussprechen konnten.
Herr von Landry kam nicht mehr zurück. Man hatte ihn in Paris
erkannt, als einen der Mitwisser der Halsbandgeschichte in der
Wohnung seiner Frau eingefangen, und tat ihm der König nichts, so
köpften ihn die Jakobiner.
Er aber lächelte.
Es hieß, die Liebe zu seiner Gattin hätte ihn nach Paris
getrieben, und der Name Landry war der Zukunft gerettet.
In Patmos wartete man vergebens auf den Bringer origineller
Neuheiten. Statt seiner kamen unversehens die Bauern. Die brachten
noch ganz andere Überraschungen mit sich, als der delikate
Chevalier.
Es geschah solches mitten in einem Schäferspiel, das die
verwaisten Gäste arrangiert hatten, am Abend eines schönen

Septembertages, nachdem soeben für dreihundert Taler
bengalisches Licht verbrannt war.
Das Stück spielte im Freien, im Blumenparterre vor dem
Schlosse, und von der Terrasse sah die übrige Gesellschaft zu.
Dorette gab sehr überzeugend eine Prinzessin, die Perlenstaat
und Seidenrobe ablegt, um ihrem Schäfer in die Blumengefilde der
schuldlosen Natur zu folgen, wie es in den hübschen Versen hieß.
Der Herr von Bareilles gab den Schäfer wie aus Zucker und
Biskuit.
Hans Georg spielte den bösen Jägersmann, der des Schäfers
Hündlein erschossen hatte und die süßen Tauben des Myrtenhaines
bedrohte.
Heloise hinwiderum hatte diesen Jägersmann zärtlich zu
zähmen.
In der dichtverhangenen Laube, wo sich Dorette zum zweiten
Akt als Bauernmädchen umkleiden sollte, ertappte sie den Hans
Georg, der eben zwei Pistolen aus dem Dickicht hervorzog und zu
sich steckte.
„Haben Sie denn mit Ihrer Flinte noch nicht genug?“
„Leider nein,“ sagte ihr Freund wortkarg und ernst. „Wir werden
bald ein etwas wahrheitsgetreueres Spiel durchzumachen haben.“
Vom Schlosse her drang unbestimmter Lärm. Es war, als
trampelten zahlreiche Menschen durch die Korridore.
„Sie wollen sich doch nicht schießen!?“ schrie Dorette.
„Still,“ herrschte der Thüringer.
Im Schlosse wurden erregte Stimmen laut, dann Hilferufe.
Die Darsteller des Schäferspieles, die der Terrasse näher
standen, scharten sich zu einem Klumpen und schrien ihren

Windows Kernel Programming Second Edition Pavel Yosifovich

Weitere ähnliche Inhalte

Empfohlen (20)

Windows Kernel Programming Second Edition Pavel Yosifovich