コード例 #1
0
ファイル: ACL.cs プロジェクト: vossjannik/ldap4net
        /// <summary>
        ///     Serializes to byte array.
        ///     @return serialized ACL.
        /// </summary>
        public byte[] ToByteArray()
        {
            int size = this.GetSize();

            using var ms = new MemoryStream(size);
            var buff = new BinaryWriter(ms);

            // add revision
            buff.Write((byte)this.revision);

            // add reserved
            buff.Write((byte)0x00);

            // add size (2 bytes reversed)
            byte[] sizeSrc = NumberFacility.GetBytes(size);
            buff.Write(sizeSrc[3]);
            buff.Write(sizeSrc[2]);

            // add ace count (2 bytes reversed)
            byte[] aceCountSrc = NumberFacility.GetBytes(this.GetAceCount());
            buff.Write(aceCountSrc[3]);
            buff.Write(aceCountSrc[2]);

            // add reserved (2 bytes)
            buff.Write((byte)0x00);
            buff.Write((byte)0x00);

            // add aces
            foreach (Ace ace in this.aces)
            {
                buff.Write(ace.ToByteArray());
            }

            return(ms.ToArray());
        }
コード例 #2
0
        /// <summary>
        ///     Serializes to byte array.
        ///     @return serialized ACE.
        /// </summary>
        public byte[] ToByteArray()
        {
            int size = this.GetSize();

            using var ms = new MemoryStream(size);
            var buff = new BinaryWriter(ms);

            // Add type byte
            buff.Write((byte)this.type);

            // add flags byte
            byte flagSrc = this.GetFlags().Aggregate <AceFlag, byte>(0x00, (current, flag) => (byte)(current | (byte)flag));

            buff.Write(flagSrc);

            // add size bytes (2 reversed)
            byte[] sizeSrc = NumberFacility.GetBytes(size);
            buff.Write(sizeSrc[3]);
            buff.Write(sizeSrc[2]);

            // add right mask
            buff.Write(Hex.Reverse(NumberFacility.GetUIntBytes(this.rights.AsUInt())));

            // add object flags (from int to byte[] + reversed)
            if (this.objectFlags != null)
            {
                buff.Write(Hex.Reverse(NumberFacility.GetUIntBytes(this.objectFlags.AsUInt())));
            }

            // add object type
            if (this.objectType != null)
            {
                buff.Write(this.objectType.Value.ToByteArray());
            }

            // add inherited object type
            if (this.inheritedObjectType != null)
            {
                buff.Write(this.inheritedObjectType.Value.ToByteArray());
            }

            // add sid
            buff.Write(this.sid.ToByteArray());

            // add application data
            if (this.applicationData != null)
            {
                buff.Write(this.applicationData);
            }

            return(ms.ToArray());
        }
コード例 #3
0
ファイル: ACL.cs プロジェクト: vossjannik/ldap4net
        /// <summary>
        ///     Load the ACL from the buffer returning the last ACL segment position into the buffer.
        ///     @param buff source buffer.
        ///     @param start start loading position.
        ///     @return last loading position.
        /// </summary>
        public void Parse(BinaryReader buff, long start)
        {
            buff.BaseStream.Seek(start, SeekOrigin.Begin);

            // read for Dacl
            byte[] bytes = NumberFacility.GetBytes(buff.ReadInt32());
            this.revision = AclRevisionExtension.ParseValue(bytes[0]);

            bytes = NumberFacility.GetBytes(buff.ReadInt32());
            int aceCount = NumberFacility.GetInt(bytes[1], bytes[0]);

            for (var i = 0; i < aceCount; i++)
            {
                Ace ace = new Ace();
                this.aces.Add(ace);

                ace.Parse(buff);
            }
        }
