BridgeHead

Nattiver C++-Zugriff auf Active Directory über ADWS, ohne .NET, ohne WCF, ohne HTTP-Stack.

BridgeHead ist eine statische C++20-Bibliothek, die den vollständigen Active Directory Web Services (ADWS)-Protokollstack direkt über TCP implementiert. Benannt nach dem AD-Bridgehead-Server, dem Gateway, durch den der Verzeichnisverkehr fließt, bietet es Ihrem C++-Code denselben Low-Level-Zugriff auf Port 9389, den PowerShells Get-ADUser und Get-ADComputer im Hintergrund verwenden.

Protokollstack

Die Transportschichten umschließen die darunterliegende Schicht über die gemeinsame bridgehead::transport::IByteStream-Schnittstelle. NbfseCodec ist ein Codec-Dienstprogramm, das von AdwsClient aufgerufen wird, um SOAP-Nachrichten vor und nach dem Framing zu kodieren/dekodieren:``` AdwsClient WS-Enumeration + WS-Transfer [MS-ADDM] ├── NbfseCodec .NET Binary Format for SOAP [MC-NBFSE] (encode/decode) └── NmfFramer .NET Message Framing [MC-NMF] (send/receive frames) └── NnsSession .NET NegotiateStream [MS-NNS] └── TcpSocket raw TCP/IP

Der Einstiegspunkt für Anwender ist `bridgehead::adws::AdwsClient`.

---

## Schnellstart

### Abfragen, alle Benutzer auflisten```cpp
#include "bridgehead/adws/AdwsClient.hpp"

// NTLM (works on any host)
auto client = bridgehead::adws::AdwsClient::EnumerationClient(
    "192.168.1.10",     // DC IP or hostname
    "DC01.corp.local",  // DC FQDN, used in NMF Via header and Kerberos SPN
    "CORP",             // NetBIOS domain name
    "Administrator",    // username
    "Passw0rd"          // password
);

// Kerberos (username hidden on the wire; requires DC reachable on port 88)
auto client = bridgehead::adws::AdwsClient::EnumerationClient(
    "192.168.1.10", "DC01.corp.local", "CORP",
    "Administrator", "Passw0rd",
    bridgehead::adws::AuthPackage::Kerberos
);

auto users = client.Query(
    "(objectClass=user)",
    {"sAMAccountName", "distinguishedName", "memberOf"}
);

for (auto& obj : users)
    std::cout << obj.FirstValue("sAMAccountName") << '\n';

Große Ergebnisdatensätze streamen```cpp

client.Enumerate( "(objectClass=computer)", {"dNSHostName", "operatingSystem"}, "", // empty = domain root base DN [](const bridgehead::adws::LdapObject& obj) { std::cout << obj.FirstValue("dNSHostName") << '\n'; return true; // return false to stop early (sends wsen:Release) } );

### Umfang und Paginierung```cpp
// OneLevel scope, 50 objects per Pull round-trip
client.Query(
    "(objectClass=user)",
    {"sAMAccountName"},
    "OU=Admins,DC=corp,DC=local",
    50,
    bridgehead::adws::SearchScope::OneLevel
);

Binäre Attribute, objectGUID, objectSid```cpp

auto objs = client.Query("(objectClass=user)", {"objectGUID", "objectSid"}); for (auto& obj : objs) { if (auto* b = obj.FirstBytes("objectGUID")) std::cout << bridgehead::adws::ParseGuid(b) << '\n'; // {XXXXXXXX-...} if (auto b = obj.FirstBytes("objectSid")) std::cout << bridgehead::adws::ParseSid(*b) << '\n'; // S-1-5-... }

### Sicherheitsdeskriptor-Dekodierung```cpp
#include "bridgehead/adws/SecurityDescriptor.hpp"

