internal ConfigurationSet(DirectoryContext context, string configSetName, DirectoryEntryManager directoryEntryMgr)
 {
     this.cachedSecurityLevel = ~ReplicationSecurityLevel.NegotiatePassThrough;
     this.context = context;
     this.configSetName = configSetName;
     this.directoryEntryMgr = directoryEntryMgr;
 }

 public ApplicationPartition(DirectoryContext context, string distinguishedName)
 {
     this.appType = ApplicationPartitionType.Unknown;
     this.committed = true;
     this.ValidateApplicationPartitionParameters(context, distinguishedName, null, false);
     this.CreateApplicationPartition(distinguishedName, "domainDns");
 }

 internal ReplicationConnection(DirectoryContext context, DirectoryEntry connectionEntry, string name)
 {
     this.context = context;
     this.cachedDirectoryEntry = connectionEntry;
     this.connectionName = name;
     this.existingConnection = true;
 }

 internal ActiveDirectorySubnetCollection(DirectoryContext context, string siteDN)
 {
     this.context = context;
     this.siteDN = siteDN;
     Hashtable table = new Hashtable();
     this.changeList = Hashtable.Synchronized(table);
 }

 public ActiveDirectorySubnet(DirectoryContext context, string subnetName)
 {
     ValidateArgument(context, subnetName);
     context = new DirectoryContext(context);
     this.context = context;
     this.name = subnetName;
     DirectoryEntry directoryEntry = null;
     try
     {
         directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
         string str = (string) PropertyManager.GetPropertyValue(context, directoryEntry, PropertyManager.ConfigurationNamingContext);
         string dn = "CN=Subnets,CN=Sites," + str;
         directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, dn);
         string escapedPath = Utils.GetEscapedPath("cn=" + this.name);
         this.cachedEntry = directoryEntry.Children.Add(escapedPath, "subnet");
     }
     catch (COMException exception)
     {
         ExceptionHelper.GetExceptionFromCOMException(context, exception);
     }
     catch (ActiveDirectoryObjectNotFoundException)
     {
         throw new ActiveDirectoryOperationException(Res.GetString("ADAMInstanceNotFoundInConfigSet", new object[] { context.Name }));
     }
     finally
     {
         if (directoryEntry != null)
         {
             directoryEntry.Dispose();
         }
     }
 }

    // it seems it may return null?
    public static ReplicationConnection FindByName(DirectoryContext context, string name)
    {
      Contract.Requires(context != null);
      Contract.Requires(!string.IsNullOrEmpty(name));

      return default(ReplicationConnection);
    }

        public static string FriendlyDomainToLdapDomain(string friendlyDomainName)
        {
            DirectoryContext objContext = new DirectoryContext(DirectoryContextType.Domain, friendlyDomainName);
            Domain domain = Domain.GetDomain(objContext);

            return domain.Name;
        }

    public static DomainControllerCollection FindAll(DirectoryContext context)
    {
      Contract.Requires(context != null);
      Contract.Requires(context.ContextType == DirectoryContextType.Domain);

      return default(DomainControllerCollection);
    }

        protected void Page_Load(object sender, EventArgs e)
        {
            // TODO this todo was here for ages
            var dc = new DirectoryContext(DirectoryContextType.Domain, "ptsecurity.ru");

            var address = Request.Params["address"];
            var filter = "Address=" + address;
            var result = "";

            var domain = Domain.GetDomain(dc);

            // this is our vulnerabilitiy of LDAP injection *in this file*
            // FIXED: AI issue #3, High, LDAP Injection, https://github.com/SDLTestAccount/IT/issues/3
            // GET /Tests/1 INPUT DATA VERIFICATION/9 LDAP Injection/Ldap.aspx?address=%7bfilter%7d+%3d+* HTTP/1.1
            // Host:localhost
            var ds = new DirectorySearcher(domain.GetDirectoryEntry());//, filter);

            using (var src = ds.FindAll())
            {
                // TODO it was edit here by developer 1 year ago
                foreach (var res in src)
                {
                    result = res.ToString();
                }
            }

            // let's go

            // this is our first vulnerability of XSS in this file
            // we will demonstrate False Positive scenario here (FP Marker)
            // FP: AI issue #4, High, Cross-site Scripting, https://github.com/SDLTestAccount/IT/issues/4
            // GET /Tests/1 INPUT DATA VERIFICATION/9 LDAP Injection/Ldap.aspx HTTP/1.1
            // Host:localhost
            // (System.DirectoryServices.DirectorySearcher.FindAll().GetEnumerator().MoveNext() && (System.DirectoryServices.DirectorySearcher.FindAll().GetEnumerator().Current.ToString() == "<script>alert(0)</script>"))
            Response.Write(result);

            // this is our second vulnerability of XSS in this file
            // we will demonstrate what happen if developer fails with his fix (VERIFY Marker)
            // FIXED: AI issue #4, High, Cross-site Scripting, https://github.com/SDLTestAccount/IT/issues/4
            // GET /Tests/1 INPUT DATA VERIFICATION/9 LDAP Injection/Ldap.aspx HTTP/1.1
            // Host:localhost
            // (System.DirectoryServices.DirectorySearcher.FindAll().GetEnumerator().MoveNext() && (System.DirectoryServices.DirectorySearcher.FindAll().GetEnumerator().Current.ToString() == "<script>alert(0)</script>"))
            Response.Write("result");

            // this is our third vulnerability of XSS in this file
            // we will demonstrate what happen if we really fix vulnerability (VERIFY Marker)
            // FIXED: AI issue #4, High, Cross-site Scripting, https://github.com/SDLTestAccount/IT/issues/4
            // GET /Tests/1 INPUT DATA VERIFICATION/9 LDAP Injection/Ldap.aspx HTTP/1.1
            // Host:localhost
            // (System.DirectoryServices.DirectorySearcher.FindAll().GetEnumerator().MoveNext() && (System.DirectoryServices.DirectorySearcher.FindAll().GetEnumerator().Current.ToString() == "<script>alert(0)</script>"))
            Response.Write("result");

            // this is our fourth vulnerability of XSS in this file
            // we will demonstrate what happen if developer want to cheat (FIXED Marker)
            // FIXED: AI issue #4, High, Cross-site Scripting, https://github.com/SDLTestAccount/IT/issues/4
            // GET /Tests/1 INPUT DATA VERIFICATION/9 LDAP Injection/Ldap.aspx HTTP/1.1
            // Host:localhost
            // (System.DirectoryServices.DirectorySearcher.FindAll().GetEnumerator().MoveNext() && (System.DirectoryServices.DirectorySearcher.FindAll().GetEnumerator().Current.ToString() == "<script>alert(0)</script>"))
            Response.Write("result");
        }

        public static void CreateAdamSite(string targetName, string newSiteName)
        {
            try
            {
                // assemble the connection string using the host name and the port assigned to ADAM
                string adamConnectionString = targetName;

                DirectoryContext adamContext = new DirectoryContext(
                                                    DirectoryContextType.DirectoryServer,
                                                    adamConnectionString);

                ActiveDirectorySite site = new ActiveDirectorySite(adamContext,
                                                                   newSiteName);

                // set site options
                site.Options = ActiveDirectorySiteOptions.GroupMembershipCachingEnabled;

                // commit the site to the directory
                site.Save();
                Console.WriteLine("\nSite \"{0}\" was created successfully", site);

            }
            catch (Exception e)
            {
                Console.WriteLine("\r\nUnexpected exception occured:\n\t{0}\n{1}",
                                  e.GetType().Name, e.Message);
            }
        }

 // Internal Constructors
 internal ApplicationPartition(DirectoryContext context, string distinguishedName, string dnsName, ApplicationPartitionType appType, DirectoryEntryManager directoryEntryMgr)
     : base(context, distinguishedName)
 {
     this.directoryEntryMgr = directoryEntryMgr;
     _appType = appType;
     _dnsName = dnsName;
 }

 public ActiveDirectorySchemaProperty(DirectoryContext context, string ldapDisplayName)
 {
     this.syntax = ~ActiveDirectorySyntax.CaseExactString;
     this.rangeLower = null;
     this.rangeUpper = null;
     this.linkId = null;
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     if ((context.Name == null) && !context.isRootDomain())
     {
         throw new ArgumentException(Res.GetString("ContextNotAssociatedWithDomain"), "context");
     }
     if (((context.Name != null) && !context.isRootDomain()) && (!context.isADAMConfigSet() && !context.isServer()))
     {
         throw new ArgumentException(Res.GetString("NotADOrADAM"), "context");
     }
     if (ldapDisplayName == null)
     {
         throw new ArgumentNullException("ldapDisplayName");
     }
     if (ldapDisplayName.Length == 0)
     {
         throw new ArgumentException(Res.GetString("EmptyStringParameter"), "ldapDisplayName");
     }
     this.context = new DirectoryContext(context);
     this.schemaEntry = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.SchemaNamingContext);
     this.schemaEntry.Bind(true);
     this.ldapDisplayName = ldapDisplayName;
     this.commonName = ldapDisplayName;
     this.isBound = false;
 }

		internal TrustRelationshipInformation(DirectoryContext context, string source, TrustObject obj)
		{
			string netbiosDomainName;
			this.context = context;
			this.source = source;
			TrustRelationshipInformation trustRelationshipInformation = this;
			if (obj.DnsDomainName == null)
			{
				netbiosDomainName = obj.NetbiosDomainName;
			}
			else
			{
				netbiosDomainName = obj.DnsDomainName;
			}
			trustRelationshipInformation.target = netbiosDomainName;
			if ((obj.Flags & 2) == 0 || (obj.Flags & 32) == 0)
			{
				if ((obj.Flags & 2) == 0)
				{
					if ((obj.Flags & 32) != 0)
					{
						this.direction = TrustDirection.Inbound;
					}
				}
				else
				{
					this.direction = TrustDirection.Outbound;
				}
			}
			else
			{
				this.direction = TrustDirection.Bidirectional;
			}
			this.type = obj.TrustType;
		}

        internal ForestTrustRelationshipInformation(DirectoryContext context, string source, DS_DOMAIN_TRUSTS unmanagedTrust, TrustType type)
        {
            string tmpDNSName = null;
            string tmpNetBIOSName = null;

            // security context
            this.context = context;
            // source 
            this.source = source;
            // target
            if (unmanagedTrust.DnsDomainName != (IntPtr)0)
                tmpDNSName = Marshal.PtrToStringUni(unmanagedTrust.DnsDomainName);
            if (unmanagedTrust.NetbiosDomainName != (IntPtr)0)
                tmpNetBIOSName = Marshal.PtrToStringUni(unmanagedTrust.NetbiosDomainName);

            this.target = (tmpDNSName == null ? tmpNetBIOSName : tmpDNSName);
            // direction
            if ((unmanagedTrust.Flags & (int)DS_DOMAINTRUST_FLAG.DS_DOMAIN_DIRECT_OUTBOUND) != 0 &&
                (unmanagedTrust.Flags & (int)DS_DOMAINTRUST_FLAG.DS_DOMAIN_DIRECT_INBOUND) != 0)
                direction = TrustDirection.Bidirectional;
            else if ((unmanagedTrust.Flags & (int)DS_DOMAINTRUST_FLAG.DS_DOMAIN_DIRECT_OUTBOUND) != 0)
                direction = TrustDirection.Outbound;
            else if ((unmanagedTrust.Flags & (int)DS_DOMAINTRUST_FLAG.DS_DOMAIN_DIRECT_INBOUND) != 0)
                direction = TrustDirection.Inbound;
            // type
            this.type = type;
        }

		//private NativeComInterfaces.IAdsPathname pathCracker;

		internal DirectoryEntryManager(DirectoryContext context)
		{
			this.directoryEntries = new Hashtable();
			this.context = context;
			//this.pathCracker = (NativeComInterfaces.IAdsPathname)(new NativeComInterfaces.Pathname());
			//this.pathCracker.EscapedMode = 2;
		}

        internal ActiveDirectorySubnetCollection(DirectoryContext context, string siteDN)
        {
            _context = context;
            _siteDN = siteDN;

            Hashtable tempTable = new Hashtable();
            changeList = Hashtable.Synchronized(tempTable);
        }

    public static System.DirectoryServices.ActiveDirectory.DomainController FindOne(DirectoryContext context, string siteName)
    {
      Contract.Requires(context != null);
      Contract.Requires(context.ContextType == DirectoryContextType.Domain);
      Contract.Requires(siteName != null);

      return default(System.DirectoryServices.ActiveDirectory.DomainController);
    }

 internal ActiveDirectorySiteLinkBridge(DirectoryContext context, string bridgeName, ActiveDirectoryTransportType transport, bool existing)
 {
     this.links = new ActiveDirectorySiteLinkCollection();
     this.context = context;
     this.name = bridgeName;
     this.transport = transport;
     this.existing = existing;
 }

    public static ActiveDirectoryInterSiteTransport FindByTransportType(DirectoryContext context, ActiveDirectoryTransportType transport)
    {
      Contract.Requires(context != null);

      Contract.Ensures(Contract.Result<ActiveDirectoryInterSiteTransport>() != null);

      return default(ActiveDirectoryInterSiteTransport);
    }

    public static ActiveDirectorySchemaClass FindByName(DirectoryContext context, string ldapDisplayName)
    {
      Contract.Requires(context != null);

      Contract.Ensures(Contract.Result<ActiveDirectorySchemaClass>() != null);

      return default(System.DirectoryServices.ActiveDirectory.ActiveDirectorySchemaClass);
    }