コード例 #4
0
        /// <summary>
        ///     Load the ACE from the buffer returning the last ACE segment position into the buffer.
        ///     @param buff source buffer.
        ///     @param start start loading position.
        ///     @return last loading position.
        /// </summary>
        public void Parse(BinaryReader buff)
        {
            var start = buff.BaseStream.Position;

            byte[] bytes = NumberFacility.GetBytes(buff.ReadInt32());
            this.type  = AceTypeExtension.ParseValue(bytes[0]);
            this.flags = AceFlagExtension.ParseValue(bytes[1]);

            int size = NumberFacility.GetInt(bytes[3], bytes[2]);

            this.rights = AceRights.ParseValue(NumberFacility.GetReverseInt(buff.ReadInt32()));

            if (this.type == AceType.AccessAllowedObjectAceType || this.type == AceType.AccessDeniedObjectAceType)
            {
                this.objectFlags = AceObjectFlags.ParseValue(NumberFacility.GetReverseInt(buff.ReadInt32()));

                if (this.objectFlags.GetFlags().Contains(AceObjectFlags.Flag.AceObjectTypePresent))
                {
                    this.objectType = new Guid(buff.ReadBytes(16));
                }

                if (this.objectFlags.GetFlags().Contains(AceObjectFlags.Flag.AceInheritedObjectTypePresent))
                {
                    this.inheritedObjectType = new Guid(buff.ReadBytes(16));
                }
            }

            this.sid = new SID();
            this.sid.Parse(buff);

            if (size > 0)
            {
                var lastPos = start + size;
                this.applicationData = new byte[lastPos - buff.BaseStream.Position];

                for (var i = 0; i < applicationData.Length; i++)
                {
                    this.applicationData[i] = buff.ReadByte();
                }
            }
        }
コード例 #5
0
        /// <summary>
        ///     Serializes SDDL as byte array.
        ///     @return SDL as byte array.
        /// </summary>
        public byte[] ToByteArray()
        {
            using var ms = new MemoryStream(this.GetSize());
            var buff = new BinaryWriter(ms);

            // add revision
            buff.Write(this.revision);

            // add reserved
            buff.Write((byte)0x00);

            // add contro flags
            buff.Write(this.controlFlags[1]);
            buff.Write(this.controlFlags[0]);

            // add offset owner
            buff.Seek(4, SeekOrigin.Begin);

            var nextAvailablePosition = 20;

            // add owner SID
            if (this.owner == null)
            {
                buff.Write(0);
            }
            else
            {
                buff.Write(Hex.Reverse(NumberFacility.GetBytes(nextAvailablePosition)));
                buff.Seek(nextAvailablePosition, SeekOrigin.Begin);
                buff.Write(this.owner.ToByteArray());
                nextAvailablePosition += this.owner.GetSize();
            }

            // add offset group
            buff.Seek(8, SeekOrigin.Begin);

            // add group SID
            if (this.group == null)
            {
                buff.Write(0);
            }
            else
            {
                buff.Write(Hex.Reverse(NumberFacility.GetBytes(nextAvailablePosition)));
                buff.Seek(nextAvailablePosition, SeekOrigin.Begin);
                buff.Write(this.group.ToByteArray());
                nextAvailablePosition += this.group.GetSize();
            }

            // add offset sacl
            buff.Seek(12, SeekOrigin.Begin);

            // add SACL
            if (this.sacl == null)
            {
                buff.Write(0);
            }
            else
            {
                buff.Write(Hex.Reverse(NumberFacility.GetBytes(nextAvailablePosition)));
                buff.Seek(nextAvailablePosition, SeekOrigin.Begin);
                buff.Write(this.sacl.ToByteArray());
                nextAvailablePosition += this.sacl.GetSize();
            }

            // add offset dacl
            buff.Seek(16, SeekOrigin.Begin);

            // add DACL
            if (this.dacl == null)
            {
                buff.Write(0);
            }
            else
            {
                buff.Write(Hex.Reverse(NumberFacility.GetBytes(nextAvailablePosition)));
                buff.Seek(nextAvailablePosition, SeekOrigin.Begin);
                buff.Write(this.dacl.ToByteArray());
            }

            return(ms.ToArray());
        }