auto objs = client.Query("(objectClass=user)", {"nTSecurityDescriptor"});
if (auto* raw = objs[0].FirstBytes("nTSecurityDescriptor")) {
    auto sd = bridgehead::adws::ParseSecurityDescriptor(*raw);
    std::cout << "Owner: " << sd.ownerSid << '\n';
    for (auto& ace : sd.dacl.aces)
        std::cout << "  type=" << (int)ace.type
                  << " mask=0x" << std::hex << ace.mask
                  << " sid="   << ace.sid << '\n';
}

Attribute schreiben (Ressourcen-Endpunkt)```cpp

auto rc = bridgehead::adws::AdwsClient::ResourceClient( "192.168.1.10", "DC01.corp.local", "CORP", "Administrator", "Passw0rd");

// Modify attributes rc.Put("CN=Alice,OU=Users,DC=corp,DC=local", { {"description", {"managed by bridgehead"}}, {"telephoneNumber", {"555-1234"}}, });

// Clear an attribute (both values and bytes empty = delete) rc.Put("CN=Alice,OU=Users,DC=corp,DC=local", { {"telephoneNumber", {}}, });

// Read back auto obj = rc.Get("CN=Alice,OU=Users,DC=corp,DC=local", {"description", "telephoneNumber"});

// Delete object rc.Delete("CN=TempUser,OU=Users,DC=corp,DC=local");

### LDAP modify types, Add / Replace / Delete

`Put` defaults to `Replace` (überschreibt alle vorhandenen Werte). Verwenden Sie `ModifyOperation` für eine feingranulare Kontrolle über mehrwertige Attribute:```cpp
using bridgehead::adws::LdapModification;
using bridgehead::adws::ModifyOperation;

rc.Put("CN=Alice,OU=Users,DC=corp,DC=local", {
    // Append a value to an existing multi-valued attribute
    LdapModification{"otherTelephone", {"555-9999"}, {}, ModifyOperation::Add},

    // Remove one specific value (leave others intact)
    LdapModification{"otherTelephone", {"555-0000"}, {}, ModifyOperation::Delete},

    // Replace is the default, explicit here for clarity
    LdapModification{"description", {"updated"}, {}, ModifyOperation::Replace},
});

Verschieben / Umbenennen```cpp

// Move to a different OU rc.Move( "CN=Alice,OU=OldOU,DC=corp,DC=local", // current DN "CN=Alice,OU=NewOU,DC=corp,DC=local" // new DN );

// Rename in place (same parent, new CN) rc.Move( "CN=Alice,OU=Users,DC=corp,DC=local", "CN=AliceSmith,OU=Users,DC=corp,DC=local" );

### Binäre Attribute schreiben

Geben Sie binäre Werte im Feld `bytes` von `LdapModification` an. Sie werden automatisch auf der Verbindung base64-kodiert:```cpp
std::vector<uint8_t> thumbnail = loadFile("photo.jpg");

rc.Put("CN=Alice,OU=Users,DC=corp,DC=local", {
    LdapModification{"thumbnailPhoto", {}, {thumbnail}},
});

Objekte erstellen (ResourceFactory endpoint)```cpp

auto rf = bridgehead::adws::AdwsClient::ResourceFactoryClient( "192.168.1.10", "DC01.corp.local", "CORP", "Administrator", "Passw0rd");

rf.Create( "CN=NewUser,OU=Users,DC=corp,DC=local", "user", {{"sAMAccountName", {"newuser"}}, {"userAccountControl", {"512"}}} );

### Asynchrone Operationen```cpp
#include "bridgehead/adws/AdwsClientAsync.hpp"

auto ac = bridgehead::adws::AdwsClientAsync::EnumerationClient(
    "192.168.1.10", "DC01.corp.local", "CORP", "Administrator", "Passw0rd");

auto future = ac.QueryAsync("(objectClass=user)", {"sAMAccountName"});

// ... do other work while the query runs ...

auto users = future.get();  // blocks until complete; re-throws any exception

