Ejemplo n.º 1
0
 /// <summary>
 /// Un-marshal a byte array to PDU struct.
 /// </summary>
 /// <param name="binaryReader">BinaryReader</param>
 internal override void FromBytes(BinaryReader binaryReader)
 {
     base.FromBytes(binaryReader);
     auth_verifier = RpceUtility.AuthVerifierFromBytes(
         binaryReader,
         auth_length);
 }
Ejemplo n.º 2
0
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            alloc_hint = binaryReader.ReadUInt32();
            p_cont_id  = binaryReader.ReadUInt16();
            opnum      = binaryReader.ReadUInt16();

            if ((pfc_flags & RpceCoPfcFlags.PFC_OBJECT_UUID) != 0)
            {
                @object = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
            }

            int stubLength = frag_length;

            stubLength -= GetSize();
            if (auth_verifier != null)
            {
                stubLength -= auth_verifier.Value.auth_pad_length;
                stubLength -= RpceUtility.AUTH_VERIFIER_SIZE;
                stubLength -= auth_length;
            }
            stub = binaryReader.ReadBytes(stubLength);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Append verification_trailer to stub.
        /// </summary>
        /// <param name="verificationTrailer">verification_trailer</param>
        /// <exception cref="ArgumentNullException">Thrown when verificationTrailer is null.</exception>
        public void AppendVerificationTrailerToStub(verification_trailer_t verificationTrailer)
        {
            if (verificationTrailer == null)
            {
                throw new ArgumentNullException("verificationTrailer");
            }

            if (stub == null)
            {
                stub = new byte[0];
            }

            stub = RpceUtility.AppendVerificationTrailerToStub(stub, verificationTrailer);

            if (auth_verifier != null)
            {
                auth_verifier_co_t authVerifier = auth_verifier.Value;
                authVerifier.auth_pad_length = (byte)(
                    RpceUtility.Align(stub.Length, RpceUtility.STUB_PAD_LENGTH) - stub.Length);
                authVerifier.auth_pad = new byte[authVerifier.auth_pad_length];
                auth_verifier         = authVerifier;
            }

            SetLength();
        }
 /// <summary>
 /// Un-marshal a byte array to PDU struct.
 /// </summary>
 /// <param name="binaryReader">BinaryReader</param>
 internal override void FromBytes(BinaryReader binaryReader)
 {
     base.FromBytes(binaryReader);
     auth_verifier = RpceUtility.AuthVerifierFromBytes(
         binaryReader,
         auth_length);
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Marshal the PDU struct to a byte array.
        /// </summary>
        /// <returns>A byte array contains PDU data.</returns>
        public override byte[] ToBytes()
        {
            int size = GetSize();

            FieldInfo fieldInfo = GetType().GetField("stub");

            if (fieldInfo != null)
            {
                byte[] stub = (byte[])fieldInfo.GetValue(this);
                if (stub != null)
                {
                    size += stub.Length;
                }
            }

            fieldInfo = GetType().GetField("auth_verifier");
            if (fieldInfo != null)
            {
                auth_verifier_co_t?authVerifier = (auth_verifier_co_t?)fieldInfo.GetValue(this);
                size += RpceUtility.AuthVerifierGetSize(authVerifier);
            }

            byte[] pduBytes = new byte[size];
            using (BinaryWriter binaryWriter = new BinaryWriter(new MemoryStream(pduBytes)))
            {
                ToBytes(binaryWriter);
            }

            return(pduBytes);
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            alloc_hint = binaryReader.ReadUInt32();
            p_cont_id  = binaryReader.ReadUInt16();
            opnum      = binaryReader.ReadUInt16();

            if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
            {
                alloc_hint = EndianUtility.ReverseByteOrder(alloc_hint);
                p_cont_id  = EndianUtility.ReverseByteOrder(p_cont_id);
                opnum      = EndianUtility.ReverseByteOrder(opnum);
            }

            if ((pfc_flags & RpceCoPfcFlags.PFC_OBJECT_UUID) != 0)
            {
                @object = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
            }

            int stubLength = frag_length;

            stubLength -= GetSize();
            if (auth_verifier != null)
            {
                stubLength -= auth_verifier.Value.auth_pad_length;
                stubLength -= RpceUtility.AUTH_VERIFIER_SIZE;
                stubLength -= auth_length;
            }
            stub = binaryReader.ReadBytes(stubLength);
        }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            alloc_hint   = binaryReader.ReadUInt32();
            p_cont_id    = binaryReader.ReadUInt16();
            cancel_count = binaryReader.ReadByte();
            reserved     = binaryReader.ReadByte();
            status       = binaryReader.ReadUInt32();
            reserved2    = binaryReader.ReadUInt32();

            // read stub
            int stubLength = frag_length;

            stubLength -= GetSize();
            if (auth_verifier != null)
            {
                stubLength -= auth_verifier.Value.auth_pad_length;
                stubLength -= RpceUtility.AUTH_VERIFIER_SIZE;
                stubLength -= auth_length;
            }
            stub = binaryReader.ReadBytes(stubLength);
        }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            alloc_hint   = binaryReader.ReadUInt32();
            p_cont_id    = binaryReader.ReadUInt16();
            cancel_count = binaryReader.ReadByte();
            reserved     = binaryReader.ReadByte();

            if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
            {
                alloc_hint = EndianUtility.ReverseByteOrder(alloc_hint);
                p_cont_id  = EndianUtility.ReverseByteOrder(p_cont_id);
            }

            // read stub.
            int stubLength = frag_length;

            stubLength -= GetSize();
            if (auth_verifier != null)
            {
                stubLength -= auth_verifier.Value.auth_pad_length;
                stubLength -= RpceUtility.AUTH_VERIFIER_SIZE;
                stubLength -= auth_length;
            }
            stub = binaryReader.ReadBytes(stubLength);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Encrypt stub and initial auth_token.
        /// </summary>
        public override void InitializeAuthenticationToken()
        {
            if (context.AuthenticationType == RpceAuthenticationType.RPC_C_AUTHN_NONE ||
                context.AuthenticationLevel == RpceAuthenticationLevel.RPC_C_AUTHN_LEVEL_NONE)
            {
                // AUTHN_NONE and AUTHN_LEVEL_NONE, do nothing.
                return;
            }

            FieldInfo fieldInfo = this.GetType().GetField("auth_verifier");

            if (fieldInfo == null)
            {
                // PDU has no auth_verifier field, do nothing.
                return;
            }

            auth_verifier_co_t?authVerifier = (auth_verifier_co_t?)fieldInfo.GetValue(this);

            if (authVerifier == null)
            {
                // PDU has no auth_verifier, do nothing.
                return;
            }

            if (PTYPE == RpcePacketType.Bind ||
                PTYPE == RpcePacketType.AlterContext ||
                PTYPE == RpcePacketType.Auth3)
            {
                //Bind PDU, First call to GSS_Init_sec_context, as specified in [RFC2743] section 2.2.1.
                //alter_context, rpc_auth_3, Second and subsequent calls to GSS_Init_sec_context,
                //as specified in [RFC2743] section 2.2.1.
                auth_verifier_co_t newAuthVerifier = authVerifier.Value;
                newAuthVerifier.auth_value = context.SecurityContext.Token;
                authVerifier = newAuthVerifier;
            }
            else if (PTYPE == RpcePacketType.BindAck ||
                     PTYPE == RpcePacketType.AlterContextResp)
            {
                auth_verifier_co_t newAuthVerifier = authVerifier.Value;
                newAuthVerifier.auth_value = context.SecurityContext.Token;
                authVerifier = newAuthVerifier;
            }
            else if (context.AuthenticationLevel != RpceAuthenticationLevel.RPC_C_AUTHN_LEVEL_DEFAULT &&
                     context.AuthenticationLevel != RpceAuthenticationLevel.RPC_C_AUTHN_LEVEL_CONNECT)
            {
                auth_verifier_co_t newAuthVerifier = authVerifier.Value;
                EncryptAndSign(ref newAuthVerifier);
                authVerifier = newAuthVerifier;
            }

            // set it back to PDU.
            fieldInfo.SetValue(this, authVerifier);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);
            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);
            pad = binaryReader.ReadUInt32();

            if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
            {
                pad = EndianUtility.ReverseByteOrder(pad);
            }
        }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            max_xmit_frag  = binaryReader.ReadUInt16();
            max_recv_frag  = binaryReader.ReadUInt16();
            assoc_group_id = binaryReader.ReadUInt32();

            p_context_elem = new p_cont_list_t();

            p_context_elem.n_context_elem = binaryReader.ReadByte();
            p_context_elem.reserved       = binaryReader.ReadByte();
            p_context_elem.reserved2      = binaryReader.ReadUInt16();

            p_context_elem.p_cont_elem = new p_cont_elem_t[p_context_elem.n_context_elem];
            for (int i = 0; i < p_context_elem.n_context_elem; i++)
            {
                p_context_elem.p_cont_elem[i].p_cont_id      = binaryReader.ReadUInt16();
                p_context_elem.p_cont_elem[i].n_transfer_syn = binaryReader.ReadByte();
                p_context_elem.p_cont_elem[i].reserved       = binaryReader.ReadByte();

                p_context_elem.p_cont_elem[i].abstract_syntax = new p_syntax_id_t();
                p_context_elem.p_cont_elem[i].abstract_syntax.if_uuid
                    = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                p_context_elem.p_cont_elem[i].abstract_syntax.if_vers_major
                    = binaryReader.ReadUInt16();
                p_context_elem.p_cont_elem[i].abstract_syntax.if_vers_minor
                    = binaryReader.ReadUInt16();

                p_context_elem.p_cont_elem[i].transfer_syntaxes
                    = new p_syntax_id_t[p_context_elem.p_cont_elem[i].n_transfer_syn];
                for (int j = 0; j < p_context_elem.p_cont_elem[i].transfer_syntaxes.Length; j++)
                {
                    p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_uuid
                        = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                    p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_vers_major
                        = binaryReader.ReadUInt16();
                    p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_vers_minor
                        = binaryReader.ReadUInt16();
                }
            }
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Set length field of PDU.
        /// </summary>
        public override void SetLength()
        {
            auth_verifier_co_t?authVerifier = null;
            FieldInfo          fieldInfo    = this.GetType().GetField("auth_verifier");

            if (fieldInfo != null)
            {
                authVerifier = (auth_verifier_co_t?)fieldInfo.GetValue(this);
            }

            byte[] stub       = GetStub();
            int    stubLength = (stub == null) ? 0 : stub.Length;

            // stub was already padded in AppendAuthenticationVerifier()
            auth_length = (authVerifier == null || authVerifier.Value.auth_value == null)
                            ? (ushort)0
                            : (ushort)authVerifier.Value.auth_value.Length;
            frag_length = (ushort)(GetSize() + stubLength + RpceUtility.AuthVerifierGetSize(authVerifier));
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Get size of auth_verifier.
        /// </summary>
        /// <param name="authVerifier">auth_verifier</param>
        /// <returns>size</returns>
        internal static ushort AuthVerifierGetSize(
            auth_verifier_co_t?authVerifier)
        {
            ushort size = 0;

            if (authVerifier != null)
            {
                size += AUTH_VERIFIER_SIZE;
                if (authVerifier.Value.auth_pad != null)
                {
                    size += (ushort)authVerifier.Value.auth_pad.Length;
                }
                if (authVerifier.Value.auth_value != null)
                {
                    size += (ushort)authVerifier.Value.auth_value.Length;
                }
            }
            return(size);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            max_xmit_frag  = binaryReader.ReadUInt16();
            max_recv_frag  = binaryReader.ReadUInt16();
            assoc_group_id = binaryReader.ReadUInt32();

            sec_addr           = new port_any_t();
            sec_addr.length    = binaryReader.ReadUInt16();
            sec_addr.port_spec = binaryReader.ReadBytes(sec_addr.length);

            // restore 4-octet alignment
            int pad2length = RpceUtility.Align((int)binaryReader.BaseStream.Position, 4)
                             - (int)binaryReader.BaseStream.Position;

            pad2 = binaryReader.ReadBytes(pad2length);

            p_result_list           = new p_result_list_t();
            p_result_list.n_results = binaryReader.ReadByte();
            p_result_list.reserved  = binaryReader.ReadByte();
            p_result_list.reserved2 = binaryReader.ReadUInt16();

            p_result_list.p_results = new p_result_t[p_result_list.n_results];
            for (int i = 0; i < p_result_list.n_results; i++)
            {
                p_result_list.p_results[i].result          = (p_cont_def_result_t)binaryReader.ReadUInt16();
                p_result_list.p_results[i].reason          = (p_provider_reason_t)binaryReader.ReadUInt16();
                p_result_list.p_results[i].transfer_syntax = new p_syntax_id_t();
                p_result_list.p_results[i].transfer_syntax.if_uuid
                    = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                p_result_list.p_results[i].transfer_syntax.if_vers_major
                    = binaryReader.ReadUInt16();
                p_result_list.p_results[i].transfer_syntax.if_vers_minor
                    = binaryReader.ReadUInt16();
            }
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Append auth_verifier to the end of PDU.
        /// </summary>
        public override void AppendAuthenticationVerifier()
        {
            FieldInfo fieldInfo = this.GetType().GetField("auth_verifier");

            if (fieldInfo == null)
            {
                return;
            }

            byte[] stub = GetStub();

            auth_verifier_co_t?authVerifier = RpceUtility.AuthVerifierCreateInstance(
                PTYPE,
                stub != null ? stub.Length : 0,
                context.SecurityContext,
                context.AuthenticationType,
                context.AuthenticationLevel,
                context.AuthenticationContextId);

            fieldInfo.SetValue(this, authVerifier);
        }
Ejemplo n.º 16
0
 /// <summary>
 /// Write auth_verifier into binary writer.
 /// </summary>
 /// <param name="binaryWriter">binary writer</param>
 /// <param name="authVerifier">auth_verifier</param>
 internal static void AuthVerifierToBytes(
     BinaryWriter binaryWriter,
     auth_verifier_co_t?authVerifier)
 {
     if (authVerifier != null)
     {
         if (authVerifier.Value.auth_pad != null)
         {
             binaryWriter.Write(authVerifier.Value.auth_pad);
         }
         binaryWriter.Write(authVerifier.Value.auth_type);
         binaryWriter.Write(authVerifier.Value.auth_level);
         binaryWriter.Write(authVerifier.Value.auth_pad_length);
         binaryWriter.Write(authVerifier.Value.auth_reserved);
         binaryWriter.Write(authVerifier.Value.auth_context_id);
         if (authVerifier.Value.auth_value != null)
         {
             binaryWriter.Write(authVerifier.Value.auth_value);
         }
     }
 }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            max_xmit_frag  = binaryReader.ReadUInt16();
            max_recv_frag  = binaryReader.ReadUInt16();
            assoc_group_id = binaryReader.ReadUInt32();

            if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
            {
                max_xmit_frag  = EndianUtility.ReverseByteOrder(max_xmit_frag);
                max_recv_frag  = EndianUtility.ReverseByteOrder(max_recv_frag);
                assoc_group_id = EndianUtility.ReverseByteOrder(assoc_group_id);
            }

            p_context_elem = new p_cont_list_t();

            p_context_elem.n_context_elem = binaryReader.ReadByte();
            p_context_elem.reserved       = binaryReader.ReadByte();
            p_context_elem.reserved2      = binaryReader.ReadUInt16();

            p_context_elem.p_cont_elem = new p_cont_elem_t[p_context_elem.n_context_elem];
            for (int i = 0; i < p_context_elem.n_context_elem; i++)
            {
                p_context_elem.p_cont_elem[i].p_cont_id      = binaryReader.ReadUInt16();
                p_context_elem.p_cont_elem[i].n_transfer_syn = binaryReader.ReadByte();
                p_context_elem.p_cont_elem[i].reserved       = binaryReader.ReadByte();

                p_context_elem.p_cont_elem[i].abstract_syntax = new p_syntax_id_t();
                p_context_elem.p_cont_elem[i].abstract_syntax.if_uuid
                    = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                p_context_elem.p_cont_elem[i].abstract_syntax.if_version
                    = binaryReader.ReadUInt32();

                if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
                {
                    p_context_elem.p_cont_elem[i].p_cont_id = EndianUtility.ReverseByteOrder(p_context_elem.p_cont_elem[i].p_cont_id);
                    p_context_elem.p_cont_elem[i].abstract_syntax.if_uuid    = EndianUtility.ReverseByteOrder(p_context_elem.p_cont_elem[i].abstract_syntax.if_uuid);
                    p_context_elem.p_cont_elem[i].abstract_syntax.if_version = EndianUtility.ReverseByteOrder(p_context_elem.p_cont_elem[i].abstract_syntax.if_version);
                }

                p_context_elem.p_cont_elem[i].transfer_syntaxes
                    = new p_syntax_id_t[p_context_elem.p_cont_elem[i].n_transfer_syn];
                for (int j = 0; j < p_context_elem.p_cont_elem[i].transfer_syntaxes.Length; j++)
                {
                    p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_uuid
                        = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                    p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_version
                        = binaryReader.ReadUInt32();

                    if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
                    {
                        p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_uuid    = EndianUtility.ReverseByteOrder(p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_uuid);
                        p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_version = EndianUtility.ReverseByteOrder(p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_version);
                    }
                }
            }
        }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            max_xmit_frag  = binaryReader.ReadUInt16();
            max_recv_frag  = binaryReader.ReadUInt16();
            assoc_group_id = binaryReader.ReadUInt32();

            if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
            {
                max_xmit_frag  = EndianUtility.ReverseByteOrder(max_xmit_frag);
                max_recv_frag  = EndianUtility.ReverseByteOrder(max_recv_frag);
                assoc_group_id = EndianUtility.ReverseByteOrder(assoc_group_id);
            }

            sec_addr        = new port_any_t();
            sec_addr.length = binaryReader.ReadUInt16();
            if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
            {
                sec_addr.length = EndianUtility.ReverseByteOrder(sec_addr.length);
            }
            sec_addr.port_spec = binaryReader.ReadBytes(sec_addr.length);

            // restore 4-octet alignment
            int pad2Length = RpceUtility.Align((int)binaryReader.BaseStream.Position, 4)
                             - (int)binaryReader.BaseStream.Position;

            pad2 = binaryReader.ReadBytes(pad2Length);

            p_result_list           = new p_result_list_t();
            p_result_list.n_results = binaryReader.ReadByte();
            p_result_list.reserved  = binaryReader.ReadByte();
            p_result_list.reserved2 = binaryReader.ReadUInt16();

            p_result_list.p_results = new p_result_t[p_result_list.n_results];
            for (int i = 0; i < p_result_list.n_results; i++)
            {
                if (packed_drep.dataRepFormat == RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
                {
                    p_result_list.p_results[i].result = (p_cont_def_result_t)binaryReader.ReadUInt16();
                    p_result_list.p_results[i].reason = (p_provider_reason_t)binaryReader.ReadUInt16();
                }
                else
                {
                    p_result_list.p_results[i].result = (p_cont_def_result_t)EndianUtility.ReverseByteOrder(binaryReader.ReadUInt16());
                    p_result_list.p_results[i].reason = (p_provider_reason_t)EndianUtility.ReverseByteOrder(binaryReader.ReadUInt16());
                }

                p_result_list.p_results[i].transfer_syntax = new p_syntax_id_t();
                p_result_list.p_results[i].transfer_syntax.if_uuid
                    = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                p_result_list.p_results[i].transfer_syntax.if_version
                    = binaryReader.ReadUInt32();

                if (packed_drep.dataRepFormat != RpceDataRepresentationFormat.IEEE_LittleEndian_ASCII)
                {
                    p_result_list.p_results[i].transfer_syntax.if_uuid    = EndianUtility.ReverseByteOrder(p_result_list.p_results[i].transfer_syntax.if_uuid);
                    p_result_list.p_results[i].transfer_syntax.if_version = EndianUtility.ReverseByteOrder(p_result_list.p_results[i].transfer_syntax.if_version);
                }
            }
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Decrypt stub and validate auth_token.
        /// </summary>
        public override bool ValidateAuthenticationToken()
        {
            FieldInfo fieldInfo = this.GetType().GetField("auth_verifier");

            if (fieldInfo == null)
            {
                // PDU has no auth_verifier field, do nothing.
                return(true);
            }

            auth_verifier_co_t?authVerifier = (auth_verifier_co_t?)fieldInfo.GetValue(this);

            if (authVerifier == null)
            {
                // PDU has no auth_verifier, do nothing.
                return(true);
            }

            if (authVerifier.Value.auth_type != (byte)context.AuthenticationType ||
                authVerifier.Value.auth_level != (byte)context.AuthenticationLevel ||
                authVerifier.Value.auth_context_id != context.AuthenticationContextId)
            {
                //SecurityProvider in context is not the right SSPI to decrypt and validate the PDU.
                return(false);
            }

            bool result = true;

            if (PTYPE == RpcePacketType.Bind ||
                PTYPE == RpcePacketType.AlterContext ||
                PTYPE == RpcePacketType.Auth3)
            {
                ServerSecurityContext serverSspi = context.SecurityContext as ServerSecurityContext;
                if (serverSspi != null)
                {
                    // Accept or Initialize should throw exception when token is incorrect.
                    serverSspi.Accept(authVerifier.Value.auth_value);
                    securityContextNeedContinueProcessing = serverSspi.NeedContinueProcessing;
                }
            }
            else if (PTYPE == RpcePacketType.BindAck ||
                     PTYPE == RpcePacketType.AlterContextResp)
            {
                ClientSecurityContext clientSspi = context.SecurityContext as ClientSecurityContext;
                if (clientSspi != null)
                {
                    //BindAck only received on client.
                    clientSspi.Initialize(authVerifier.Value.auth_value);
                    securityContextNeedContinueProcessing = clientSspi.NeedContinueProcessing;
                }
            }
            else if (context.AuthenticationLevel != RpceAuthenticationLevel.RPC_C_AUTHN_LEVEL_DEFAULT &&
                     context.AuthenticationLevel != RpceAuthenticationLevel.RPC_C_AUTHN_LEVEL_CONNECT)
            {
                auth_verifier_co_t newAuthVerifier = authVerifier.Value;
                result       = DecryptAndVerify(ref newAuthVerifier);
                authVerifier = newAuthVerifier;
            }

            return(result);
        }
        /// <summary>
        /// Append verification_trailer to stub.
        /// </summary>
        /// <param name="verificationTrailer">verification_trailer</param>
        /// <exception cref="ArgumentNullException">Thrown when verificationTrailer is null.</exception>
        public void AppendVerificationTrailerToStub(verification_trailer_t verificationTrailer)
        {
            if (verificationTrailer == null)
            {
                throw new ArgumentNullException("verificationTrailer");
            }

            if (stub == null)
            {
                stub = new byte[0];
            }

            stub = RpceUtility.AppendVerificationTrailerToStub(stub, verificationTrailer);

            if (auth_verifier != null)
            {
                auth_verifier_co_t authVerifier = auth_verifier.Value;
                authVerifier.auth_pad_length = (byte)(
                    RpceUtility.Align(stub.Length, RpceUtility.STUB_PAD_LENGTH) - stub.Length);
                authVerifier.auth_pad = new byte[authVerifier.auth_pad_length];
                auth_verifier = authVerifier;
            }

            SetLength();
        }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
              binaryReader,
              auth_length);

            alloc_hint = binaryReader.ReadUInt32();
            p_cont_id = binaryReader.ReadUInt16();
            opnum = binaryReader.ReadUInt16();

            if ((pfc_flags & RpceCoPfcFlags.PFC_OBJECT_UUID) != 0)
            {
                @object = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
            }

            int stubLength = frag_length;
            stubLength -= GetSize();
            if (auth_verifier != null)
            {
                stubLength -= auth_verifier.Value.auth_pad_length;
                stubLength -= RpceUtility.AUTH_VERIFIER_SIZE;
                stubLength -= auth_length;
            }
            stub = binaryReader.ReadBytes(stubLength);
        }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            max_xmit_frag = binaryReader.ReadUInt16();
            max_recv_frag = binaryReader.ReadUInt16();
            assoc_group_id = binaryReader.ReadUInt32();

            p_context_elem = new p_cont_list_t();

            p_context_elem.n_context_elem = binaryReader.ReadByte();
            p_context_elem.reserved = binaryReader.ReadByte();
            p_context_elem.reserved2 = binaryReader.ReadUInt16();

            p_context_elem.p_cont_elem = new p_cont_elem_t[p_context_elem.n_context_elem];
            for (int i = 0; i < p_context_elem.n_context_elem; i++)
            {
                p_context_elem.p_cont_elem[i].p_cont_id = binaryReader.ReadUInt16();
                p_context_elem.p_cont_elem[i].n_transfer_syn = binaryReader.ReadByte();
                p_context_elem.p_cont_elem[i].reserved = binaryReader.ReadByte();

                p_context_elem.p_cont_elem[i].abstract_syntax = new p_syntax_id_t();
                p_context_elem.p_cont_elem[i].abstract_syntax.if_uuid
                    = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                p_context_elem.p_cont_elem[i].abstract_syntax.if_vers_major
                    = binaryReader.ReadUInt16();
                p_context_elem.p_cont_elem[i].abstract_syntax.if_vers_minor
                    = binaryReader.ReadUInt16();

                p_context_elem.p_cont_elem[i].transfer_syntaxes
                    = new p_syntax_id_t[p_context_elem.p_cont_elem[i].n_transfer_syn];
                for (int j = 0; j < p_context_elem.p_cont_elem[i].transfer_syntaxes.Length; j++)
                {
                    p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_uuid
                        = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                    p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_vers_major
                        = binaryReader.ReadUInt16();
                    p_context_elem.p_cont_elem[i].transfer_syntaxes[j].if_vers_minor
                        = binaryReader.ReadUInt16();
                }
            }
        }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            max_xmit_frag = binaryReader.ReadUInt16();
            max_recv_frag = binaryReader.ReadUInt16();
            assoc_group_id = binaryReader.ReadUInt32();

            sec_addr = new port_any_t();
            sec_addr.length = binaryReader.ReadUInt16();
            sec_addr.port_spec = binaryReader.ReadBytes(sec_addr.length);

            // restore 4-octet alignment
            int pad2length = RpceUtility.Align((int)binaryReader.BaseStream.Position, 4)
                                - (int)binaryReader.BaseStream.Position;
            pad2 = binaryReader.ReadBytes(pad2length);

            p_result_list = new p_result_list_t();
            p_result_list.n_results = binaryReader.ReadByte();
            p_result_list.reserved = binaryReader.ReadByte();
            p_result_list.reserved2 = binaryReader.ReadUInt16();

            p_result_list.p_results = new p_result_t[p_result_list.n_results];
            for (int i = 0; i < p_result_list.n_results; i++)
            {
                p_result_list.p_results[i].result = (p_cont_def_result_t)binaryReader.ReadUInt16();
                p_result_list.p_results[i].reason = (p_provider_reason_t)binaryReader.ReadUInt16();
                p_result_list.p_results[i].transfer_syntax = new p_syntax_id_t();
                p_result_list.p_results[i].transfer_syntax.if_uuid
                    = new Guid(binaryReader.ReadBytes(RpceUtility.GUID_SIZE));
                p_result_list.p_results[i].transfer_syntax.if_vers_major
                    = binaryReader.ReadUInt16();
                p_result_list.p_results[i].transfer_syntax.if_vers_minor
                    = binaryReader.ReadUInt16();
            }
        }
        /// <summary>
        /// Un-marshal a byte array to PDU struct.
        /// </summary>
        /// <param name="binaryReader">BinaryReader</param>
        internal override void FromBytes(BinaryReader binaryReader)
        {
            base.FromBytes(binaryReader);

            auth_verifier = RpceUtility.AuthVerifierFromBytes(
                binaryReader,
                auth_length);

            alloc_hint = binaryReader.ReadUInt32();
            p_cont_id = binaryReader.ReadUInt16();
            cancel_count = binaryReader.ReadByte();
            reserved = binaryReader.ReadByte();

            // read stub.
            int stubLength = frag_length;
            stubLength -= GetSize();
            if (auth_verifier != null)
            {
                stubLength -= auth_verifier.Value.auth_pad_length;
                stubLength -= RpceUtility.AUTH_VERIFIER_SIZE;
                stubLength -= auth_length;
            }
            stub = binaryReader.ReadBytes(stubLength);
        }