コード例 #6
0
        /// <summary>
        ///     Load the SDDL from the buffer returning the last SDDL segment position into the buffer.
        ///     @param buff source buffer.
        ///     @param start start loading position.
        ///     @return last loading position.
        /// </summary>
        private void Parse(BinaryReader buff, long start)
        {
            // Revision (1 byte): An unsigned 8-bit value that specifies the revision of the SECURITY_DESCRIPTOR
            // structure. This field MUST be set to one.
            buff.BaseStream.Seek(start, SeekOrigin.Begin);
            byte[] header = NumberFacility.GetBytes(buff.ReadInt32());
            this.revision = header[0];

            // Control (2 bytes): An unsigned 16-bit field that specifies control access bit flags. The Self Relative
            // (SR) bit MUST be set when the security descriptor is in self-relative format.
            this.controlFlags = new[] { header[3], header[2] };
            bool[] controlFlag = NumberFacility.GetBits(this.controlFlags);

            // OffsetOwner (4 bytes): An unsigned 32-bit integer that specifies the offset to the SID. This SID
            // specifies the owner of the object to which the security descriptor is associated. This must be a valid
            // offset if the OD flag is not set. If this field is set to zero, the OwnerSid field MUST not be present.
            var offsetOwnerValue = buff.ReadInt32();

            if (!controlFlag[15])
            {
                this.offsetOwner = NumberFacility.GetReverseUInt(offsetOwnerValue);
            }
            else
            {
                this.offsetOwner = 0;
            }

            // OffsetGroup (4 bytes): An unsigned 32-bit integer that specifies the offset to the SID. This SID
            // specifies the group of the object to which the security descriptor is associated. This must be a valid
            // offset if the GD flag is not set. If this field is set to zero, the GroupSid field MUST not be present.
            var offsetGroupValue = buff.ReadInt32();

            if (!controlFlag[14])
            {
                this.offsetGroup = NumberFacility.GetReverseUInt(offsetGroupValue);
            }
            else
            {
                this.offsetGroup = 0;
            }

            // OffsetSacl (4 bytes): An unsigned 32-bit integer that specifies the offset to the ACL that contains
            // system ACEs. Typically, the system ACL contains auditing ACEs (such as SYSTEM_AUDIT_ACE,
            // SYSTEM_AUDIT_CALLBACK_ACE, or SYSTEM_AUDIT_CALLBACK_OBJECT_ACE), and at most one Label ACE (as specified
            // in section 2.4.4.13). This must be a valid offset if the SP flag is set; if the SP flag is not set, this
            // field MUST be set to zero. If this field is set to zero, the Sacl field MUST not be present.
            var offsetSaclValue = buff.ReadInt32();

            if (controlFlag[11])
            {
                this.offsetSacl = NumberFacility.GetReverseUInt(offsetSaclValue);
            }
            else
            {
                this.offsetSacl = 0;
            }

            // OffsetDacl (4 bytes): An unsigned 32-bit integer that specifies the offset to the ACL that contains ACEs
            // that control access. Typically, the DACL contains ACEs that grant or deny access to principals or groups.
            // This must be a valid offset if the DP flag is set; if the DP flag is not set, this field MUST be set to
            // zero. If this field is set to zero, the Dacl field MUST not be present.
            var offsetDaclValue = buff.ReadInt32();

            if (controlFlag[13])
            {
                this.offsetDacl = NumberFacility.GetReverseUInt(offsetDaclValue);
            }
            else
            {
                this.offsetDacl = 0;
            }

            // OwnerSid (variable): The SID of the owner of the object. The length of the SID MUST be a multiple of 4.
            // This field MUST be present if the OffsetOwner field is not zero.
            if (this.offsetOwner > 0)
            {
                // read for OwnerSid
                this.owner = new SID();
                this.owner.Parse(buff, this.offsetOwner);
            }

            // GroupSid (variable): The SID of the group of the object. The length of the SID MUST be a multiple of 4.
            // This field MUST be present if the GroupOwner field is not zero.
            if (this.offsetGroup > 0)
            {
                // read for GroupSid
                this.group = new SID();
                this.group.Parse(buff, this.offsetGroup);
            }

            // Sacl (variable): The SACL of the object. The length of the SID MUST be a multiple of 4. This field MUST
            // be present if the SP flag is set.
            if (this.offsetSacl > 0)
            {
                // read for Sacl
                this.sacl = new Acl();
                this.sacl.Parse(buff, this.offsetSacl);
            }

            // Dacl (variable): The DACL of the object. The length of the SID MUST be a multiple of 4. This field MUST
            // be present if the DP flag is set.
            if (this.offsetDacl > 0)
            {
                this.dacl = new Acl();
                this.dacl.Parse(buff, this.offsetDacl);
            }
        }