Zeitüberschreitung bei einem langsamen DC:```cpp if (future.wait_for(std::chrono::seconds(5)) == std::future_status::timeout) { // query is still running }

Alle Operationen haben asynchrone Varianten: `QueryAsync`, `EnumerateAsync`, `GetAsync`, `PutAsync`, `DeleteAsync`, `CreateAsync`, `MoveAsync`.

### Verbindungspool (Hochfrequente / Multi-Thread-Arbeitslasten)```cpp
#include "bridgehead/adws/AdwsClientPool.hpp"

// Enumeration pool, Query / Enumerate
bridgehead::adws::AdwsClientPool pool({
    .host = "192.168.1.10", .fqdn = "DC01.corp.local",
    .domain = "CORP", .username = "Administrator", .password = "Passw0rd",
    .maxSize = 4,   // up to 4 concurrent authenticated sessions
});

auto users = pool.Query("(objectClass=user)", {"sAMAccountName"});

// Resource pool, Get / Put / Delete
bridgehead::adws::AdwsClientPool resPool({
    .host = "192.168.1.10", .fqdn = "DC01.corp.local",
    .domain = "CORP", .username = "Administrator", .password = "Passw0rd",
    .maxSize = 4,
    .endpoint = bridgehead::adws::PoolEndpoint::Resource,
});
auto obj = resPool.Get("CN=Alice,OU=Users,DC=corp,DC=local", {"mail"});
resPool.Put("CN=Alice,OU=Users,DC=corp,DC=local", {{"mail", {"[email protected]"}}});

// ResourceFactory pool, Create
bridgehead::adws::AdwsClientPool rfPool({
    .host = "192.168.1.10", .fqdn = "DC01.corp.local",
    .domain = "CORP", .username = "Administrator", .password = "Passw0rd",
    .endpoint = bridgehead::adws::PoolEndpoint::ResourceFactory,
});
rfPool.Create("CN=NewUser,OU=Users,DC=corp,DC=local", "user",
              {{"sAMAccountName", {"newuser"}}});

API-Referenz

Alle öffentlichen Header befinden sich unter include/bridgehead/. Die vollständige API-Dokumentation kann mit Doxygen generiert werden (siehe Build).

`bridgehead::adws::AdwsClient`

`bridgehead::adws::AdwsClientAsync`

Asynchroner Wrapper auf Basis von std::future. Gleiche Factory-Methoden wie AdwsClient; jede Operation gibt ein std::future<T> zurück.```cpp std::future<std::vector> f = ac.QueryAsync(...); std::future e = ac.EnumerateAsync(filter, attrs, baseDN, callback); std::future g = ac.GetAsync(...); std::future h = ac.PutAsync(...); std::future i = ac.DeleteAsync(...); std::future j = ac.CreateAsync(...); std::future k = ac.MoveAsync(...);

Für gleichzeitige Abfragen über mehrere Verbindungen hinweg verwenden Sie `AdwsClientPool`.

### `bridgehead::adws::AdwsClientPool`

Thread-sicherer Pool von vorauthentifizierten Sitzungen. Verbindungen werden verzögert erstellt und über Aufrufe hinweg wiederverwendet.```cpp
pool.IdleCount();   // sessions currently idle
pool.TotalCount();  // idle + checked-out
pool.MaxSize();     // configured maximum pool size
pool.Move(dn, newDn);  // Move/rename (Resource pool)

`bridgehead::adws::SearchScope````cpp

enum class SearchScope { Base, OneLevel, Subtree /default/ };

### `bridgehead::adws::LdapObject` / `LdapAttribute````cpp
struct LdapAttribute {
    std::string name;
    std::string syntax;                         // LdapSyntax OID, empty if absent
    std::vector<std::string>          values;   // text values (raw base64 for binary)
    std::vector<std::vector<uint8_t>> bytes;    // decoded binary; parallel to values
};

struct LdapObject {
    std::vector<LdapAttribute>  attributes;                          // all returned attributes
    const LdapAttribute*        Find(const std::string& name) const;  // case-insensitive
    std::string                 FirstValue(const std::string& name) const;
    const std::vector<uint8_t>* FirstBytes(const std::string& name) const;
};

Binäre Helfer```cpp

std::string ParseGuid(const std::vector<uint8_t>& bytes); // → "{XXXXXXXX-XXXX-...}" std::string ParseSid (const std::vector<uint8_t>& bytes); // → "S-1-5-..."

### `FilterValue` und Filter-Builder-Hilfsfunktionen

`FilterValue` ist ein typsicherer Wrapper, der beim Aufbau RFC 4515 §3-Metazeichen (`\`, `*`, `(`, `)`, NUL) escaped. Verwenden Sie es mit den Builder-Hilfsfunktionen, um LDAP-Injection strukturell unmöglich zu machen:```cpp
// UNSAFE, raw string concatenation, easy to forget escaping
client.Query("(sAMAccountName=" + username + ")", ...);

// SAFE, FilterValue escapes on construction; FilterEq composes the assertion
FilterValue user = username;
client.Query(FilterEq("sAMAccountName", user), ...);

// Compose complex filters
client.Query(
    FilterAnd({
        FilterEq("objectClass", FilterValue::Raw("user")),  // Raw() for safe literals
        FilterOr({
            FilterEq("sAMAccountName", user),
            FilterEq("mail", FilterValue(email)),
        }),
        FilterNot(FilterPresent("userAccountControl")),
    }), {"sAMAccountName", "mail"}
);

EscapeLdapFilter(str) ist weiterhin als grundlegendes Primitiv verfügbar, wenn Sie Filterzeichenfolgen manuell erstellen müssen.

`DnValue` und DN-Builder-Hilfsfunktionen

Gleiches Muster wie FilterValue, aber für Distinguished-Name-RDN-Werte (RFC 4514 §2.4). Maskiert ,, +, ", \, <, >, ;, NUL und führende/nachfolgende # und Leerzeichen:```cpp // UNSAFE, comma injection breaks the DN structure rc.Get("CN=" + username + ",OU=Users,DC=corp,DC=local", attrs);

// SAFE DnValue cn = username; // auto-escaped auto dn = BuildDn({DnAttr("CN", cn), "OU=Users", "DC=corp", "DC=local"}); rc.Get(dn, attrs);

// DnValue::Raw() for values you control auto dn2 = BuildDn({DnAttr("CN", DnValue::Raw("Service Account")), "OU=SvcAccounts", "DC=corp", "DC=local"});

### `bridgehead::adws::SecurityDescriptor````cpp
SecurityDescriptor ParseSecurityDescriptor(const std::vector<uint8_t>& bytes);

struct SecurityDescriptor {
    uint16_t    control;       // SdControl::* flags
    std::string ownerSid;
    std::string groupSid;
    bool hasDacl; Acl dacl;
    bool hasSacl; Acl sacl;
};
struct Acl { std::vector<Ace> aces; };
struct Ace {
    uint8_t     type;                  // AceType::*
    uint8_t     flags;                 // AceFlags::*
    uint32_t    mask;
    std::string sid;
    std::string objectType;            // GUID string, object ACEs only
    std::string inheritedObjectType;   // GUID string, object ACEs only
};

Konstante Namensbereiche: AceType::*, AceFlags::*, SdControl::*.

`bridgehead::ConnectionError` / `AuthenticationError` / `ProtocolError`

Definiert in include/bridgehead/Exceptions.hpp (transitiv eingeschlossen durch AdwsClient.hpp). Alle drei erweitern std::runtime_error:

Typ	Wird geworfen, wenn
`ConnectionError`	TCP-Level-Fehler: abgelehnt, Timeout, E/A-Fehler
`AuthenticationError`	NTLM/Kerberos-Aushandlung fehlgeschlagen
`ProtocolError`	Fehlerhafte Serverantwort auf einer beliebigen Protokollebene

auto client = bridgehead::adws::AdwsClient::EnumerationClient(...);
auto users  = client.Query(...);

} catch (const bridgehead::ConnectionError& e) { // unreachable DC, wrong port, timeout } catch (const bridgehead::AuthenticationError& e) { // bad credentials, KDC unreachable } catch (const bridgehead::ProtocolError& e) { // unexpected server response } catch (const bridgehead::adws::SoapFault& e) { // DC returned a SOAP fault (e.g. invalid filter) } // or coarse-grained: // } catch (const std::runtime_error& e) { ... }

### `bridgehead::adws::SoapFault`

Wird bei jeder `s:Fault`-Antwort des DC anstelle eines einfachen `std::runtime_error` ausgelöst:```cpp
struct SoapFault : std::runtime_error {
    std::string code;     // e.g. "Sender"
    std::string subcode;  // e.g. "InvalidEnumerationContext", empty if absent
    std::string reason;   // human-readable text
};

`bridgehead::adws::LdapModification`

Verwendet von Put und Create:```cpp enum class ModifyOperation { Replace /default/, Add, Delete };

struct LdapModification { std::string name; std::vectorstd::string values; // text values std::vector<std::vector<uint8_t>> bytes; // binary values (base64-encoded on the wire) ModifyOperation operation = ModifyOperation::Replace; };

Wenn sowohl `values` als auch `bytes` leer sind, wird das Attribut unabhängig von `operation` gelöscht/entfernt.

### `bridgehead::adws::ProtocolLimits`

Optionaler letzter Parameter für alle Factory-Methoden, `AdwsClientAsync`-Factories und `AdwsClientPool::Config::limits`. Alle Felder haben sichere Standardwerte; ändern Sie sie nur, wenn Sie spezifische Anforderungen haben:```cpp
struct ProtocolLimits {
    uint32_t nmfMaxFrameBytes   = 64 * 1024 * 1024;  // max NMF frame (default 64 MiB)
    uint32_t nnsMaxPayloadBytes = 16 * 1024 * 1024;  // max NNS packet (default 16 MB)
    int tcpKeepaliveIdleSec     = 60;   // idle seconds before first probe
    int tcpKeepaliveIntervalSec = 10;   // seconds between probes
    int tcpKeepaliveProbeCount  = 5;    // probes before declaring dead (POSIX only)
};

Erhöhen Sie nmfMaxFrameBytes / nnsMaxPayloadBytes nur, wenn Sie Objekte mit ungewöhnlich großen binären Attributen lesen (z.B. nTSecurityDescriptor mit vielen ACEs oder großem thumbnailPhoto). Verringern Sie die Keepalive-Felder in Cloud-/NAT-Umgebungen, in denen inaktive Verbindungen aggressiv getrennt werden.

Benannte Konstruktor-Helfer (inline statische Fabriken):```cpp LdapModification::Replace(name, values) // Replace with text values (default) LdapModification::ReplaceBinary(name, bytes) // Replace with binary values LdapModification::Append(name, values) // Add to multi-valued attribute LdapModification::Remove(name, values={}) // Remove specific values (or all) LdapModification::Clear(name) // Delete the attribute entirely

## Erstellen

**Anforderungen:** CMake 3.25+ und einen C++20-fähigen Compiler (MSVC 2022+, GCC 12+, Clang 15+).```bash
# Configure and build (unit tests only, no live AD needed)
cmake -B build -A x64
cmake --build build --config Release

# Run unit tests
ctest --test-dir build -C Release --output-on-failure

# With integration tests (requires a live Domain Controller)
cmake -B build -A x64 -DBRIDGEHEAD_INTEGRATION_TESTS=ON
cmake --build build --config Release
./build/tests/Release/bridgehead_integration_tests.exe

# With CLI tool (adws_list, browse AD objects from the command line)
cmake -B build -A x64 -DBRIDGEHEAD_BUILD_TOOLS=ON
cmake --build build --config Release --target adws_list
./build/tools/Release/adws_list.exe --host <dc-ip> --fqdn <dc-fqdn> --domain <domain> --user <user>

# Generate API reference docs (requires Doxygen)
cmake --build build --target docs
# or directly:
doxygen Doxyfile
# Output: docs/doxygen/html/index.html

CMake options

Integration

Option A, CMake-Unterverzeichnis (keine Installation erforderlich)```cmake

add_subdirectory(bridgehead) target_link_libraries(my_target PRIVATE bridgehead::bridgehead)

### Option B, installiertes Paket (`find_package`)```bash
cmake --install build --prefix /usr/local   # or any install prefix

Please provide the Markdown content to translate.```cmake find_package(bridgehead REQUIRED) target_link_libraries(my_target PRIVATE bridgehead::bridgehead)

`pugixml`, `ws2_32` und `secur32` (Windows) / `gssapi_krb5` (Linux/macOS) werden alle transitiv eingebunden.

---

## Plattformunterstützung

| Platform | Authentifizierungs-Backend | Status |
|----------|-------------|--------|
| Windows | SSPI (`secur32.dll`), NTLM und Kerberos | **Funktioniert** |
| Linux / macOS | GSSAPI (`libgssapi_krb5`), SPNEGO / Kerberos | Kompiliert; noch nicht integriert getestet |

Sowohl `AuthPackage::Ntlm` als auch `AuthPackage::Kerberos` funktionieren unter Windows. Kerberos verbirgt den Benutzernamen auf der Leitung und wird in der Produktion bevorzugt; NTLM ist der Fallback, wenn der KDC (Port 88) nicht erreichbar ist.

Unter Linux/macOS verwendet das GSSAPI-Backend SPNEGO mit Kerberos. Installieren Sie für NTLM-Unterstützung das Plugin `gss-ntlmssp`:```bash
apt install libgss-ntlmssp   # Debian / Ubuntu
dnf install gssntlmssp       # Fedora / RHEL

Ohne das Plugin wird der Server Kerberos aushandeln. Explizite Benutzer-/Passwort-Anmeldeinformationen verwenden gss_acquire_cred_with_password (MIT Kerberos 1.9+); leere Zeichenfolgen übergeben, um den Standard-Anmeldeinformations-Cache (kinit) zu verwenden. Der GSSAPI-Pfad lässt sich sauber kompilieren und ist von Natur aus korrekt, wurde aber noch nicht Ende-zu-Ende gegen einen Live-DC validiert; betrachten Sie die Linux/macOS-Unterstützung als Beta.

Hinweis zur Verschlüsselung: ADWS auf Port 9389 wird auf der NNS-Ebene verschlüsselt (NTLM-Sitzungsschlüssel oder Kerberos AES-256), nicht TLS. Dies ist beabsichtigt, der DC bietet auf diesem Port kein TLS an. Falls eine zertifikatbasierte Serverauthentifizierung erforderlich ist, ist LDAPS (Port 636) die Alternative.

Abhängigkeiten

Werden zur Konfigurationszeit automatisch über cmake/Dependencies.cmake abgerufen, keine manuelle Installation erforderlich:

Bibliothek	Version	Zweck
Catch2	v3.5.2	Unit-Test-Framework (nur Testziele)
pugixml	v1.14	XML DOM (nur ADWS-Antwort-Parsing)

Kein OpenSSL. Kein Asio. Kein Boost.

Bekannte Einschränkungen

NTLM unter Linux/macOS erfordert das gss-ntlmssp GSSAPI-Plugin (siehe Plattformunterstützung). Ohne dieses verhandelt der Server stattdessen Kerberos. NTLM unter Windows funktioniert nativ über SSPI.
pugixml DOM, jede SOAP-Antwort wird vollständig in einen XML-Baum im Speicher geparst, bevor Ergebnisse zurückgegeben werden. Dies wird durch die Seitengröße maxElements (Standard 256 Objekte pro Pull) begrenzt, sodass der gesamte Ergebnissatz nie gleichzeitig im Speicher gehalten wird. Der Speicher wird nur bei sehr großen Seitengrößen oder Objekten mit großen binären Attributen (z.B. nTSecurityDescriptor bei Objekten mit vielen ACEs) zum Problem. Ein SAX/Streaming-Ansatz würde dies vermeiden, ist aber derzeit nicht geplant.

Protokollreferenzen

[MS-ADDM], Active Directory Web Services: Datenmodell und gemeinsame Elemente
[MS-NNS], .NET NegotiateStream Protocol
[MC-NMF], .NET Message Framing
[MC-NBFSE], .NET Binary Format: SOAP Extension
[MS-DTYP], Windows-Datentypen (SECURITY_DESCRIPTOR, ACL, ACE, SID, GUID)
[MS-ADTS], Active Directory Technische Spezifikation (LDAP-Filter / Attribute)

Alle Spezifikationen sind in der Microsoft Open Specifications-Dokumentation verfügbar.

Besonderer Dank

Besonderer Dank gilt IBM X-Force und dem SoaPy-Projekt für ihre Inspiration, Forschung und öffentlich geteilte Arbeit, die zu diesem Projekt beigetragen haben. Ich möchte auch Logan Goins, den Schöpfer von SoaPy bei IBM X-Force Red, für die Mühe und Einsicht würdigen, die diese Arbeit ermöglicht haben.

Lizenz

Siehe LICENSE für Details.

`EnumerationClient(host, fqdn, domain, user, pass [, auth, timeoutMs, opTimeoutMs, limits])`	`/Enumeration`	Factory, verbinden und authentifizieren
`ResourceClient(...)`	`/Resource`	Factory für Get / Put / Delete / Move
`ResourceFactoryClient(...)`	`/ResourceFactory`	Factory für Create
`Query(filter, attrs [, baseDN, maxElems, scope])`	Enumeration	Alle Ergebnisse in einen Vektor sammeln
`Enumerate(filter, attrs, baseDN, callback [, maxElems, scope])`	Enumeration	Ergebnisse per Callback streamen
`Get(dn, attrs)`	Resource	Attribute eines einzelnen Objekts lesen
`Put(dn, modifications)`	Resource	Attribute ändern
`Delete(dn)`	Resource	Objekt löschen
`Create(dn, objectClass, attrs)`	ResourceFactory	Neues Objekt erstellen
`Move(dn, newDn)`	Resource	Vorhandenes Objekt verschieben oder umbenennen

`BRIDGEHEAD_BUILD_TESTS`	`ON`	Baue die Unit-Test-Suite
`BRIDGEHEAD_INTEGRATION_TESTS`	`OFF`	Baue Integrationstests (erfordert einen live DC)
`BRIDGEHEAD_BUILD_TOOLS`	`OFF`	Baue das `adws_list` CLI-Tool

BridgeHead

Beliebteste

BridgeHead

Inhaltsverzeichnis

Protokollstack

Große Ergebnisdatensätze streamen```cpp

Binäre Attribute, objectGUID, objectSid```cpp

Attribute schreiben (Ressourcen-Endpunkt)```cpp

Verschieben / Umbenennen```cpp

Objekte erstellen (ResourceFactory endpoint)```cpp

API-Referenz

bridgehead::adws::AdwsClient

bridgehead::adws::AdwsClientAsync

`bridgehead::adws::SearchScope````cpp

Binäre Helfer```cpp

DnValue und DN-Builder-Hilfsfunktionen

bridgehead::ConnectionError / AuthenticationError / ProtocolError

bridgehead::adws::LdapModification

CMake options

Integration

Option A, CMake-Unterverzeichnis (keine Installation erforderlich)```cmake

Abhängigkeiten

Bekannte Einschränkungen

Protokollreferenzen

Besonderer Dank

Lizenz

`bridgehead::adws::AdwsClient`

`bridgehead::adws::AdwsClientAsync`

`DnValue` und DN-Builder-Hilfsfunktionen

`bridgehead::ConnectionError` / `AuthenticationError` / `ProtocolError`

`bridgehead::adws::LdapModification`