Changeset 919


Ignore:
Timestamp:
Jun 9, 2016, 2:17:22 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: apply latest security patches to vendor

Location:
vendor/current
Files:
11 added
89 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/docs-xml/smbdotconf/ldap/clientldapsaslwrapping.xml

    r414 r919  
    3535
    3636        <para>
    37         The default value is <emphasis>plain</emphasis> which is not irritable
    38         to KRB5 clock skew errors. That implies synchronizing the time
    39         with the KDC in the case of using <emphasis>sign</emphasis> or
    40         <emphasis>seal</emphasis>.
     37        The default value is <emphasis>sign</emphasis>. That implies synchronizing the time
     38        with the KDC in the case of using <emphasis>Kerberos</emphasis>.
    4139        </para>
    4240</description>
    43 <value type="default">plain</value>
     41<value type="default">sign</value>
    4442</samba:parameter>

  • vendor/current/docs-xml/smbdotconf/protocol/clientusespnego.xml

    r414 r919  
    1010    3.0) to agree upon an authentication
    1111    mechanism.  This enables Kerberos authentication in particular.</para>
     12
     13    <para>When <smbconfoption name="client NTLMv2 auth"/> is also set to
     14    <constant>yes</constant> extended security (SPNEGO) is required
     15    in order to use NTLMv2 only within NTLMSSP. This behavior was
     16    introduced with the patches for CVE-2016-2111.</para>
    1217</description>
    1318

  • vendor/current/docs-xml/smbdotconf/security/clientntlmv2auth.xml

    r917 r919  
    2929    'best practice' security polices) only allow NTLMv2 responses, and
    3030    not the weaker LM or NTLM.</para>
     31
     32    <para>When <smbconfoption name="client use spnego"/> is also set to
     33    <constant>yes</constant> extended security (SPNEGO) is required
     34    in order to use NTLMv2 only within NTLMSSP. This behavior was
     35    introduced with the patches for CVE-2016-2111.</para>
    3136</description>
    3237<value type="default">yes</value>

  • vendor/current/docs-xml/smbdotconf/security/clientsigning.xml

    r414 r919  
    1313    When set to mandatory, SMB signing is required and if set
    1414        to disabled, SMB signing is not offered either.
     15
     16    <para>IPC$ connections for DCERPC e.g. in winbindd, are handled by the
     17    <smbconfoption name="client ipc signing"/> option.</para>
    1518</para>
    1619</description>

  • vendor/current/lib/util/wscript_build

    r917 r919  
    100100                  private_library=True,
    101101                  local_include=False
    102                   )
     102                 )
    103103
     104bld.SAMBA_LIBRARY('bitmap',
     105                  source='bitmap.c',
     106                  deps='talloc samba-util',
     107                  local_include=False,
     108                  private_library=True)
     109

  • vendor/current/libcli/auth/ntlmssp.h

    r917 r919  
    8484        DATA_BLOB session_key;
    8585
     86        uint32_t required_flags;
    8687        uint32_t neg_flags; /* the current state of negotiation with the NTLMSSP partner */
    8788

  • vendor/current/libcli/auth/proto.h

    r917 r919  
    140140                      DATA_BLOB *lm_response, DATA_BLOB *nt_response,
    141141                      DATA_BLOB *lm_session_key, DATA_BLOB *user_session_key) ;
     142NTSTATUS NTLMv2_RESPONSE_verify_netlogon_creds(const char *account_name,
     143                        const char *account_domain,
     144                        const DATA_BLOB response,
     145                        const struct netlogon_creds_CredentialState *creds,
     146                        const char *workgroup);
    142147
    143148/***********************************************************

  • vendor/current/libcli/auth/smbencrypt.c

    r917 r919  
    2727#include "../lib/crypto/crypto.h"
    2828#include "../libcli/auth/libcli_auth.h"
    29 #include "../librpc/gen_ndr/ntlmssp.h"
     29#include "../librpc/gen_ndr/ndr_ntlmssp.h"
    3030
    3131void SMBencrypt_hash(const uint8_t lm_hash[16], const uint8_t *c8, uint8_t p24[24])
    … …  
    356356
    357357        /* Deliberately ignore return here.. */
    358         (void)msrpc_gen(mem_ctx, &names_blob,
    359                   "aaa",
    360                   MsvAvNbDomainName, domain,
    361                   MsvAvNbComputerName, hostname,
    362                   MsvAvEOL, "");
     358        if (hostname != NULL) {
     359                (void)msrpc_gen(mem_ctx, &names_blob,
     360                          "aaa",
     361                          MsvAvNbDomainName, domain,
     362                          MsvAvNbComputerName, hostname,
     363                          MsvAvEOL, "");
     364        } else {
     365                (void)msrpc_gen(mem_ctx, &names_blob,
     366                          "aa",
     367                          MsvAvNbDomainName, domain,
     368                          MsvAvEOL, "");
     369        }
    363370        return names_blob;
    364371}
    … …  
    516523}
    517524
     525NTSTATUS NTLMv2_RESPONSE_verify_netlogon_creds(const char *account_name,
     526                        const char *account_domain,
     527                        const DATA_BLOB response,
     528                        const struct netlogon_creds_CredentialState *creds,
     529                        const char *workgroup)
     530{
     531        TALLOC_CTX *frame = NULL;
     532        /* RespType + HiRespType */
     533        static const char *magic = "\x01\x01";
     534        int cmp;
     535        struct NTLMv2_RESPONSE v2_resp;
     536        enum ndr_err_code err;
     537        const struct AV_PAIR *av_nb_cn = NULL;
     538        const struct AV_PAIR *av_nb_dn = NULL;
     539
     540        if (response.length < 48) {
     541                /*
     542                 * NTLMv2_RESPONSE has at least 48 bytes.
     543                 */
     544                return NT_STATUS_OK;
     545        }
     546
     547        cmp = memcmp(response.data + 16, magic, 2);
     548        if (cmp != 0) {
     549                /*
     550                 * It doesn't look like a valid NTLMv2_RESPONSE
     551                 */
     552                return NT_STATUS_OK;
     553        }
     554
     555        frame = talloc_stackframe();
     556
     557        err = ndr_pull_struct_blob(&response, frame, &v2_resp,
     558                (ndr_pull_flags_fn_t)ndr_pull_NTLMv2_RESPONSE);
     559        if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     560                NTSTATUS status;
     561                status = ndr_map_error2ntstatus(err);
     562                DEBUG(2,("Failed to parse NTLMv2_RESPONSE "
     563                         "length %u - %s - %s\n",
     564                         (unsigned)response.length,
     565                         ndr_map_error2string(err),
     566                         nt_errstr(status)));
     567                dump_data(2, response.data, response.length);
     568                TALLOC_FREE(frame);
     569                return status;
     570        }
     571
     572        if (DEBUGLVL(10)) {
     573                NDR_PRINT_DEBUG(NTLMv2_RESPONSE, &v2_resp);
     574        }
     575
     576        /*
     577         * Make sure the netbios computer name in the
     578         * NTLMv2_RESPONSE matches the computer name
     579         * in the secure channel credentials for workstation
     580         * trusts.
     581         *
     582         * And the netbios domain name matches our
     583         * workgroup.
     584         *
     585         * This prevents workstations from requesting
     586         * the session key of NTLMSSP sessions of clients
     587         * to other hosts.
     588         */
     589        if (creds->secure_channel_type == SEC_CHAN_WKSTA) {
     590                av_nb_cn = ndr_ntlmssp_find_av(&v2_resp.Challenge.AvPairs,
     591                                               MsvAvNbComputerName);
     592                av_nb_dn = ndr_ntlmssp_find_av(&v2_resp.Challenge.AvPairs,
     593                                               MsvAvNbDomainName);
     594        }
     595
     596        if (av_nb_cn != NULL) {
     597                const char *v = NULL;
     598                char *a = NULL;
     599                size_t len;
     600
     601                v = av_nb_cn->Value.AvNbComputerName;
     602
     603                a = talloc_strdup(frame, creds->account_name);
     604                if (a == NULL) {
     605                        TALLOC_FREE(frame);
     606                        return NT_STATUS_NO_MEMORY;
     607                }
     608                len = strlen(a);
     609                if (len > 0 && a[len - 1] == '$') {
     610                        a[len - 1] = '\0';
     611                }
     612
     613#ifdef SAMBA4_INTERNAL_HEIMDAL /* smbtorture4 for make test */
     614                cmp = strcasecmp_m(a, v);
     615#else /* smbd */
     616                cmp = StrCaseCmp(a, v);
     617#endif
     618                if (cmp != 0) {
     619                        DEBUG(2,("%s: NTLMv2_RESPONSE with "
     620                                 "NbComputerName[%s] rejected "
     621                                 "for user[%s\\%s] "
     622                                 "against SEC_CHAN_WKSTA[%s/%s] "
     623                                 "in workgroup[%s]\n",
     624                                 __func__, v,
     625                                 account_domain,
     626                                 account_name,
     627                                 creds->computer_name,
     628                                 creds->account_name,
     629                                 workgroup));
     630                        TALLOC_FREE(frame);
     631                        return NT_STATUS_LOGON_FAILURE;
     632                }
     633        }
     634        if (av_nb_dn != NULL) {
     635                const char *v = NULL;
     636
     637                v = av_nb_dn->Value.AvNbDomainName;
     638
     639#ifdef SAMBA4_INTERNAL_HEIMDAL /* smbtorture4 for make test */
     640                cmp = strcasecmp_m(workgroup, v);
     641#else /* smbd */
     642                cmp = StrCaseCmp(workgroup, v);
     643#endif
     644                if (cmp != 0) {
     645                        DEBUG(2,("%s: NTLMv2_RESPONSE with "
     646                                 "NbDomainName[%s] rejected "
     647                                 "for user[%s\\%s] "
     648                                 "against SEC_CHAN_WKSTA[%s/%s] "
     649                                 "in workgroup[%s]\n",
     650                                 __func__, v,
     651                                 account_domain,
     652                                 account_name,
     653                                 creds->computer_name,
     654                                 creds->account_name,
     655                                 workgroup));
     656                        TALLOC_FREE(frame);
     657                        return NT_STATUS_LOGON_FAILURE;
     658                }
     659        }
     660
     661        TALLOC_FREE(frame);
     662        return NT_STATUS_OK;
     663}
     664
    518665/***********************************************************
    519666 encode a password buffer with a unicode password.  The buffer

  • vendor/current/libcli/auth/wscript_build

    r917 r919  
    2020bld.SAMBA_SUBSYSTEM('LIBCLI_AUTH',
    2121        source='credentials.c session.c smbencrypt.c smbdes.c',
    22         public_deps='MSRPC_PARSE',
     22        public_deps='MSRPC_PARSE NDR_NTLMSSP',
    2323        public_headers='credentials.h:domain_credentials.h'
    2424        )

  • vendor/current/librpc/idl/dcerpc.idl

    r860 r919  
    1010*/
    1111import "misc.idl";
     12
     13cpp_quote("extern const uint8_t DCERPC_SEC_VT_MAGIC[8];")
    1214
    1315interface dcerpc
    … …  
    454456
    455457        /* pfc_flags values */
    456         const uint8 DCERPC_PFC_FLAG_FIRST               = 0x01; /* First fragment */
    457         const uint8 DCERPC_PFC_FLAG_LAST                = 0x02; /* Last fragment */
    458         const uint8 DCERPC_PFC_FLAG_PENDING_CANCEL      = 0x04; /* Cancel was pending at sender */
    459         const uint8 DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN = DCERPC_PFC_FLAG_PENDING_CANCEL; /* depends on the pdu type */
    460         const uint8 DCERPC_PFC_FLAG_CONC_MPX            = 0x10; /* supports concurrent multiplexing of a single connection. */
    461         const uint8 DCERPC_PFC_FLAG_DID_NOT_EXECUTE     = 0x20; /* on a fault it means the server hasn't done anything */
    462         const uint8 DCERPC_PFC_FLAG_MAYBE               = 0x40; /* `maybe' call semantics requested */
    463         const uint8 DCERPC_PFC_FLAG_OBJECT_UUID         = 0x80; /* on valid guid is in the optional object field */
     458        typedef [bitmap8bit] bitmap {
     459                DCERPC_PFC_FLAG_FIRST           = 0x01, /* First fragment */
     460                DCERPC_PFC_FLAG_LAST            = 0x02, /* Last fragment */
     461                DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING = 0x04, /* depends on the pdu type */
     462                DCERPC_PFC_FLAG_CONC_MPX        = 0x10, /* supports concurrent multiplexing of a single connection. */
     463                DCERPC_PFC_FLAG_DID_NOT_EXECUTE = 0x20, /* on a fault it means the server hasn't done anything */
     464                DCERPC_PFC_FLAG_MAYBE           = 0x40, /* `maybe' call semantics requested */
     465                DCERPC_PFC_FLAG_OBJECT_UUID     = 0x80 /* on valid guid is in the optional object field */
     466        } dcerpc_pfc_flags;
     467
     468        /* Cancel was pending at sender */
     469        const int DCERPC_PFC_FLAG_PENDING_CANCEL =
     470                DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING;
     471        const ist DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN =
     472                DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING;
    464473
    465474        /* these offsets are needed by the signing code */
    … …  
    467476        const uint8 DCERPC_DREP_OFFSET     =  4;
    468477        const uint8 DCERPC_FRAG_LEN_OFFSET =  8;
     478        const uint32 DCERPC_FRAG_MAX_SIZE  = 5840;
    469479        const uint8 DCERPC_AUTH_LEN_OFFSET = 10;
    470480        const uint8 DCERPC_CALL_ID_OFFSET  = 12;
     481        const uint8 DCERPC_NCACN_PAYLOAD_OFFSET = 16;
     482        const uint32 DCERPC_NCACN_PAYLOAD_MAX_SIZE = 0x400000; /* 4 MByte */
    471483
    472484        /* little-endian flag */
    … …  
    477489                uint8 rpc_vers_minor;   /* Minor version */
    478490                dcerpc_pkt_type ptype;  /* Packet type */
    479                 uint8 pfc_flags;        /* Fragmentation flags */
     491                dcerpc_pfc_flags pfc_flags; /* Fragmentation flags */
    480492                uint8 drep[4];          /* NDR data representation */
    481493                uint16 frag_length;     /* Total length of fragment */
    … …  
    507519                [switch_is(ptype)] dcerpc_payload u;
    508520        } ncadg_packet;
     521
     522        typedef [bitmap16bit] bitmap {
     523                DCERPC_SEC_VT_COMMAND_ENUM  = 0x3FFF,
     524                DCERPC_SEC_VT_COMMAND_END   = 0x4000,
     525                DCERPC_SEC_VT_MUST_PROCESS  = 0x8000
     526        } dcerpc_sec_vt_command;
     527
     528        typedef [enum16bit] enum {
     529                DCERPC_SEC_VT_COMMAND_BITMASK1  = 0x0001,
     530                DCERPC_SEC_VT_COMMAND_PCONTEXT  = 0x0002,
     531                DCERPC_SEC_VT_COMMAND_HEADER2   = 0x0003
     532        } dcerpc_sec_vt_command_enum;
     533
     534        typedef [bitmap32bit] bitmap {
     535                DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING = 0x00000001
     536        } dcerpc_sec_vt_bitmask1;
     537
     538        typedef struct {
     539                ndr_syntax_id abstract_syntax;
     540                ndr_syntax_id transfer_syntax;
     541        } dcerpc_sec_vt_pcontext;
     542
     543        typedef struct {
     544                dcerpc_pkt_type ptype;  /* Packet type */
     545                [value(0)] uint8 reserved1;
     546                [value(0)] uint16 reserved2;
     547                uint8 drep[4];          /* NDR data representation */
     548                uint32 call_id;         /* Call identifier */
     549                uint16 context_id;
     550                uint16 opnum;
     551        } dcerpc_sec_vt_header2;
     552
     553        typedef [switch_type(dcerpc_sec_vt_command_enum),nodiscriminant] union {
     554        [case(DCERPC_SEC_VT_COMMAND_BITMASK1)] dcerpc_sec_vt_bitmask1 bitmask1;
     555        [case(DCERPC_SEC_VT_COMMAND_PCONTEXT)] dcerpc_sec_vt_pcontext pcontext;
     556        [case(DCERPC_SEC_VT_COMMAND_HEADER2)] dcerpc_sec_vt_header2 header2;
     557        [default,flag(NDR_REMAINING)] DATA_BLOB _unknown;
     558        } dcerpc_sec_vt_union;
     559
     560        typedef struct {
     561                dcerpc_sec_vt_command command;
     562                [switch_is(command & DCERPC_SEC_VT_COMMAND_ENUM)]
     563                        [subcontext(2),flag(NDR_SUBCONTEXT_NO_UNREAD_BYTES)]
     564                        dcerpc_sec_vt_union u;
     565        } dcerpc_sec_vt;
     566
     567        typedef [public,nopush,nopull] struct {
     568                uint16 count;
     569        } dcerpc_sec_vt_count;
     570
     571        /*
     572         * We assume that the whole verification trailer fits into
     573         * the last 1024 bytes after the stub data.
     574         *
     575         * There're currently only 3 commands defined and each should
     576         * only be used once.
     577         */
     578        const uint16 DCERPC_SEC_VT_MAX_SIZE = 1024;
     579
     580        typedef [public,flag(NDR_PAHEX)] struct {
     581                [flag(NDR_ALIGN4)] DATA_BLOB _pad;
     582                [value(DCERPC_SEC_VT_MAGIC)] uint8 magic[8];
     583                dcerpc_sec_vt_count count;
     584                dcerpc_sec_vt commands[count.count];
     585        } dcerpc_sec_verification_trailer;
    509586}

  • vendor/current/librpc/idl/idl_types.h

    r917 r919  
    4848#define NDR_RELATIVE_REVERSE LIBNDR_FLAG_RELATIVE_REVERSE
    4949#define NDR_NO_RELATIVE_REVERSE LIBNDR_FLAG_NO_RELATIVE_REVERSE
     50
     51#define NDR_SUBCONTEXT_NO_UNREAD_BYTES LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES

  • vendor/current/librpc/ndr/libndr.h

    r917 r919  
    125125#define LIBNDR_STRING_FLAGS             (0x7FFC)
    126126
     127/*
     128 * don't debug NDR_ERR_BUFSIZE failures,
     129 * as the available buffer might be incomplete.
     130 *
     131 * return NDR_ERR_INCOMPLETE_BUFFER instead.
     132 */
     133#define LIBNDR_FLAG_INCOMPLETE_BUFFER (1<<16)
     134
     135/*
     136 * This lets ndr_pull_subcontext_end() return
     137 * NDR_ERR_UNREAD_BYTES.
     138 */
     139#define LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES (1<<17)
     140
    127141/* set if relative pointers should *not* be marshalled in reverse order */
    128142#define LIBNDR_FLAG_NO_RELATIVE_REVERSE (1<<18)
    … …  
    164178/* useful macro for debugging */
    165179#define NDR_PRINT_DEBUG(type, p) ndr_print_debug((ndr_print_fn_t)ndr_print_ ##type, #p, p)
     180#define NDR_PRINT_DEBUGC(dbgc_class, type, p) ndr_print_debugc(dbgc_class, (ndr_print_fn_t)ndr_print_ ##type, #p, p)
    166181#define NDR_PRINT_UNION_DEBUG(type, level, p) ndr_print_union_debug((ndr_print_fn_t)ndr_print_ ##type, #p, level, p)
    167182#define NDR_PRINT_FUNCTION_DEBUG(type, flags, p) ndr_print_function_debug((ndr_print_function_t)ndr_print_ ##type, #type, flags, p)
    … …  
    200215        NDR_ERR_INVALID_POINTER,
    201216        NDR_ERR_UNREAD_BYTES,
    202         NDR_ERR_NDR64
     217        NDR_ERR_NDR64,
     218        NDR_ERR_FLAGS,
     219        NDR_ERR_INCOMPLETE_BUFFER
    203220};
    204221
    … …  
    218235/*
    219236  flags passed to control parse flow
     237  These are deliberately in a different range to the NDR_IN/NDR_OUT
     238  flags to catch mixups
    220239*/
    221 #define NDR_SCALARS 1
    222 #define NDR_BUFFERS 2
     240#define NDR_SCALARS    0x100
     241#define NDR_BUFFERS    0x200
    223242
    224243/*
    225   flags passed to ndr_print_*()
     244  flags passed to ndr_print_*() and ndr pull/push for functions
     245  These are deliberately in a different range to the NDR_SCALARS/NDR_BUFFERS
     246  flags to catch mixups
    226247*/
    227 #define NDR_IN 1
    228 #define NDR_OUT 2
    229 #define NDR_BOTH 3
    230 #define NDR_SET_VALUES 4
     248#define NDR_IN         0x10
     249#define NDR_OUT        0x20
     250#define NDR_BOTH       0x30
     251#define NDR_SET_VALUES 0x40
     252
     253
     254#define NDR_PULL_CHECK_FLAGS(ndr, ndr_flags) do { \
     255        if ((ndr_flags) & ~(NDR_SCALARS|NDR_BUFFERS)) { \
     256                return ndr_pull_error(ndr, NDR_ERR_FLAGS, "Invalid pull struct ndr_flags 0x%x", ndr_flags); \
     257        } \
     258} while (0)
     259
     260#define NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags) do { \
     261        if ((ndr_flags) & ~(NDR_SCALARS|NDR_BUFFERS)) \
     262                return ndr_push_error(ndr, NDR_ERR_FLAGS, "Invalid push struct ndr_flags 0x%x", ndr_flags); \
     263} while (0)
     264
     265#define NDR_PULL_CHECK_FN_FLAGS(ndr, flags) do { \
     266        if ((flags) & ~(NDR_BOTH|NDR_SET_VALUES)) { \
     267                return ndr_pull_error(ndr, NDR_ERR_FLAGS, "Invalid fn pull flags 0x%x", flags); \
     268        } \
     269} while (0)
     270
     271#define NDR_PUSH_CHECK_FN_FLAGS(ndr, flags) do { \
     272        if ((flags) & ~(NDR_BOTH|NDR_SET_VALUES)) \
     273                return ndr_push_error(ndr, NDR_ERR_FLAGS, "Invalid fn push flags 0x%x", flags); \
     274} while (0)
    231275
    232276#define NDR_PULL_NEED_BYTES(ndr, n) do { \
    233277        if (unlikely((n) > ndr->data_size || ndr->offset + (n) > ndr->data_size)) { \
     278                if (ndr->flags & LIBNDR_FLAG_INCOMPLETE_BUFFER) { \
     279                        uint32_t _available = ndr->data_size - ndr->offset; \
     280                        uint32_t _missing = n - _available; \
     281                        ndr->relative_highest_offset = _missing; \
     282                } \
    234283                return ndr_pull_error(ndr, NDR_ERR_BUFSIZE, "Pull bytes %u (%s)", (unsigned)n, __location__); \
    235284        } \
    … …  
    248297        } \
    249298        if (unlikely(ndr->offset > ndr->data_size)) {                   \
     299                if (ndr->flags & LIBNDR_FLAG_INCOMPLETE_BUFFER) { \
     300                        uint32_t _missing = ndr->offset - ndr->data_size; \
     301                        ndr->relative_highest_offset = _missing; \
     302                } \
    250303                return ndr_pull_error(ndr, NDR_ERR_BUFSIZE, "Pull align %u", (unsigned)n); \
    251304        } \
    … …  
    403456void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid);
    404457bool ndr_syntax_id_equal(const struct ndr_syntax_id *i1, const struct ndr_syntax_id *i2);
     458char *ndr_syntax_id_to_string(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *id);
     459bool ndr_syntax_id_from_string(const char *s, struct ndr_syntax_id *id);
    405460enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p, ndr_push_flags_fn_t fn);
    406461enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, uint32_t level, ndr_push_flags_fn_t fn);
    … …  
    425480size_t ndr_align_size(uint32_t offset, size_t n);
    426481struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
     482enum ndr_err_code ndr_pull_append(struct ndr_pull *ndr, DATA_BLOB *blob);
     483enum ndr_err_code ndr_pull_pop(struct ndr_pull *ndr);
    427484enum ndr_err_code ndr_pull_advance(struct ndr_pull *ndr, uint32_t size);
    428485struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx);
    … …  
    430487enum ndr_err_code ndr_push_expand(struct ndr_push *ndr, uint32_t extra_size);
    431488void ndr_print_debug_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
     489void ndr_print_debugc_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
    432490void ndr_print_printf_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
    433491void ndr_print_string_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
    434492void ndr_print_debug(ndr_print_fn_t fn, const char *name, void *ptr);
     493void ndr_print_debugc(int dbgc_class, ndr_print_fn_t fn, const char *name, void *ptr);
    435494void ndr_print_union_debug(ndr_print_fn_t fn, const char *name, uint32_t level, void *ptr);
    436495void ndr_print_function_debug(ndr_print_function_t fn, const char *name, int flags, void *ptr);

  • vendor/current/librpc/ndr/ndr.c

    r917 r919  
    7878}
    7979
     80_PUBLIC_ enum ndr_err_code ndr_pull_append(struct ndr_pull *ndr, DATA_BLOB *blob)
     81{
     82        enum ndr_err_code ndr_err;
     83        DATA_BLOB b;
     84        uint32_t append = 0;
     85        bool ok;
     86
     87        if (blob->length == 0) {
     88                return NDR_ERR_SUCCESS;
     89        }
     90
     91        ndr_err = ndr_token_retrieve(&ndr->array_size_list, ndr, &append);
     92        if (ndr_err == NDR_ERR_TOKEN) {
     93                append = 0;
     94                ndr_err = NDR_ERR_SUCCESS;
     95        }
     96        NDR_CHECK(ndr_err);
     97
     98        if (ndr->data_size == 0) {
     99                ndr->data = NULL;
     100                append = UINT32_MAX;
     101        }
     102
     103        if (append == UINT32_MAX) {
     104                /*
     105                 * append == UINT32_MAX means that
     106                 * ndr->data is either NULL or a valid
     107                 * talloc child of ndr, which means
     108                 * we can use data_blob_append() without
     109                 * data_blob_talloc() of the existing callers data
     110                 */
     111                b = data_blob_const(ndr->data, ndr->data_size);
     112        } else {
     113                b = data_blob_talloc(ndr, ndr->data, ndr->data_size);
     114                if (b.data == NULL) {
     115                        return ndr_pull_error(ndr, NDR_ERR_ALLOC, "%s", __location__);
     116                }
     117        }
     118
     119        ok = data_blob_append(ndr, &b, blob->data, blob->length);
     120        if (!ok) {
     121                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "%s", __location__);
     122        }
     123
     124        ndr->data = b.data;
     125        ndr->data_size = b.length;
     126
     127        return ndr_token_store(ndr, &ndr->array_size_list, ndr, UINT32_MAX);
     128}
     129
     130_PUBLIC_ enum ndr_err_code ndr_pull_pop(struct ndr_pull *ndr)
     131{
     132        uint32_t skip = 0;
     133        uint32_t append = 0;
     134
     135        if (ndr->relative_base_offset != 0) {
     136                return ndr_pull_error(ndr, NDR_ERR_RELATIVE,
     137                                      "%s", __location__);
     138        }
     139        if (ndr->relative_highest_offset != 0) {
     140                return ndr_pull_error(ndr, NDR_ERR_RELATIVE,
     141                                      "%s", __location__);
     142        }
     143        if (ndr->relative_list != NULL) {
     144                return ndr_pull_error(ndr, NDR_ERR_RELATIVE,
     145                                      "%s", __location__);
     146        }
     147        if (ndr->relative_base_list != NULL) {
     148                return ndr_pull_error(ndr, NDR_ERR_RELATIVE,
     149                                      "%s", __location__);
     150        }
     151
     152        /*
     153         * we need to keep up to 7 bytes
     154         * in order to get the aligment right.
     155         */
     156        skip = ndr->offset & 0xFFFFFFF8;
     157
     158        if (skip == 0) {
     159                return NDR_ERR_SUCCESS;
     160        }
     161
     162        ndr->offset -= skip;
     163        ndr->data_size -= skip;
     164
     165        append = ndr_token_peek(&ndr->array_size_list, ndr);
     166        if (append != UINT32_MAX) {
     167                /*
     168                 * here we assume, that ndr->data is not a
     169                 * talloc child of ndr.
     170                 */
     171                ndr->data += skip;
     172                return NDR_ERR_SUCCESS;
     173        }
     174
     175        memmove(ndr->data, ndr->data + skip, ndr->data_size);
     176
     177        ndr->data = talloc_realloc(ndr, ndr->data, uint8_t, ndr->data_size);
     178        if (ndr->data_size != 0 && ndr->data == NULL) {
     179                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "%s", __location__);
     180        }
     181
     182        return NDR_ERR_SUCCESS;
     183}
     184
    80185/*
    81186  advance by 'size' bytes
    … …  
    166271
    167272        return NDR_ERR_SUCCESS;
     273}
     274
     275_PUBLIC_ void ndr_print_debugc_helper(struct ndr_print *ndr, const char *format, ...)
     276{
     277        va_list ap;
     278        char *s = NULL;
     279        uint32_t i;
     280        int ret;
     281        int dbgc_class;
     282
     283        va_start(ap, format);
     284        ret = vasprintf(&s, format, ap);
     285        va_end(ap);
     286
     287        if (ret == -1) {
     288                return;
     289        }
     290
     291        dbgc_class = *(int *)ndr->private_data;
     292
     293        if (ndr->no_newline) {
     294                DEBUGADDC(dbgc_class, 1,("%s", s));
     295                free(s);
     296                return;
     297        }
     298
     299        for (i=0;i<ndr->depth;i++) {
     300                DEBUGADDC(dbgc_class, 1,("    "));
     301        }
     302
     303        DEBUGADDC(dbgc_class, 1,("%s\n", s));
     304        free(s);
    168305}
    169306
    … …  
    236373                                                                  "\n");
    237374        }
     375}
     376
     377/*
     378  a useful helper function for printing idl structures via DEBUGC()
     379*/
     380_PUBLIC_ void ndr_print_debugc(int dbgc_class, ndr_print_fn_t fn, const char *name, void *ptr)
     381{
     382        struct ndr_print *ndr;
     383
     384        DEBUGC(dbgc_class, 1,(" "));
     385
     386        ndr = talloc_zero(NULL, struct ndr_print);
     387        if (!ndr) return;
     388        ndr->private_data = &dbgc_class;
     389        ndr->print = ndr_print_debugc_helper;
     390        ndr->depth = 1;
     391        ndr->flags = 0;
     392        fn(ndr, name, ptr);
     393        talloc_free(ndr);
    238394}
    239395
    … …  
    403559        va_list ap;
    404560        int ret;
     561
     562        if (ndr->flags & LIBNDR_FLAG_INCOMPLETE_BUFFER) {
     563                switch (ndr_err) {
     564                case NDR_ERR_BUFSIZE:
     565                        return NDR_ERR_INCOMPLETE_BUFFER;
     566                default:
     567                        break;
     568                }
     569        }
    405570
    406571        va_start(ap, format);
    … …  
    558723                break;
    559724        }
     725        case 0xFFFFFFFF:
     726                /*
     727                 * a shallow copy like subcontext
     728                 * useful for DCERPC pipe chunks.
     729                 */
     730                subndr = talloc_zero(ndr, struct ndr_pull);
     731                NDR_ERR_HAVE_NO_MEMORY(subndr);
     732
     733                subndr->flags           = ndr->flags;
     734                subndr->current_mem_ctx = ndr->current_mem_ctx;
     735                subndr->data            = ndr->data;
     736                subndr->offset          = ndr->offset;
     737                subndr->data_size       = ndr->data_size;
     738
     739                *_subndr = subndr;
     740                return NDR_ERR_SUCCESS;
     741
    560742        default:
    561743                return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) header_size %d",
    … …  
    590772{
    591773        uint32_t advance;
    592         if (size_is >= 0) {
     774        uint32_t highest_ofs;
     775
     776        if (header_size == 0xFFFFFFFF) {
     777                advance = subndr->offset - ndr->offset;
     778        } else if (size_is >= 0) {
    593779                advance = size_is;
    594780        } else if (header_size > 0) {
    … …  
    597783                advance = subndr->offset;
    598784        }
     785
     786        if (subndr->offset > ndr->relative_highest_offset) {
     787                highest_ofs = subndr->offset;
     788        } else {
     789                highest_ofs = subndr->relative_highest_offset;
     790        }
     791        if (!(subndr->flags & LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES)) {
     792                /*
     793                 * avoid an error unless SUBCONTEXT_NO_UNREAD_BYTES is specified
     794                 */
     795                highest_ofs = advance;
     796        }
     797        if (highest_ofs < advance) {
     798                return ndr_pull_error(subndr, NDR_ERR_UNREAD_BYTES,
     799                                      "not all bytes consumed ofs[%u] advance[%u]",
     800                                      highest_ofs, advance);
     801        }
     802
    599803        NDR_CHECK(ndr_pull_advance(ndr, advance));
    600804        return NDR_ERR_SUCCESS;
    … …  
    14411645        { NDR_ERR_UNREAD_BYTES, "Unread Bytes" },
    14421646        { NDR_ERR_NDR64, "NDR64 assertion error" },
     1647        { NDR_ERR_INCOMPLETE_BUFFER, "Incomplete Buffer" },
    14431648        { 0, NULL }
    14441649};

  • vendor/current/librpc/ndr/ndr_basic.c

    r917 r919  
    6262_PUBLIC_ enum ndr_err_code ndr_pull_int8(struct ndr_pull *ndr, int ndr_flags, int8_t *v)
    6363{
     64        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    6465        NDR_PULL_NEED_BYTES(ndr, 1);
    6566        *v = (int8_t)CVAL(ndr->data, ndr->offset);
    … …  
    7374_PUBLIC_ enum ndr_err_code ndr_pull_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v)
    7475{
     76        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    7577        NDR_PULL_NEED_BYTES(ndr, 1);
    7678        *v = CVAL(ndr->data, ndr->offset);
    … …  
    8486_PUBLIC_ enum ndr_err_code ndr_pull_int16(struct ndr_pull *ndr, int ndr_flags, int16_t *v)
    8587{
     88        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    8689        NDR_PULL_ALIGN(ndr, 2);
    8790        NDR_PULL_NEED_BYTES(ndr, 2);
    … …  
    9699_PUBLIC_ enum ndr_err_code ndr_pull_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
    97100{
     101        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    98102        NDR_PULL_ALIGN(ndr, 2);
    99103        NDR_PULL_NEED_BYTES(ndr, 2);
    … …  
    108112_PUBLIC_ enum ndr_err_code ndr_pull_uint1632(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
    109113{
     114        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    110115        if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
    111116                uint32_t v32 = 0;
    … …  
    126131_PUBLIC_ enum ndr_err_code ndr_pull_int32(struct ndr_pull *ndr, int ndr_flags, int32_t *v)
    127132{
     133        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    128134        NDR_PULL_ALIGN(ndr, 4);
    129135        NDR_PULL_NEED_BYTES(ndr, 4);
    … …  
    138144_PUBLIC_ enum ndr_err_code ndr_pull_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
    139145{
     146        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    140147        NDR_PULL_ALIGN(ndr, 4);
    141148        NDR_PULL_NEED_BYTES(ndr, 4);
    … …  
    152159        uint64_t v64;
    153160        enum ndr_err_code err;
     161        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    154162        if (likely(!(ndr->flags & LIBNDR_FLAG_NDR64))) {
    155163                return ndr_pull_uint32(ndr, ndr_flags, v);
    … …  
    170178_PUBLIC_ enum ndr_err_code ndr_pull_double(struct ndr_pull *ndr, int ndr_flags, double *v)
    171179{
     180        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    172181        NDR_PULL_ALIGN(ndr, 8);
    173182        NDR_PULL_NEED_BYTES(ndr, 8);
    … …  
    218227_PUBLIC_ enum ndr_err_code ndr_pull_udlong(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
    219228{
     229        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    220230        NDR_PULL_ALIGN(ndr, 4);
    221231        NDR_PULL_NEED_BYTES(ndr, 8);
    … …  
    231241_PUBLIC_ enum ndr_err_code ndr_pull_udlongr(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
    232242{
     243        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    233244        NDR_PULL_ALIGN(ndr, 4);
    234245        NDR_PULL_NEED_BYTES(ndr, 8);
    … …  
    265276{
    266277        uintptr_t h;
     278        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    267279        NDR_PULL_ALIGN(ndr, sizeof(h));
    268280        NDR_PULL_NEED_BYTES(ndr, sizeof(h));
    … …  
    279291{
    280292        uint32_t v;
     293        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    281294        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
    282295        *status = NT_STATUS(v);
    … …  
    303316{
    304317        uint32_t v;
     318        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    305319        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
    306320        *status = W_ERROR(v);
    … …  
    415429_PUBLIC_ enum ndr_err_code ndr_pull_array_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *data, uint32_t n)
    416430{
     431        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    417432        if (!(ndr_flags & NDR_SCALARS)) {
    418433                return NDR_ERR_SUCCESS;
    … …  
    426441_PUBLIC_ enum ndr_err_code ndr_push_int8(struct ndr_push *ndr, int ndr_flags, int8_t v)
    427442{
     443        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    428444        NDR_PUSH_NEED_BYTES(ndr, 1);
    429445        SCVAL(ndr->data, ndr->offset, (uint8_t)v);
    … …  
    437453_PUBLIC_ enum ndr_err_code ndr_push_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v)
    438454{
     455        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    439456        NDR_PUSH_NEED_BYTES(ndr, 1);
    440457        SCVAL(ndr->data, ndr->offset, v);
    … …  
    448465_PUBLIC_ enum ndr_err_code ndr_push_int16(struct ndr_push *ndr, int ndr_flags, int16_t v)
    449466{
     467        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    450468        NDR_PUSH_ALIGN(ndr, 2);
    451469        NDR_PUSH_NEED_BYTES(ndr, 2);
    … …  
    460478_PUBLIC_ enum ndr_err_code ndr_push_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
    461479{
     480        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    462481        NDR_PUSH_ALIGN(ndr, 2);
    463482        NDR_PUSH_NEED_BYTES(ndr, 2);
    … …  
    483502_PUBLIC_ enum ndr_err_code ndr_push_int32(struct ndr_push *ndr, int ndr_flags, int32_t v)
    484503{
     504        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    485505        NDR_PUSH_ALIGN(ndr, 4);
    486506        NDR_PUSH_NEED_BYTES(ndr, 4);
    … …  
    495515_PUBLIC_ enum ndr_err_code ndr_push_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
    496516{
     517        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    497518        NDR_PUSH_ALIGN(ndr, 4);
    498519        NDR_PUSH_NEED_BYTES(ndr, 4);
    … …  
    518539_PUBLIC_ enum ndr_err_code ndr_push_udlong(struct ndr_push *ndr, int ndr_flags, uint64_t v)
    519540{
     541        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    520542        NDR_PUSH_ALIGN(ndr, 4);
    521543        NDR_PUSH_NEED_BYTES(ndr, 8);
    … …  
    531553_PUBLIC_ enum ndr_err_code ndr_push_udlongr(struct ndr_push *ndr, int ndr_flags, uint64_t v)
    532554{
     555        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    533556        NDR_PUSH_ALIGN(ndr, 4);
    534557        NDR_PUSH_NEED_BYTES(ndr, 8);
    … …  
    564587_PUBLIC_ enum ndr_err_code ndr_push_double(struct ndr_push *ndr, int ndr_flags, double v)
    565588{
     589        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    566590        NDR_PUSH_ALIGN(ndr, 8);
    567591        NDR_PUSH_NEED_BYTES(ndr, 8);
    … …  
    577601{
    578602        uintptr_t h = (intptr_t)v;
     603        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    579604        NDR_PUSH_ALIGN(ndr, sizeof(h));
    580605        NDR_PUSH_NEED_BYTES(ndr, sizeof(h));
    … …  
    687712_PUBLIC_ enum ndr_err_code ndr_push_array_uint8(struct ndr_push *ndr, int ndr_flags, const uint8_t *data, uint32_t n)
    688713{
     714        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    689715        if (!(ndr_flags & NDR_SCALARS)) {
    690716                return NDR_ERR_SUCCESS;
    … …  
    739765_PUBLIC_ enum ndr_err_code ndr_push_NTTIME(struct ndr_push *ndr, int ndr_flags, NTTIME t)
    740766{
     767        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    741768        NDR_CHECK(ndr_push_udlong(ndr, ndr_flags, t));
    742769        return NDR_ERR_SUCCESS;
    … …  
    748775_PUBLIC_ enum ndr_err_code ndr_pull_NTTIME(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
    749776{
     777        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    750778        NDR_CHECK(ndr_pull_udlong(ndr, ndr_flags, t));
    751779        return NDR_ERR_SUCCESS;
    … …  
    757785_PUBLIC_ enum ndr_err_code ndr_push_NTTIME_1sec(struct ndr_push *ndr, int ndr_flags, NTTIME t)
    758786{
     787        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    759788        t /= 10000000;
    760789        NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
    … …  
    767796_PUBLIC_ enum ndr_err_code ndr_pull_NTTIME_1sec(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
    768797{
     798        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    769799        NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
    770800        (*t) *= 10000000;
    … …  
    777807_PUBLIC_ enum ndr_err_code ndr_pull_NTTIME_hyper(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
    778808{
     809        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
    779810        NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
    780811        return NDR_ERR_SUCCESS;
    … …  
    786817_PUBLIC_ enum ndr_err_code ndr_push_NTTIME_hyper(struct ndr_push *ndr, int ndr_flags, NTTIME t)
    787818{
     819        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    788820        NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
    789821        return NDR_ERR_SUCCESS;
    … …  
    815847_PUBLIC_ enum ndr_err_code ndr_push_uid_t(struct ndr_push *ndr, int ndr_flags, uid_t u)
    816848{
     849        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    817850        return ndr_push_hyper(ndr, NDR_SCALARS, (uint64_t)u);
    818851}
    … …  
    840873_PUBLIC_ enum ndr_err_code ndr_push_gid_t(struct ndr_push *ndr, int ndr_flags, gid_t g)
    841874{
     875        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
    842876        return ndr_push_hyper(ndr, NDR_SCALARS, (uint64_t)g);
    843877}

  • vendor/current/librpc/ndr/ndr_misc.c

    r414 r919  
    3636                && (i1->if_version == i2->if_version);
    3737}
     38
     39_PUBLIC_ char *ndr_syntax_id_to_string(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *id)
     40{
     41        return talloc_asprintf(mem_ctx,
     42                               "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x/0x%08x",
     43                               id->uuid.time_low, id->uuid.time_mid,
     44                               id->uuid.time_hi_and_version,
     45                               id->uuid.clock_seq[0],
     46                               id->uuid.clock_seq[1],
     47                               id->uuid.node[0], id->uuid.node[1],
     48                               id->uuid.node[2], id->uuid.node[3],
     49                               id->uuid.node[4], id->uuid.node[5],
     50                               (unsigned)id->if_version);
     51}
     52
     53_PUBLIC_ bool ndr_syntax_id_from_string(const char *s, struct ndr_syntax_id *id)
     54{
     55        int ret;
     56        size_t i;
     57        uint32_t time_low;
     58        uint32_t time_mid, time_hi_and_version;
     59        uint32_t clock_seq[2];
     60        uint32_t node[6];
     61        uint32_t if_version;
     62
     63        ret = sscanf(s,
     64                     "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x/0x%08x",
     65                     &time_low, &time_mid, &time_hi_and_version,
     66                     &clock_seq[0], &clock_seq[1],
     67                     &node[0], &node[1], &node[2], &node[3], &node[4], &node[5],
     68                     &if_version);
     69        if (ret != 12) {
     70                return false;
     71        }
     72
     73        id->uuid.time_low = time_low;
     74        id->uuid.time_mid = time_mid;
     75        id->uuid.time_hi_and_version = time_hi_and_version;
     76        id->uuid.clock_seq[0] = clock_seq[0];
     77        id->uuid.clock_seq[1] = clock_seq[1];
     78        for (i=0; i<6; i++) {
     79                id->uuid.node[i] = node[i];
     80        }
     81        id->if_version = if_version;
     82
     83        return true;
     84}

  • vendor/current/librpc/ndr/ndr_ntlmssp.c

    r917 r919  
    177177}
    178178
     179_PUBLIC_ struct AV_PAIR *ndr_ntlmssp_find_av(const struct AV_PAIR_LIST *av_list,
     180                                             enum ntlmssp_AvId AvId)
     181{
     182        struct AV_PAIR *res = NULL;
     183        uint32_t i = 0;
    179184
     185        for (i = 0; i < av_list->count; i++) {
     186                if (av_list->pair[i].AvId != AvId) {
     187                        continue;
     188                }
     189
     190                res = discard_const_p(struct AV_PAIR, &av_list->pair[i]);
     191                break;
     192        }
     193
     194        return res;
     195}

  • vendor/current/librpc/ndr/ndr_ntlmssp.h

    r917 r919  
    3232_PUBLIC_ void ndr_print_ntlmssp_Version(struct ndr_print *ndr, const char *name, const union ntlmssp_Version *r);
    3333
     34_PUBLIC_ struct AV_PAIR *ndr_ntlmssp_find_av(const struct AV_PAIR_LIST *av_list,
     35                                             enum ntlmssp_AvId AvId);

  • vendor/current/librpc/rpc/dcerpc_util.c

    r860 r919  
    2828#include "librpc/gen_ndr/ndr_dcerpc.h"
    2929#include "rpc_common.h"
     30#include "lib/util/bitmap.h"
    3031
    3132/* we need to be able to get/set the fragment length without doing a full
    … …  
    9293* @return               - A NTSTATUS error code.
    9394*/
    94 NTSTATUS dcerpc_pull_auth_trailer(struct ncacn_packet *pkt,
     95NTSTATUS dcerpc_pull_auth_trailer(const struct ncacn_packet *pkt,
    9596                                  TALLOC_CTX *mem_ctx,
    96                                   DATA_BLOB *pkt_trailer,
     97                                  const DATA_BLOB *pkt_trailer,
    9798                                  struct dcerpc_auth *auth,
    98                                   uint32_t *auth_length,
     99                                  uint32_t *_auth_length,
    99100                                  bool auth_data_only)
    100101{
    101102        struct ndr_pull *ndr;
    102103        enum ndr_err_code ndr_err;
    103         uint32_t data_and_pad;
    104 
    105         data_and_pad = pkt_trailer->length
    106                         - (DCERPC_AUTH_TRAILER_LENGTH + pkt->auth_length);
    107 
    108         /* paranoia check for pad size. This would be caught anyway by
    109            the ndr_pull_advance() a few lines down, but it scared
    110            Jeremy enough for him to call me, so we might as well check
    111            it now, just to prevent someone posting a bogus YouTube
    112            video in the future.
    113         */
    114         if (data_and_pad > pkt_trailer->length) {
    115                 return NT_STATUS_INFO_LENGTH_MISMATCH;
    116         }
    117 
    118         *auth_length = pkt_trailer->length - data_and_pad;
     104        uint16_t data_and_pad;
     105        uint16_t auth_length;
     106        uint32_t tmp_length;
     107
     108        ZERO_STRUCTP(auth);
     109        if (_auth_length != NULL) {
     110                *_auth_length = 0;
     111        }
     112
     113        /* Paranoia checks for auth_length. The caller should check this... */
     114        if (pkt->auth_length == 0) {
     115                return NT_STATUS_INTERNAL_ERROR;
     116        }
     117
     118        /* Paranoia checks for auth_length. The caller should check this... */
     119        if (pkt->auth_length > pkt->frag_length) {
     120                return NT_STATUS_INTERNAL_ERROR;
     121        }
     122        tmp_length = DCERPC_NCACN_PAYLOAD_OFFSET;
     123        tmp_length += DCERPC_AUTH_TRAILER_LENGTH;
     124        tmp_length += pkt->auth_length;
     125        if (tmp_length > pkt->frag_length) {
     126                return NT_STATUS_INTERNAL_ERROR;
     127        }
     128        if (pkt_trailer->length > UINT16_MAX) {
     129                return NT_STATUS_INTERNAL_ERROR;
     130        }
     131
     132        auth_length = DCERPC_AUTH_TRAILER_LENGTH + pkt->auth_length;
     133        if (pkt_trailer->length < auth_length) {
     134                return NT_STATUS_RPC_PROTOCOL_ERROR;
     135        }
     136
     137        data_and_pad = pkt_trailer->length - auth_length;
    119138
    120139        ndr = ndr_pull_init_blob(pkt_trailer, mem_ctx);
    … …  
    136155        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
    137156                talloc_free(ndr);
     157                ZERO_STRUCTP(auth);
    138158                return ndr_map_error2ntstatus(ndr_err);
    139159        }
    140160
    141         if (auth_data_only && data_and_pad != auth->auth_pad_length) {
    142                 DEBUG(1, (__location__ ": WARNING: pad length mismatch. "
     161        if (data_and_pad < auth->auth_pad_length) {
     162                DEBUG(1, (__location__ ": ERROR: pad length mismatch. "
    143163                          "Calculated %u  got %u\n",
    144164                          (unsigned)data_and_pad,
    145165                          (unsigned)auth->auth_pad_length));
     166                talloc_free(ndr);
     167                ZERO_STRUCTP(auth);
     168                return NT_STATUS_RPC_PROTOCOL_ERROR;
     169        }
     170
     171        if (auth_data_only && data_and_pad != auth->auth_pad_length) {
     172                DEBUG(1, (__location__ ": ERROR: pad length mismatch. "
     173                          "Calculated %u  got %u\n",
     174                          (unsigned)data_and_pad,
     175                          (unsigned)auth->auth_pad_length));
     176                talloc_free(ndr);
     177                ZERO_STRUCTP(auth);
     178                return NT_STATUS_RPC_PROTOCOL_ERROR;
    146179        }
    147180
    … …  
    151184        talloc_steal(mem_ctx, auth->credentials.data);
    152185        talloc_free(ndr);
     186
     187        if (_auth_length != NULL) {
     188                *_auth_length = auth_length;
     189        }
     190
     191        return NT_STATUS_OK;
     192}
     193
     194/**
     195* @brief        Verify the fields in ncacn_packet header.
     196*
     197* @param pkt            - The ncacn_packet strcuture
     198* @param ptype          - The expected PDU type
     199* @param max_auth_info  - The maximum size of a possible auth trailer
     200* @param required_flags - The required flags for the pdu.
     201* @param optional_flags - The possible optional flags for the pdu.
     202*
     203* @return               - A NTSTATUS error code.
     204*/
     205NTSTATUS dcerpc_verify_ncacn_packet_header(const struct ncacn_packet *pkt,
     206                                           enum dcerpc_pkt_type ptype,
     207                                           size_t max_auth_info,
     208                                           uint8_t required_flags,
     209                                           uint8_t optional_flags)
     210{
     211        if (pkt->rpc_vers != 5) {
     212                return NT_STATUS_RPC_PROTOCOL_ERROR;
     213        }
     214
     215        if (pkt->rpc_vers_minor != 0) {
     216                return NT_STATUS_RPC_PROTOCOL_ERROR;
     217        }
     218
     219        if (pkt->auth_length > pkt->frag_length) {
     220                return NT_STATUS_RPC_PROTOCOL_ERROR;
     221        }
     222
     223        if (pkt->ptype != ptype) {
     224                return NT_STATUS_RPC_PROTOCOL_ERROR;
     225        }
     226
     227        if (max_auth_info > UINT16_MAX) {
     228                return NT_STATUS_INTERNAL_ERROR;
     229        }
     230
     231        if (pkt->auth_length > 0) {
     232                size_t max_auth_length;
     233
     234                if (max_auth_info <= DCERPC_AUTH_TRAILER_LENGTH) {
     235                        return NT_STATUS_RPC_PROTOCOL_ERROR;
     236                }
     237                max_auth_length = max_auth_info - DCERPC_AUTH_TRAILER_LENGTH;
     238
     239                if (pkt->auth_length > max_auth_length) {
     240                        return NT_STATUS_RPC_PROTOCOL_ERROR;
     241                }
     242        }
     243
     244        if ((pkt->pfc_flags & required_flags) != required_flags) {
     245                return NT_STATUS_RPC_PROTOCOL_ERROR;
     246        }
     247        if (pkt->pfc_flags & ~(optional_flags|required_flags)) {
     248                return NT_STATUS_RPC_PROTOCOL_ERROR;
     249        }
     250
     251        if (pkt->drep[0] & ~DCERPC_DREP_LE) {
     252                return NT_STATUS_RPC_PROTOCOL_ERROR;
     253        }
     254        if (pkt->drep[1] != 0) {
     255                return NT_STATUS_RPC_PROTOCOL_ERROR;
     256        }
     257        if (pkt->drep[2] != 0) {
     258                return NT_STATUS_RPC_PROTOCOL_ERROR;
     259        }
     260        if (pkt->drep[3] != 0) {
     261                return NT_STATUS_RPC_PROTOCOL_ERROR;
     262        }
    153263
    154264        return NT_STATUS_OK;
    … …  
    342452        return NT_STATUS_OK;
    343453}
     454
     455struct dcerpc_sec_vt_header2 dcerpc_sec_vt_header2_from_ncacn_packet(const struct ncacn_packet *pkt)
     456{
     457        struct dcerpc_sec_vt_header2 ret;
     458
     459        ZERO_STRUCT(ret);
     460        ret.ptype = pkt->ptype;
     461        memcpy(&ret.drep, pkt->drep, sizeof(ret.drep));
     462        ret.call_id = pkt->call_id;
     463
     464        switch (pkt->ptype) {
     465        case DCERPC_PKT_REQUEST:
     466                ret.context_id = pkt->u.request.context_id;
     467                ret.opnum      = pkt->u.request.opnum;
     468                break;
     469
     470        case DCERPC_PKT_RESPONSE:
     471                ret.context_id = pkt->u.response.context_id;
     472                break;
     473
     474        case DCERPC_PKT_FAULT:
     475                ret.context_id = pkt->u.fault.context_id;
     476                break;
     477
     478        default:
     479                break;
     480        }
     481
     482        return ret;
     483}
     484
     485bool dcerpc_sec_vt_header2_equal(const struct dcerpc_sec_vt_header2 *v1,
     486                                 const struct dcerpc_sec_vt_header2 *v2)
     487{
     488        if (v1->ptype != v2->ptype) {
     489                return false;
     490        }
     491
     492        if (memcmp(v1->drep, v2->drep, sizeof(v1->drep)) != 0) {
     493                return false;
     494        }
     495
     496        if (v1->call_id != v2->call_id) {
     497                return false;
     498        }
     499
     500        if (v1->context_id != v2->context_id) {
     501                return false;
     502        }
     503
     504        if (v1->opnum != v2->opnum) {
     505                return false;
     506        }
     507
     508        return true;
     509}
     510
     511static bool dcerpc_sec_vt_is_valid(const struct dcerpc_sec_verification_trailer *r)
     512{
     513        bool ret = false;
     514        TALLOC_CTX *frame = talloc_stackframe();
     515        struct bitmap *commands_seen;
     516        int i;
     517
     518        if (r->count.count == 0) {
     519                ret = true;
     520                goto done;
     521        }
     522
     523        if (memcmp(r->magic, DCERPC_SEC_VT_MAGIC, sizeof(r->magic)) != 0) {
     524                goto done;
     525        }
     526
     527        commands_seen = bitmap_talloc(frame, DCERPC_SEC_VT_COMMAND_ENUM + 1);
     528        if (commands_seen == NULL) {
     529                goto done;
     530        }
     531
     532        for (i=0; i < r->count.count; i++) {
     533                enum dcerpc_sec_vt_command_enum cmd =
     534                        r->commands[i].command & DCERPC_SEC_VT_COMMAND_ENUM;
     535
     536                if (bitmap_query(commands_seen, cmd)) {
     537                        /* Each command must appear at most once. */
     538                        goto done;
     539                }
     540                bitmap_set(commands_seen, cmd);
     541
     542                switch (cmd) {
     543                case DCERPC_SEC_VT_COMMAND_BITMASK1:
     544                case DCERPC_SEC_VT_COMMAND_PCONTEXT:
     545                case DCERPC_SEC_VT_COMMAND_HEADER2:
     546                        break;
     547                default:
     548                        if ((r->commands[i].u._unknown.length % 4) != 0) {
     549                                goto done;
     550                        }
     551                        break;
     552                }
     553        }
     554        ret = true;
     555done:
     556        TALLOC_FREE(frame);
     557        return ret;
     558}
     559
     560#define CHECK(msg, ok)                                          \
     561do {                                                            \
     562        if (!ok) {                                              \
     563                DEBUG(10, ("SEC_VT check %s failed\n", msg));   \
     564                return false;                                   \
     565        }                                                       \
     566} while(0)
     567
     568#define CHECK_SYNTAX(msg, s1, s2)                                       \
     569do {                                                            \
     570        if (!ndr_syntax_id_equal(&s1, &s2)) {                           \
     571                TALLOC_CTX *frame = talloc_stackframe();                \
     572                DEBUG(10, ("SEC_VT check %s failed: %s vs. %s\n", msg,  \
     573                           ndr_syntax_id_to_string(frame, &s1),         \
     574                           ndr_syntax_id_to_string(frame, &s1)));       \
     575                TALLOC_FREE(frame);                                     \
     576                return false;                                           \
     577        }                                                               \
     578} while(0)
     579
     580
     581bool dcerpc_sec_verification_trailer_check(
     582                const struct dcerpc_sec_verification_trailer *vt,
     583                const uint32_t *bitmask1,
     584                const struct dcerpc_sec_vt_pcontext *pcontext,
     585                const struct dcerpc_sec_vt_header2 *header2)
     586{
     587        size_t i;
     588
     589        if (!dcerpc_sec_vt_is_valid(vt)) {
     590                return false;
     591        }
     592
     593        for (i=0; i < vt->count.count; i++) {
     594                struct dcerpc_sec_vt *c = &vt->commands[i];
     595
     596                switch (c->command & DCERPC_SEC_VT_COMMAND_ENUM) {
     597                case DCERPC_SEC_VT_COMMAND_BITMASK1:
     598                        if (bitmask1 == NULL) {
     599                                CHECK("Bitmask1 must_process_command",
     600                                      !(c->command & DCERPC_SEC_VT_MUST_PROCESS));
     601                                break;
     602                        }
     603
     604                        if (c->u.bitmask1 & DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING) {
     605                                CHECK("Bitmask1 client_header_signing",
     606                                      *bitmask1 & DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING);
     607                        }
     608                        break;
     609
     610                case DCERPC_SEC_VT_COMMAND_PCONTEXT:
     611                        if (pcontext == NULL) {
     612                                CHECK("Pcontext must_process_command",
     613                                      !(c->command & DCERPC_SEC_VT_MUST_PROCESS));
     614                                break;
     615                        }
     616
     617                        CHECK_SYNTAX("Pcontect abstract_syntax",
     618                                     pcontext->abstract_syntax,
     619                                     c->u.pcontext.abstract_syntax);
     620                        CHECK_SYNTAX("Pcontext transfer_syntax",
     621                                     pcontext->transfer_syntax,
     622                                     c->u.pcontext.transfer_syntax);
     623                        break;
     624
     625                case DCERPC_SEC_VT_COMMAND_HEADER2: {
     626                        if (header2 == NULL) {
     627                                CHECK("Header2 must_process_command",
     628                                      !(c->command & DCERPC_SEC_VT_MUST_PROCESS));
     629                                break;
     630                        }
     631
     632                        CHECK("Header2", dcerpc_sec_vt_header2_equal(header2, &c->u.header2));
     633                        break;
     634                }
     635
     636                default:
     637                        CHECK("Unknown must_process_command",
     638                              !(c->command & DCERPC_SEC_VT_MUST_PROCESS));
     639                        break;
     640                }
     641        }
     642
     643        return true;
     644}

  • vendor/current/librpc/rpc/rpc_common.h

    r860 r919  
    159159* @return               - A NTSTATUS error code.
    160160*/
    161 NTSTATUS dcerpc_pull_auth_trailer(struct ncacn_packet *pkt,
     161NTSTATUS dcerpc_pull_auth_trailer(const struct ncacn_packet *pkt,
    162162                                  TALLOC_CTX *mem_ctx,
    163                                   DATA_BLOB *pkt_trailer,
     163                                  const DATA_BLOB *pkt_trailer,
    164164                                  struct dcerpc_auth *auth,
    165165                                  uint32_t *auth_length,
    166166                                  bool auth_data_only);
     167NTSTATUS dcerpc_verify_ncacn_packet_header(const struct ncacn_packet *pkt,
     168                                           enum dcerpc_pkt_type ptype,
     169                                           size_t max_auth_info,
     170                                           uint8_t required_flags,
     171                                           uint8_t optional_flags);
    167172struct tevent_req *dcerpc_read_ncacn_packet_send(TALLOC_CTX *mem_ctx,
    168173                                                 struct tevent_context *ev,
    … …  
    297302                                    void *r_ptr);
    298303
     304/**
     305 * Extract header information from a ncacn_packet
     306 * as a dcerpc_sec_vt_header2 as used by the security verification trailer.
     307 *
     308 * @param[in] pkt a packet
     309 *
     310 * @return a dcerpc_sec_vt_header2
     311 */
     312struct dcerpc_sec_vt_header2 dcerpc_sec_vt_header2_from_ncacn_packet(const struct ncacn_packet *pkt);
     313
     314
     315/**
     316 * Test if two dcerpc_sec_vt_header2 structures are equal
     317 * without consideration of reserved fields.
     318 *
     319 * @param v1 a pointer to a dcerpc_sec_vt_header2 structure
     320 * @param v2 a pointer to a dcerpc_sec_vt_header2 structure
     321 *
     322 * @retval true if *v1 equals *v2
     323 */
     324bool dcerpc_sec_vt_header2_equal(const struct dcerpc_sec_vt_header2 *v1,
     325                                 const struct dcerpc_sec_vt_header2 *v2);
     326
     327/**
     328 * Check for consistency of the security verification trailer with the PDU header.
     329 * See <a href="http://msdn.microsoft.com/en-us/library/cc243559.aspx">MS-RPCE 2.2.2.13</a>.
     330 * A check with an empty trailer succeeds.
     331 *
     332 * @param[in] vt a pointer to the security verification trailer.
     333 * @param[in] bitmask1 which flags were negotiated on the connection.
     334 * @param[in] pcontext the syntaxes negotiatied for the presentation context.
     335 * @param[in] header2 some fields from the PDU header.
     336 *
     337 * @retval true on success.
     338 */
     339bool dcerpc_sec_verification_trailer_check(
     340                const struct dcerpc_sec_verification_trailer *vt,
     341                const uint32_t *bitmask1,
     342                const struct dcerpc_sec_vt_pcontext *pcontext,
     343                const struct dcerpc_sec_vt_header2 *header2);
     344
    299345#endif /* __DEFAULT_LIBRPC_RPCCOMMON_H__ */

  • vendor/current/librpc/wscript_build

    r917 r919  
    275275
    276276bld.SAMBA_SUBSYSTEM('NDR_DCERPC',
    277         source='gen_ndr/ndr_dcerpc.c',
     277        source='gen_ndr/ndr_dcerpc.c ndr/ndr_dcerpc.c',
    278278        public_deps='ndr',
     279        deps='bitmap',
    279280        public_headers='gen_ndr/ndr_dcerpc.h gen_ndr/dcerpc.h',
    280281        header_path= [ ('*gen_ndr*', 'gen_ndr') ],

  • vendor/current/pidl/lib/Parse/Pidl/ODL.pm

    r414 r919  
    7171                                }
    7272                                my $podl = Parse::Pidl::IDL::parse_file($idl_path, $opt_incdirs);
    73                                 if (defined(@$podl)) {
     73                                if (defined($podl)) {
    7474                                        require Parse::Pidl::Typelist;
    7575                                        my $basename = basename($idl_path, ".idl");

  • vendor/current/pidl/lib/Parse/Pidl/Samba3/ServerNDR.pm

    r917 r919  
    184184
    185185        pidl "";
    186         pidl "if (p->rng_fault_state) {";
     186        pidl "if (p->fault_state) {";
    187187        pidl "\ttalloc_free(r);";
    188188        pidl "\t/* Return true here, srv_pipe_hnd.c will take care */";

  • vendor/current/pidl/pidl

    r917 r919  
    606606
    607607                $pidl = Parse::Pidl::IDL::parse_file($idl_file, \@opt_incdirs);
    608                 defined @$pidl || die "Failed to parse $idl_file";
     608                defined $pidl || die "Failed to parse $idl_file";
    609609        }
    610610

  • vendor/current/selftest/target/Samba3.pm

    r860 r919  
    128128        domain logons = yes
    129129        lanman auth = yes
     130        raw NTLMv2 auth = yes
    130131";
    131132
    … …  
    231232        security = server
    232233        password server = $s3dcvars->{SERVER_IP}
     234        client ntlmv2 auth = no
    233235";
    234236

  • vendor/current/source3/Makefile-smbtorture4

    r917 r919  
    77        @(cd .. && \
    88                CFLAGS='' $(WAF) reconfigure || \
    9                 CFLAGS='' $(WAF) configure --enable-socket-wrapper --enable-nss-wrapper --enable-uid-wrapper --nonshared-binary=$(SAMBA4_BINARIES) --enable-auto-reconfigure )
     9                CFLAGS='' $(WAF) configure --enable-socket-wrapper --enable-nss-wrapper --enable-uid-wrapper --nonshared-binary=$(SAMBA4_BINARIES) --enable-auto-reconfigure --bundled-libraries=ALL --disable-gnutls )
    1010
    1111.PHONY: samba4-configure

  • vendor/current/source3/Makefile.in

    r860 r919  
    324324             librpc/ndr/util.o \
    325325             librpc/gen_ndr/ndr_server_id.o \
    326              librpc/gen_ndr/ndr_dcerpc.o
     326             librpc/gen_ndr/ndr_dcerpc.o \
     327             ../librpc/ndr/ndr_dcerpc.o
    327328
    328329LIBNDR_GEN_OBJ0 = librpc/gen_ndr/ndr_samr.o \
    … …  
    455456          ../libds/common/flag_mapping.o \
    456457          lib/access.o lib/smbrun.o \
    457           lib/bitmap.o lib/dprintf.o $(UTIL_REG_OBJ) \
     458          ../lib/util/bitmap.o lib/dprintf.o $(UTIL_REG_OBJ) \
    458459          lib/wins_srv.o \
    459460          lib/util_str.o lib/clobber.o lib/util_sid.o \
    … …  
    783784PROFILES_OBJ = utils/profiles.o \
    784785               $(LIBSMB_ERR_OBJ) \
     786               $(LIBNDR_NTLMSSP_OBJ) \
    785787               $(PARAM_OBJ) \
    786788               $(LIB_OBJ) $(LIB_DUMMY_OBJ) \
    … …  
    988990           $(PASSCHANGE_OBJ) $(FNAME_UTIL_OBJ) \
    989991           $(LIBCLI_SAMR_OBJ) \
    990            rpc_client/init_lsa.o
     992           $(LIBCLI_NETLOGON_OBJ) \
     993           rpc_client/init_lsa.o \
     994           rpc_client/init_netlogon.o
    991995
    992996STATUS_OBJ = utils/status.o utils/status_profile.o \
    993997             $(LOCKING_OBJ) $(PARAM_OBJ) \
    994998             $(PROFILE_OBJ) $(LIB_NONSMBD_OBJ) $(POPT_LIB_OBJ) \
    995              $(LIBSMB_ERR_OBJ) $(FNAME_UTIL_OBJ)
     999             $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ) $(FNAME_UTIL_OBJ)
    9961000
    9971001SMBCONTROL_OBJ = utils/smbcontrol.o $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) \
    998         $(LIBSMB_ERR_OBJ) $(POPT_LIB_OBJ) $(PRINTBASE_OBJ)
     1002        $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ) $(POPT_LIB_OBJ) $(PRINTBASE_OBJ)
    9991003
    10001004SMBTREE_OBJ = utils/smbtree.o $(PARAM_OBJ) \
    … …  
    10041008             $(LIBMSRPC_GEN_OBJ) \
    10051009             $(LIBMSRPC_OBJ) \
    1006              $(LIBCLI_SRVSVC_OBJ)
     1010             $(LIBCLI_SRVSVC_OBJ) \
     1011             $(LIBCLI_NETLOGON_OBJ) \
     1012             rpc_client/init_netlogon.o
    10071013
    10081014TESTPARM_OBJ = utils/testparm.o \
    10091015               $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) $(POPT_LIB_OBJ) \
    1010                $(LIBSMB_ERR_OBJ)
     1016               $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ)
    10111017
    10121018SMBTA_UTIL_OBJ = utils/smbta-util.o $(PARAM_OBJ) $(POPT_LIB_OBJ) \
    10131019        $(LIB_NONSMBD_OBJ) \
    1014         $(LIBSMB_ERR_OBJ) $(FNAME_UTIL_OBJ)
     1020        $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ) $(FNAME_UTIL_OBJ)
    10151021
    10161022TEST_LP_LOAD_OBJ = param/test_lp_load.o \
    … …  
    10261032                $(LIBMSRPC_GEN_OBJ) $(LIBMSRPC_OBJ) \
    10271033                $(LIBCLI_SAMR_OBJ) \
    1028                 rpc_client/init_lsa.o
     1034                $(LIBCLI_NETLOGON_OBJ) \
     1035                rpc_client/init_lsa.o \
     1036                rpc_client/init_netlogon.o
    10291037
    10301038PDBEDIT_OBJ = utils/pdbedit.o $(PASSWD_UTIL_OBJ) $(PARAM_OBJ) $(PASSDB_OBJ) \
    … …  
    10991107                    $(PASSDB_OBJ) $(SMBLDAP_OBJ) $(GROUPDB_OBJ) \
    11001108                    $(LIBCLI_SRVSVC_OBJ) \
    1101                     $(LIBCLI_LSA_OBJ)
     1109                    $(LIBCLI_LSA_OBJ) \
     1110                    $(LIBCLI_NETLOGON_OBJ) \
     1111                    rpc_client/init_netlogon.o
    11021112
    11031113LIBSMBCLIENT_OBJ = $(LIBSMBCLIENT_OBJ1)
    … …  
    11221132             $(PASSDB_OBJ) $(SMBLDAP_OBJ) $(GROUPDB_OBJ) \
    11231133             $(DISPLAY_SEC_OBJ) \
    1124              $(LIBCLI_SRVSVC_OBJ)
     1134             $(LIBCLI_SRVSVC_OBJ) \
     1135             $(LIBCLI_NETLOGON_OBJ) \
     1136             rpc_client/init_netlogon.o
    11251137
    11261138LIBSMBCONF_OBJ = ../lib/smbconf/smbconf.o \
    … …  
    11361148                  $(PARAM_OBJ) \
    11371149                  $(LIBSMB_ERR_OBJ) \
     1150                  $(LIBNDR_NTLMSSP_OBJ) \
    11381151                  $(POPT_LIB_OBJ)
    11391152
    … …  
    12191232
    12201233NMBLOOKUP_OBJ = utils/nmblookup.o $(PARAM_OBJ) $(LIBNMB_OBJ) \
    1221                $(LIB_NONSMBD_OBJ) $(POPT_LIB_OBJ) $(LIBSMB_ERR_OBJ)
     1234               $(LIB_NONSMBD_OBJ) $(POPT_LIB_OBJ) $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ)
    12221235
    12231236SMBTORTURE_OBJ1 = torture/torture.o torture/nbio.o torture/scanner.o torture/utable.o \
    … …  
    12341247        torture/wbc_async.o \
    12351248        ../nsswitch/wb_reqtrans.o \
    1236         $(LIBMSRPC_OBJ) $(LIBMSRPC_GEN_OBJ) $(LIBCLI_ECHO_OBJ)
     1249        $(LIBMSRPC_OBJ) $(LIBMSRPC_GEN_OBJ) $(LIBCLI_ECHO_OBJ) \
     1250        $(LIBCLI_NETLOGON_OBJ) rpc_client/init_netlogon.o
     1251
    12371252
    12381253MASKTEST_OBJ = torture/masktest.o $(PARAM_OBJ) $(LIBSMB_OBJ) $(KRBCLIENT_OBJ) \
    … …  
    12411256
    12421257MSGTEST_OBJ = torture/msgtest.o $(PARAM_OBJ) $(LIBSMB_ERR_OBJ) \
     1258                 $(LIBNDR_NTLMSSP_OBJ) \
    12431259                 $(LIB_NONSMBD_OBJ) \
    12441260                 $(LIBNDR_GEN_OBJ0)
    … …  
    12571273VFSTEST_OBJ = torture/cmd_vfs.o torture/vfstest.o $(SMBD_OBJ_BASE) $(READLINE_OBJ)
    12581274
    1259 SMBICONV_OBJ = $(PARAM_OBJ) torture/smbiconv.o $(LIB_NONSMBD_OBJ) $(POPT_LIB_OBJ) $(LIBSMB_ERR_OBJ)
     1275SMBICONV_OBJ = $(PARAM_OBJ) torture/smbiconv.o $(LIB_NONSMBD_OBJ) $(POPT_LIB_OBJ) $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ)
    12601276
    12611277LOG2PCAP_OBJ = utils/log2pcaphex.o
    … …  
    12691285                $(PASSDB_OBJ) $(GROUPDB_OBJ) $(LIBMSRPC_OBJ) $(LIBMSRPC_GEN_OBJ) \
    12701286                $(POPT_LIB_OBJ) $(SMBLDAP_OBJ) \
    1271                 $(LIBCLI_LSA_OBJ)
     1287                $(LIBCLI_LSA_OBJ) \
     1288                $(LIBCLI_NETLOGON_OBJ) \
     1289                rpc_client/init_netlogon.o
    12721290
    12731291SMBCQUOTAS_OBJ = utils/smbcquotas.o $(LIBSMB_OBJ) $(KRBCLIENT_OBJ) \
    … …  
    12761294                $(LIBMSRPC_OBJ) $(LIBMSRPC_GEN_OBJ) $(POPT_LIB_OBJ) \
    12771295                $(PASSDB_OBJ) $(SMBLDAP_OBJ) $(GROUPDB_OBJ) \
    1278                 $(LIBCLI_LSA_OBJ)
     1296                $(LIBCLI_LSA_OBJ) \
     1297                $(LIBCLI_NETLOGON_OBJ) \
     1298                rpc_client/init_netlogon.o
    12791299
    12801300EVTLOGADM_OBJ0  = utils/eventlogadm.o
    12811301
    12821302EVTLOGADM_OBJ   = $(EVTLOGADM_OBJ0) $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) \
    1283                 $(LIBSMB_ERR_OBJ) $(LIB_EVENTLOG_OBJ) \
     1303                $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ) $(LIB_EVENTLOG_OBJ) \
    12841304                librpc/gen_ndr/ndr_eventlog.o \
    12851305                librpc/gen_ndr/ndr_lsa.o
    … …  
    12871307SHARESEC_OBJ0 = utils/sharesec.o
    12881308SHARESEC_OBJ  = $(SHARESEC_OBJ0) $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) \
    1289                 $(LIBSMB_ERR_OBJ) \
     1309                $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ) \
    12901310                $(POPT_LIB_OBJ)
    12911311
    12921312TALLOCTORT_OBJ = @tallocdir@/testsuite.o @tallocdir@/testsuite_main.o \
    1293                 $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) $(LIBSMB_ERR_OBJ)
     1313                $(PARAM_OBJ) $(LIB_NONSMBD_OBJ) $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ)
    12941314
    12951315REPLACETORT_OBJ = @libreplacedir@/test/testsuite.o \
    … …  
    13071327
    13081328WINBIND_WINS_NSS_OBJ = ../nsswitch/wins.o $(PARAM_OBJ) \
    1309         $(LIB_NONSMBD_OBJ) $(LIBSMB_ERR_OBJ) $(LIBNMB_OBJ)
     1329        $(LIB_NONSMBD_OBJ) $(LIBSMB_ERR_OBJ) $(LIBNDR_NTLMSSP_OBJ) $(LIBNMB_OBJ)
    13101330
    13111331PAM_SMBPASS_OBJ_0 = pam_smbpass/pam_smb_auth.o pam_smbpass/pam_smb_passwd.o \
    … …  
    15151535                  $(PARAM_OBJ) \
    15161536                  $(LIB_NONSMBD_OBJ) \
    1517                   $(LIBSMB_ERR_OBJ)
     1537                  $(LIBSMB_ERR_OBJ) \
     1538                  $(LIBNDR_NTLMSSP_OBJ)
    15181539
    15191540DBWRAP_TORTURE_OBJ = utils/dbwrap_torture.o \
    … …  
    15211542                     $(LIB_NONSMBD_OBJ) \
    15221543                     $(LIBSMB_ERR_OBJ) \
     1544                     $(LIBNDR_NTLMSSP_OBJ) \
    15231545                     $(POPT_LIB_OBJ)
    15241546

  • vendor/current/source3/auth/auth_util.c

    r860 r919  
    3131#include "lib/winbind_util.h"
    3232#include "passdb.h"
     33#include "../lib/tsocket/tsocket.h"
    3334
    3435#undef DBGC_CLASS
    … …  
    368369                                      DATA_BLOB lm_resp, DATA_BLOB nt_resp)
    369370{
     371        bool allow_raw = lp_raw_ntlmv2_auth();
     372
     373        if (!allow_raw && nt_resp.length >= 48) {
     374                /*
     375                 * NTLMv2_RESPONSE has at least 48 bytes
     376                 * and should only be supported via NTLMSSP.
     377                 */
     378                DEBUG(2,("Rejecting raw NTLMv2 authentication with "
     379                         "user [%s\\%s]\n",
     380                         client_domain, smb_name));
     381                return NT_STATUS_INVALID_PARAMETER;
     382        }
     383
    370384        return make_user_info_map(user_info, smb_name,
    371385                                  client_domain,

  • vendor/current/source3/include/ntdomain.h

    r917 r919  
    8888        int n_cmds;
    8989        uint32 context_id;
    90 
     90        struct ndr_syntax_id syntax;
     91
     92        /*
     93         * shall we allow "connect" auth level for this interface ?
     94         */
     95        bool allow_connect;
    9196} PIPE_RPC_FNS;
    9297
    … …  
    135140
    136141        /*
    137          * Set to true when we should return fault PDU's for everything.
    138          */
    139 
    140         bool fault_state;
    141 
    142         /*
    143          * Set to true when we should return fault PDU's for a bad handle.
    144          */
    145 
    146         bool bad_handle_fault_state;
    147 
    148         /*
    149          * Set to true when the backend does not support a call.
    150          */
    151 
    152         bool rng_fault_state;
     142         * States we can be in.
     143         */
     144        bool allow_alter;
     145        bool allow_bind;
     146        bool allow_auth3;
     147
     148        /*
     149         * Set the DCERPC_FAULT to return.
     150         */
     151
     152        int fault_state;
    153153
    154154        /*

  • vendor/current/source3/include/proto.h

    r860 r919  
    6161bool get_audit_category_from_param(const char *param, uint32 *audit_category);
    6262const char *audit_policy_str(TALLOC_CTX *mem_ctx, uint32 policy);
    63 
    64 /* The following definitions come from lib/bitmap.c  */
    65 
    66 struct bitmap *bitmap_talloc(TALLOC_CTX *mem_ctx, int n);
    67 int bitmap_copy(struct bitmap * const dst, const struct bitmap * const src);
    68 bool bitmap_set(struct bitmap *bm, unsigned i);
    69 bool bitmap_clear(struct bitmap *bm, unsigned i);
    70 bool bitmap_query(struct bitmap *bm, unsigned i);
    71 int bitmap_find(struct bitmap *bm, unsigned ofs);
    7263
    7364/* The following definitions come from lib/charcnv.c  */
    … …  
    12701261void ntlmssp_want_feature_list(struct ntlmssp_state *ntlmssp_state, char *feature_list);
    12711262void ntlmssp_want_feature(struct ntlmssp_state *ntlmssp_state, uint32_t feature);
     1263bool ntlmssp_have_feature(struct ntlmssp_state *ntlmssp_state, uint32_t feature);
    12721264NTSTATUS ntlmssp_update(struct ntlmssp_state *ntlmssp_state,
    12731265                        const DATA_BLOB in, DATA_BLOB *out) ;
    … …  
    14991491bool lp_lanman_auth(void);
    15001492bool lp_ntlm_auth(void);
     1493bool lp_raw_ntlmv2_auth(void);
    15011494bool lp_client_plaintext_auth(void);
    15021495bool lp_client_lanman_auth(void);
    … …  
    16981691int lp_winbind_max_clients(void);
    16991692const char **lp_winbind_nss_info(void);
     1693bool lp_winbind_sealed_pipes(void);
    17001694int lp_algorithmic_rid_base(void);
    17011695int lp_name_cache_timeout(void);
    17021696int lp_client_signing(void);
     1697int lp_client_ipc_signing(void);
    17031698int lp_server_signing(void);
    17041699int lp_client_ldap_sasl_wrapping(void);
    … …  
    18271822void widelinks_warning(int snum);
    18281823char *lp_ncalrpc_dir(void);
     1824bool lp_allow_dcerpc_auth_level_connect(void);
    18291825
    18301826/* The following definitions come from param/loadparm_server_role.c  */

  • vendor/current/source3/include/smb.h

    r860 r919  
    713713};
    714714
    715 
    716715/* the following are used by loadparm for option lists */
    717716typedef enum {
    … …  
    759758#define FLAG_META       0x8000 /* A meta directive - not a real parameter */
    760759#define FLAG_CMDLINE    0x10000 /* option has been overridden */
    761 
    762 struct bitmap {
    763         uint32 *b;
    764         unsigned int n;
    765 };
    766760
    767761/* offsets into message for common items */

  • vendor/current/source3/lib/bitmap.c

    r917 r919  
    1919
    2020#include "includes.h"
     21#include "lib/util/bitmap.h"
    2122
    2223/* these functions provide a simple way to allocate integers from a
    … …  
    3031        struct bitmap *bm;
    3132
    32         bm = TALLOC_P(mem_ctx, struct bitmap);
     33        bm = talloc_zero(mem_ctx, struct bitmap);
    3334
    3435        if (!bm) return NULL;
    3536
    3637        bm->n = n;
    37         bm->b = TALLOC_ZERO_ARRAY(bm, uint32, (n+31)/32);
     38        bm->b = talloc_zero_array(bm, uint32_t, (n+31)/32);
    3839        if (!bm->b) {
    3940                TALLOC_FREE(bm);
    … …  
    5253
    5354        SMB_ASSERT(dst->b != src->b);
    54         memcpy(dst->b, src->b, sizeof(uint32)*((count+31)/32));
     55        memcpy(dst->b, src->b, sizeof(uint32_t)*((count+31)/32));
    5556
    5657        return count;
    … …  
    6566                DEBUG(0,("Setting invalid bitmap entry %d (of %d)\n",
    6667                      i, bm->n));
    67                 return False;
     68                return false;
    6869        }
    6970        bm->b[i/32] |= (1<<(i%32));
    70         return True;
     71        return true;
    7172}
    7273
    … …  
    7980                DEBUG(0,("clearing invalid bitmap entry %d (of %d)\n",
    8081                      i, bm->n));
    81                 return False;
     82                return false;
    8283        }
    8384        bm->b[i/32] &= ~(1<<(i%32));
    84         return True;
     85        return true;
    8586}
    8687
    … …  
    9091bool bitmap_query(struct bitmap *bm, unsigned i)
    9192{
    92         if (i >= bm->n) return False;
     93        if (i >= bm->n) return false;
    9394        if (bm->b[i/32] & (1<<(i%32))) {
    94                 return True;
     95                return true;
    9596        }
    96         return False;
     97        return false;
    9798}
    9899

  • vendor/current/source3/libads/sasl.c

    r917 r919  
    261261        /* we have a reference conter on ntlmssp_state, if we are signing
    262262           then the state will be kept by the signing engine */
     263
     264        if (ads->ldap.wrap_type >= ADS_SASLWRAP_TYPE_SEAL) {
     265                bool ok;
     266
     267                ok = ntlmssp_have_feature(ntlmssp_state,
     268                                          NTLMSSP_FEATURE_SEAL);
     269                if (!ok) {
     270                        DEBUG(0,("The ntlmssp feature sealing request, but unavailable\n"));
     271                        TALLOC_FREE(ntlmssp_state);
     272                        return ADS_ERROR_NT(NT_STATUS_INVALID_NETWORK_RESPONSE);
     273                }
     274
     275                ok = ntlmssp_have_feature(ntlmssp_state,
     276                                          NTLMSSP_FEATURE_SIGN);
     277                if (!ok) {
     278                        DEBUG(0,("The ntlmssp feature signing request, but unavailable\n"));
     279                        TALLOC_FREE(ntlmssp_state);
     280                        return ADS_ERROR_NT(NT_STATUS_INVALID_NETWORK_RESPONSE);
     281                }
     282
     283        } else if (ads->ldap.wrap_type >= ADS_SASLWRAP_TYPE_SIGN) {
     284                bool ok;
     285
     286                ok = ntlmssp_have_feature(ntlmssp_state,
     287                                          NTLMSSP_FEATURE_SIGN);
     288                if (!ok) {
     289                        DEBUG(0,("The gensec feature signing request, but unavailable\n"));
     290                        TALLOC_FREE(ntlmssp_state);
     291                        return ADS_ERROR_NT(NT_STATUS_INVALID_NETWORK_RESPONSE);
     292                }
     293        }
    263294
    264295        if (ads->ldap.wrap_type > ADS_SASLWRAP_TYPE_PLAIN) {

  • vendor/current/source3/librpc/rpc/dcerpc.h

    r917 r919  
    4040        enum dcerpc_AuthType auth_type;
    4141        enum dcerpc_AuthLevel auth_level;
     42        bool verified_bitmask1;
    4243
    4344        void *auth_ctx;
     45        uint32_t auth_context_id;
    4446
    4547        /* Only the client code uses these 3 for now */
    … …  
    7173                                 const DATA_BLOB *credentials,
    7274                                 DATA_BLOB *blob);
    73 NTSTATUS dcerpc_pull_dcerpc_auth(TALLOC_CTX *mem_ctx,
    74                                  const DATA_BLOB *blob,
    75                                  struct dcerpc_auth *r,
    76                                  bool bigendian);
    7775NTSTATUS dcerpc_guess_sizes(struct pipe_auth_data *auth,
    7876                            size_t header_len, size_t data_left,
    … …  
    8583                           struct ncacn_packet *pkt,
    8684                           DATA_BLOB *pkt_trailer,
    87                            size_t header_size,
    88                            DATA_BLOB *raw_pkt,
    89                            size_t *pad_len);
     85                           uint8_t header_size,
     86                           DATA_BLOB *raw_pkt);
    9087
    9188/* The following definitions come from librpc/rpc/rpc_common.c  */

  • vendor/current/source3/librpc/rpc/dcerpc_helpers.c

    r860 r919  
    211211
    212212/**
    213 * @brief Decodes a dcerpc_auth blob
    214 *
    215 * @param mem_ctx        The memory context on which to allocate the packet
    216 *                       elements
    217 * @param blob           The blob of data to decode
    218 * @param r              An empty dcerpc_auth structure, must not be NULL
    219 *
    220 * @return a NTSTATUS error code
    221 */
    222 NTSTATUS dcerpc_pull_dcerpc_auth(TALLOC_CTX *mem_ctx,
    223                                  const DATA_BLOB *blob,
    224                                  struct dcerpc_auth *r,
    225                                  bool bigendian)
    226 {
    227         enum ndr_err_code ndr_err;
    228         struct ndr_pull *ndr;
    229 
    230         ndr = ndr_pull_init_blob(blob, mem_ctx);
    231         if (!ndr) {
    232                 return NT_STATUS_NO_MEMORY;
    233         }
    234         if (bigendian) {
    235                 ndr->flags |= LIBNDR_FLAG_BIGENDIAN;
    236         }
    237 
    238         ndr_err = ndr_pull_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS, r);
    239 
    240         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
    241                 talloc_free(ndr);
    242                 return ndr_map_error2ntstatus(ndr_err);
    243         }
    244         talloc_free(ndr);
    245 
    246         if (DEBUGLEVEL >= 10) {
    247                 NDR_PRINT_DEBUG(dcerpc_auth, r);
    248         }
    249 
    250         return NT_STATUS_OK;
    251 }
    252 
    253 /**
    254213* @brief Calculate how much data we can in a packet, including calculating
    255214*        auth token and pad lengths.
    … …  
    783742                                         auth->auth_level,
    784743                                         pad_len,
    785                                          1 /* context id. */,
     744                                         auth->auth_context_id,
    786745                                         &auth_blob,
    787746                                         &auth_info);
    … …  
    845804* @param auth           The auth data for the connection
    846805* @param pkt            The actual ncacn_packet
    847 * @param pkt_trailer    The stub_and_verifier part of the packet
     806* @param pkt_trailer [in][out]  The stub_and_verifier part of the packet,
     807*                       the auth_trailer and padding will be removed.
    848808* @param header_size    The header size
    849809* @param raw_pkt        The whole raw packet data blob
    850 * @param pad_len        [out] The padding length used in the packet
    851810*
    852811* @return A NTSTATUS error code
    … …  
    855814                           struct ncacn_packet *pkt,
    856815                           DATA_BLOB *pkt_trailer,
    857                            size_t header_size,
    858                            DATA_BLOB *raw_pkt,
    859                            size_t *pad_len)
     816                           uint8_t header_size,
     817                           DATA_BLOB *raw_pkt)
    860818{
    861819        struct schannel_state *schannel_auth;
    … …  
    869827        DATA_BLOB data;
    870828
     829        /*
     830         * These check should be done in the caller.
     831         */
     832        SMB_ASSERT(raw_pkt->length == pkt->frag_length);
     833        SMB_ASSERT(header_size <= pkt->frag_length);
     834        SMB_ASSERT(pkt_trailer->length < pkt->frag_length);
     835        SMB_ASSERT((pkt_trailer->length + header_size) <= pkt->frag_length);
     836
    871837        switch (auth->auth_level) {
    872838        case DCERPC_AUTH_LEVEL_PRIVACY:
    … …  
    882848                        break;
    883849                }
    884                 *pad_len = 0;
    885850                return NT_STATUS_OK;
    886851
    … …  
    891856                        return NT_STATUS_INVALID_PARAMETER;
    892857                }
    893                 *pad_len = 0;
    894858                return NT_STATUS_OK;
    895859
    … …  
    900864        }
    901865
    902         /* Paranioa checks for auth_length. */
    903         if (pkt->auth_length > pkt->frag_length) {
    904                 return NT_STATUS_INFO_LENGTH_MISMATCH;
    905         }
    906         if (((unsigned int)pkt->auth_length
    907              + DCERPC_AUTH_TRAILER_LENGTH < (unsigned int)pkt->auth_length) ||
    908             ((unsigned int)pkt->auth_length
    909              + DCERPC_AUTH_TRAILER_LENGTH < DCERPC_AUTH_TRAILER_LENGTH)) {
    910                 /* Integer wrap attempt. */
    911                 return NT_STATUS_INFO_LENGTH_MISMATCH;
     866        if (pkt->auth_length == 0) {
     867                return NT_STATUS_INVALID_PARAMETER;
    912868        }
    913869
    … …  
    918874        }
    919875
     876        if (auth_info.auth_type != auth->auth_type) {
     877                return NT_STATUS_INVALID_PARAMETER;
     878        }
     879
     880        if (auth_info.auth_level != auth->auth_level) {
     881                return NT_STATUS_INVALID_PARAMETER;
     882        }
     883
     884        if (auth_info.auth_context_id != auth->auth_context_id) {
     885                return NT_STATUS_INVALID_PARAMETER;
     886        }
     887
     888        pkt_trailer->length -= auth_length;
    920889        data = data_blob_const(raw_pkt->data + header_size,
    921                                 pkt_trailer->length - auth_length);
    922         full_pkt = data_blob_const(raw_pkt->data,
    923                                 raw_pkt->length - auth_info.credentials.length);
     890                               pkt_trailer->length);
     891        full_pkt = data_blob_const(raw_pkt->data, raw_pkt->length);
     892        full_pkt.length -= auth_info.credentials.length;
    924893
    925894        switch (auth->auth_type) {
    … …  
    997966         * are still both used in later calls */
    998967        if (auth->auth_level == DCERPC_AUTH_LEVEL_PRIVACY) {
     968                if (pkt_trailer->length != data.length) {
     969                        return NT_STATUS_INVALID_PARAMETER;
     970                }
    999971                memcpy(pkt_trailer->data, data.data, data.length);
    1000972        }
    1001973
    1002         *pad_len = auth_info.auth_pad_length;
     974        pkt_trailer->length -= auth_info.auth_pad_length;
    1003975        data_blob_free(&auth_info.credentials);
    1004976        return NT_STATUS_OK;

  • vendor/current/source3/libsmb/cliconnect.c

    r860 r919  
    20782078
    20792079                /* otherwise do a NT1 style session setup */
     2080                if (lp_client_ntlmv2_auth() && lp_client_use_spnego()) {
     2081                        /*
     2082                         * Don't send an NTLMv2 response without NTLMSSP
     2083                         * if we want to use spnego support
     2084                         */
     2085                        DEBUG(1, ("Server does not support EXTENDED_SECURITY "
     2086                                  " but 'client use spnego = yes"
     2087                                  " and 'client ntlmv2 auth = yes'\n"));
     2088                        return NT_STATUS_ACCESS_DENIED;
     2089                }
     2090
    20802091                status = cli_session_setup_nt1(cli, user, pass, passlen,
    20812092                                               ntpass, ntpasslen, workgroup);

  • vendor/current/source3/libsmb/clidfs.c

    r917 r919  
    9999        const char *password;
    100100        NTSTATUS status;
     101        int signing_state = get_cmdline_auth_info_signing_state(auth_info);
     102
     103        if (force_encrypt) {
     104                signing_state = Required;
     105        }
    101106
    102107        /* make a copy so we don't modify the global string 'service' */
    … …  
    133138
    134139        /* have to open a new connection */
    135         c = cli_initialise_ex(get_cmdline_auth_info_signing_state(auth_info));
     140        c = cli_initialise_ex(signing_state);
    136141        if (c == NULL) {
    137142                d_printf("Connection to %s failed\n", server_n);

  • vendor/current/source3/libsmb/libsmb_server.c

    r917 r919  
    259259        NTSTATUS status;
    260260        char *newserver, *newshare;
     261        int signing_state = Undefined;
    261262
    262263        zero_sockaddr(&ss);
    … …  
    405406        zero_sockaddr(&ss);
    406407
     408        if (context->internal->smb_encryption_level != SMBC_ENCRYPTLEVEL_NONE) {
     409                signing_state = Required;
     410        }
     411
    407412        /* have to open a new connection */
    408         if ((c = cli_initialise()) == NULL) {
     413        if ((c = cli_initialise_ex(signing_state)) == NULL) {
    409414                errno = ENOMEM;
    410415                return NULL;
    … …  
    751756                                   pp_workgroup, pp_username, pp_password);
    752757        if (!ipc_srv) {
     758                int signing_state = Undefined;
    753759
    754760                /* We didn't find a cached connection.  Get the password */
    … …  
    772778                        flags |= CLI_FULL_CONNECTION_USE_CCACHE;
    773779                }
     780                if (context->internal->smb_encryption_level != SMBC_ENCRYPTLEVEL_NONE) {
     781                        signing_state = Required;
     782                }
    774783
    775784                zero_sockaddr(&ss);
    … …  
    781790                                                *pp_password,
    782791                                                flags,
    783                                                 Undefined);
     792                                                signing_state);
    784793                if (! NT_STATUS_IS_OK(nt_status)) {
    785794                        DEBUG(1,("cli_full_connection failed! (%s)\n",

  • vendor/current/source3/libsmb/ntlmssp.c

    r917 r919  
    163163}
    164164
     165bool ntlmssp_have_feature(struct ntlmssp_state *ntlmssp_state,
     166                          uint32_t feature)
     167{
     168        if (feature & NTLMSSP_FEATURE_SIGN) {
     169                if (ntlmssp_state->session_key.length == 0) {
     170                        return false;
     171                }
     172                if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_SIGN) {
     173                        return true;
     174                }
     175        }
     176
     177        if (feature & NTLMSSP_FEATURE_SEAL) {
     178                if (ntlmssp_state->session_key.length == 0) {
     179                        return false;
     180                }
     181                if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_SEAL) {
     182                        return true;
     183                }
     184        }
     185
     186        if (feature & NTLMSSP_FEATURE_SESSION_KEY) {
     187                if (ntlmssp_state->session_key.length > 0) {
     188                        return true;
     189                }
     190        }
     191
     192        return false;
     193}
     194
    165195/**
    166196 * Request features for the NTLMSSP negotiation
    … …  
    177207         */
    178208        if (in_list("NTLMSSP_FEATURE_SESSION_KEY", feature_list, True)) {
    179                 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
     209                ntlmssp_state->required_flags |= NTLMSSP_NEGOTIATE_SIGN;
    180210        }
    181211        if (in_list("NTLMSSP_FEATURE_SIGN", feature_list, True)) {
    182                 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
     212                ntlmssp_state->required_flags |= NTLMSSP_NEGOTIATE_SIGN;
    183213        }
    184214        if(in_list("NTLMSSP_FEATURE_SEAL", feature_list, True)) {
    185                 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SEAL;
     215                ntlmssp_state->required_flags |= NTLMSSP_NEGOTIATE_SEAL;
    186216        }
    187217        if (in_list("NTLMSSP_FEATURE_CCACHE", feature_list, true)) {
    188218                ntlmssp_state->use_ccache = true;
    189219        }
     220
     221        ntlmssp_state->neg_flags |= ntlmssp_state->required_flags;
    190222}
    191223
    … …  
    200232        /* As per JRA's comment above */
    201233        if (feature & NTLMSSP_FEATURE_SESSION_KEY) {
    202                 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
     234                ntlmssp_state->required_flags |= NTLMSSP_NEGOTIATE_SIGN;
    203235        }
    204236        if (feature & NTLMSSP_FEATURE_SIGN) {
    205                 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
     237                ntlmssp_state->required_flags |= NTLMSSP_NEGOTIATE_SIGN;
    206238        }
    207239        if (feature & NTLMSSP_FEATURE_SEAL) {
    208                 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SEAL;
     240                ntlmssp_state->required_flags |= NTLMSSP_NEGOTIATE_SIGN;
     241                ntlmssp_state->required_flags |= NTLMSSP_NEGOTIATE_SEAL;
    209242        }
    210243        if (feature & NTLMSSP_FEATURE_CCACHE) {
    211244                ntlmssp_state->use_ccache = true;
    212245        }
     246
     247        ntlmssp_state->neg_flags |= ntlmssp_state->required_flags;
    213248}
    214249
    … …  
    388423
    389424        if (ntlmssp_state->use_ntlmv2) {
    390                 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_NTLM2;
     425                ntlmssp_state->required_flags |= NTLMSSP_NEGOTIATE_NTLM2;
     426                ntlmssp_state->allow_lm_key = false;
     427        }
     428
     429        if (ntlmssp_state->allow_lm_key) {
     430                ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_LM_KEY;
    391431        }
    392432
    … …  
    421461
    422462        return NT_STATUS_MORE_PROCESSING_REQUIRED;
     463}
     464
     465static NTSTATUS ntlmssp3_handle_neg_flags(struct ntlmssp_state *ntlmssp_state,
     466                                          uint32_t flags)
     467{
     468        uint32_t missing_flags = ntlmssp_state->required_flags;
     469
     470        if (flags & NTLMSSP_NEGOTIATE_UNICODE) {
     471                ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_UNICODE;
     472                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_OEM;
     473                ntlmssp_state->unicode = true;
     474        } else {
     475                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_UNICODE;
     476                ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_OEM;
     477                ntlmssp_state->unicode = false;
     478        }
     479
     480        /*
     481         * NTLMSSP_NEGOTIATE_NTLM2 (NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY)
     482         * has priority over NTLMSSP_NEGOTIATE_LM_KEY
     483         */
     484        if (!(flags & NTLMSSP_NEGOTIATE_NTLM2)) {
     485                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_NTLM2;
     486        }
     487
     488        if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) {
     489                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_LM_KEY;
     490        }
     491
     492        if (!(flags & NTLMSSP_NEGOTIATE_LM_KEY)) {
     493                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_LM_KEY;
     494        }
     495
     496        if (!(flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN)) {
     497                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_ALWAYS_SIGN;
     498        }
     499
     500        if (!(flags & NTLMSSP_NEGOTIATE_128)) {
     501                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_128;
     502        }
     503
     504        if (!(flags & NTLMSSP_NEGOTIATE_56)) {
     505                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_56;
     506        }
     507
     508        if (!(flags & NTLMSSP_NEGOTIATE_KEY_EXCH)) {
     509                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_KEY_EXCH;
     510        }
     511
     512        if (!(flags & NTLMSSP_NEGOTIATE_SIGN)) {
     513                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_SIGN;
     514        }
     515
     516        if (!(flags & NTLMSSP_NEGOTIATE_SEAL)) {
     517                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_SEAL;
     518        }
     519
     520        if ((flags & NTLMSSP_REQUEST_TARGET)) {
     521                ntlmssp_state->neg_flags |= NTLMSSP_REQUEST_TARGET;
     522        }
     523
     524        missing_flags &= ~ntlmssp_state->neg_flags;
     525        if (missing_flags != 0) {
     526                NTSTATUS status = NT_STATUS_RPC_SEC_PKG_ERROR;
     527                DEBUG(1, ("%s: Got challenge flags[0x%08x] "
     528                          "- possible downgrade detected! "
     529                          "missing_flags[0x%08x] - %s\n",
     530                          __func__,
     531                          (unsigned)flags,
     532                          (unsigned)missing_flags,
     533                          nt_errstr(status)));
     534                debug_ntlmssp_flags(missing_flags);
     535                DEBUGADD(4, ("neg_flags[0x%08x]\n",
     536                             (unsigned)ntlmssp_state->neg_flags));
     537                debug_ntlmssp_flags(ntlmssp_state->neg_flags);
     538
     539                return status;
     540        }
     541
     542        return NT_STATUS_OK;
    423543}
    424544
    … …  
    449569        NTSTATUS nt_status = NT_STATUS_OK;
    450570
     571        if (!msrpc_parse(ntlmssp_state, &reply, "CdBd",
     572                         "NTLMSSP",
     573                         &ntlmssp_command,
     574                         &server_domain_blob,
     575                         &chal_flags)) {
     576                DEBUG(1, ("Failed to parse the NTLMSSP Challenge: (#1)\n"));
     577                dump_data(2, reply.data, reply.length);
     578
     579                return NT_STATUS_INVALID_PARAMETER;
     580        }
     581        data_blob_free(&server_domain_blob);
     582
     583        DEBUG(3, ("Got challenge flags:\n"));
     584        debug_ntlmssp_flags(chal_flags);
     585
     586        nt_status = ntlmssp3_handle_neg_flags(ntlmssp_state, chal_flags);
     587        if (!NT_STATUS_IS_OK(nt_status)) {
     588                return nt_status;
     589        }
     590
    451591        if (ntlmssp_state->use_ccache) {
    452592                struct wbcCredentialCacheParams params;
    … …  
    498638
    499639noccache:
    500 
    501         if (!msrpc_parse(ntlmssp_state, &reply, "CdBd",
    502                          "NTLMSSP",
    503                          &ntlmssp_command,
    504                          &server_domain_blob,
    505                          &chal_flags)) {
    506                 DEBUG(1, ("Failed to parse the NTLMSSP Challenge: (#1)\n"));
    507                 dump_data(2, reply.data, reply.length);
    508 
    509                 return NT_STATUS_INVALID_PARAMETER;
    510         }
    511640
    512641        if (DEBUGLEVEL >= 10) {
    … …  
    525654                }
    526655        }
    527 
    528         data_blob_free(&server_domain_blob);
    529 
    530         DEBUG(3, ("Got challenge flags:\n"));
    531         debug_ntlmssp_flags(chal_flags);
    532 
    533         ntlmssp_handle_neg_flags(ntlmssp_state, chal_flags, lp_client_lanman_auth());
    534656
    535657        if (ntlmssp_state->unicode) {
    … …  
    770892
    771893        ntlmssp_state->use_ntlmv2 = use_ntlmv2;
     894        ntlmssp_state->allow_lm_key = lp_client_lanman_auth();
    772895
    773896        ntlmssp_state->expected_state = NTLMSSP_INITIAL;
    … …  
    781904                NTLMSSP_REQUEST_TARGET;
    782905
     906        if (ntlmssp_state->use_ntlmv2) {
     907                ntlmssp_state->allow_lm_key = false;
     908        }
     909
    783910        ntlmssp_state->client.netbios_name = talloc_strdup(ntlmssp_state, netbios_name);
    784911        if (!ntlmssp_state->client.netbios_name) {

  • vendor/current/source3/modules/vfs_acl_common.c

    r860 r919  
    2424#include "../libcli/security/security.h"
    2525#include "../librpc/gen_ndr/ndr_security.h"
     26#include "../lib/util/bitmap.h"
    2627
    2728static NTSTATUS create_acl_blob(const struct security_descriptor *psd,

  • vendor/current/source3/modules/vfs_full_audit.c

    r917 r919  
    6565#include "auth.h"
    6666#include "ntioctl.h"
     67#include "lib/util/bitmap.h"
    6768
    6869static int vfs_full_audit_debug_level = DBGC_VFS;

  • vendor/current/source3/modules/vfs_shadow_copy2.c

    r917 r919  
    2222#include "includes.h"
    2323#include "smbd/smbd.h"
     24#include "smbd/globals.h"
     25#include "../libcli/security/security.h"
    2426#include "system/filesys.h"
    2527#include "ntioctl.h"
    … …  
    765767}
    766768
     769static bool check_access_snapdir(struct vfs_handle_struct *handle,
     770                                const char *path)
     771{
     772        struct smb_filename smb_fname;
     773        int ret;
     774        NTSTATUS status;
     775        uint32_t access_granted = 0;
     776
     777        ZERO_STRUCT(smb_fname);
     778        smb_fname.base_name = talloc_asprintf(talloc_tos(),
     779                                                "%s",
     780                                                path);
     781        if (smb_fname.base_name == NULL) {
     782                return false;
     783        }
     784
     785        ret = SMB_VFS_NEXT_STAT(handle, &smb_fname);
     786        if (ret != 0 || !S_ISDIR(smb_fname.st.st_ex_mode)) {
     787                TALLOC_FREE(smb_fname.base_name);
     788                return false;
     789        }
     790
     791        status = smbd_check_open_rights(handle->conn,
     792                                        &smb_fname,
     793                                        SEC_DIR_LIST,
     794                                        &access_granted);
     795        if (!NT_STATUS_IS_OK(status)) {
     796                DEBUG(0,("user does not have list permission "
     797                        "on snapdir %s\n",
     798                        smb_fname.base_name));
     799                TALLOC_FREE(smb_fname.base_name);
     800                return false;
     801        }
     802        TALLOC_FREE(smb_fname.base_name);
     803        return true;
     804}
     805
    767806static int shadow_copy2_rmdir(vfs_handle_struct *handle,  const char *fname)
    768807{
    … …  
    878917        TALLOC_CTX *tmp_ctx = talloc_new(handle->data);
    879918        char *snapshot;
     919        bool ret;
    880920
    881921        snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
    … …  
    884924                         handle->conn->connectpath));
    885925                errno = EINVAL;
     926                talloc_free(tmp_ctx);
     927                return -1;
     928        }
     929        ret = check_access_snapdir(handle, snapdir);
     930        if (!ret) {
     931                DEBUG(0,("access denied on listing snapdir %s\n", snapdir));
     932                errno = EACCES;
    886933                talloc_free(tmp_ctx);
    887934                return -1;

  • vendor/current/source3/param/loadparm.c

    r917 r919  
    6565#include "dbwrap.h"
    6666#include "smbldap.h"
     67#include "../lib/util/bitmap.h"
    6768
    6869#ifdef HAVE_SYS_SYSCTL_H
    … …  
    215216        bool bWinbindRefreshTickets;
    216217        bool bWinbindOfflineLogon;
     218        bool bWinbindSealedPipes;
    217219        bool bWinbindNormalizeNames;
    218220        bool bWinbindRpcOnly;
    … …  
    336338        bool bLanmanAuth;
    337339        bool bNTLMAuth;
     340        bool bRawNTLMv2Auth;
    338341        bool bUseSpnego;
    339342        bool bClientLanManAuth;
    … …  
    353356        bool bHostnameLookups;
    354357        bool bUnixExtensions;
     358        bool bAllowDcerpcAuthLevelConnect;
    355359        bool bDisableNetbios;
    356360        char * szDedicatedKeytabFile;
    … …  
    365369        int name_cache_timeout;
    366370        int client_signing;
     371        int client_ipc_signing;
    367372        int server_signing;
    368373        int client_ldap_sasl_wrapping;
    … …  
    13831388        },
    13841389        {
     1390                .label          = "raw NTLMv2 auth",
     1391                .type           = P_BOOL,
     1392                .p_class        = P_GLOBAL,
     1393                .ptr            = &Globals.bRawNTLMv2Auth,
     1394                .special        = NULL,
     1395                .enum_list      = NULL,
     1396                .flags          = FLAG_ADVANCED,
     1397        },
     1398        {
    13851399                .label          = "client NTLMv2 auth",
    13861400                .type           = P_BOOL,
    … …  
    22912305        },
    22922306        {
     2307                .label          = "allow dcerpc auth level connect",
     2308                .type           = P_BOOL,
     2309                .p_class        = P_GLOBAL,
     2310                .ptr            = &Globals.bAllowDcerpcAuthLevelConnect,
     2311                .special        = NULL,
     2312                .enum_list      = NULL,
     2313                .flags          = FLAG_ADVANCED,
     2314        },
     2315        {
    22932316                .label          = "use spnego",
    22942317                .type           = P_BOOL,
    … …  
    23042327                .p_class        = P_GLOBAL,
    23052328                .ptr            = &Globals.client_signing,
     2329                .special        = NULL,
     2330                .enum_list      = enum_smb_signing_vals,
     2331                .flags          = FLAG_ADVANCED,
     2332        },
     2333        {
     2334                .label          = "client ipc signing",
     2335                .type           = P_ENUM,
     2336                .p_class        = P_GLOBAL,
     2337                .ptr            = &Globals.client_ipc_signing,
    23062338                .special        = NULL,
    23072339                .enum_list      = enum_smb_signing_vals,
    … …  
    47504782                .p_class        = P_GLOBAL,
    47514783                .ptr            = &Globals.bWinbindOfflineLogon,
     4784                .special        = NULL,
     4785                .enum_list      = NULL,
     4786                .flags          = FLAG_ADVANCED,
     4787        },
     4788        {
     4789                .label          = "winbind sealed pipes",
     4790                .type           = P_BOOL,
     4791                .p_class        = P_GLOBAL,
     4792                .ptr            = &Globals.bWinbindSealedPipes,
    47524793                .special        = NULL,
    47534794                .enum_list      = NULL,
    … …  
    53375378        Globals.bLanmanAuth = False;    /* Do NOT use the LanMan hash, even if it is supplied */
    53385379        Globals.bNTLMAuth = True;       /* Do use NTLMv1 if it is supplied by the client (otherwise NTLMv2) */
     5380        Globals.bRawNTLMv2Auth = false; /* Allow NTLMv2 without NTLMSSP */
    53395381        Globals.bClientNTLMv2Auth = True; /* Client should always use use NTLMv2, as we can't tell that the server supports it, but most modern servers do */
    53405382        /* Note, that we will also use NTLM2 session security (which is different), if it is available */
     5383
     5384        Globals.bAllowDcerpcAuthLevelConnect = false; /* we don't allow this by default */
    53415385
    53425386        Globals.map_to_guest = 0;       /* By Default, "Never" */
    … …  
    53815425        Globals.ldap_debug_threshold = 10;
    53825426
     5427        Globals.client_ldap_sasl_wrapping = ADS_AUTH_SASL_SIGN;
     5428
    53835429        /* This is what we tell the afs client. in reality we set the token
    53845430         * to never expire, though, when this runs out the afs client will
    … …  
    54455491        Globals.bWinbindRefreshTickets = False;
    54465492        Globals.bWinbindOfflineLogon = False;
     5493        Globals.bWinbindSealedPipes = True;
    54475494
    54485495        Globals.iIdmapCacheTime = 86400 * 7; /* a week by default */
    … …  
    54575504
    54585505        Globals.client_signing = Auto;
     5506        Globals.client_ipc_signing = Required;
    54595507        Globals.server_signing = False;
    54605508
    … …  
    57105758FN_GLOBAL_STRING(lp_check_password_script, &Globals.szCheckPasswordScript)
    57115759
     5760FN_GLOBAL_BOOL(lp_allow_dcerpc_auth_level_connect, &Globals.bAllowDcerpcAuthLevelConnect)
    57125761FN_GLOBAL_STRING(lp_wins_hook, &Globals.szWINSHook)
    57135762FN_GLOBAL_CONST_STRING(lp_template_homedir, &Globals.szTemplateHomedir)
    … …  
    57235772FN_GLOBAL_BOOL(lp_winbind_refresh_tickets, &Globals.bWinbindRefreshTickets)
    57245773FN_GLOBAL_BOOL(lp_winbind_offline_logon, &Globals.bWinbindOfflineLogon)
     5774FN_GLOBAL_BOOL(lp_winbind_sealed_pipes, &Globals.bWinbindSealedPipes)
    57255775FN_GLOBAL_BOOL(lp_winbind_normalize_names, &Globals.bWinbindNormalizeNames)
    57265776FN_GLOBAL_BOOL(lp_winbind_rpc_only, &Globals.bWinbindRpcOnly)
    … …  
    58195869FN_GLOBAL_BOOL(lp_lanman_auth, &Globals.bLanmanAuth)
    58205870FN_GLOBAL_BOOL(lp_ntlm_auth, &Globals.bNTLMAuth)
     5871FN_GLOBAL_BOOL(lp_raw_ntlmv2_auth, &Globals.bRawNTLMv2Auth)
    58215872FN_GLOBAL_BOOL(lp_client_plaintext_auth, &Globals.bClientPlaintextAuth)
    58225873FN_GLOBAL_BOOL(lp_client_lanman_auth, &Globals.bClientLanManAuth)
    … …  
    60576108FN_GLOBAL_INTEGER(lp_name_cache_timeout, &Globals.name_cache_timeout)
    60586109FN_GLOBAL_INTEGER(lp_client_signing, &Globals.client_signing)
     6110FN_GLOBAL_INTEGER(lp_client_ipc_signing, &Globals.client_ipc_signing)
    60596111FN_GLOBAL_INTEGER(lp_server_signing, &Globals.server_signing)
    60606112FN_GLOBAL_INTEGER(lp_client_ldap_sasl_wrapping, &Globals.client_ldap_sasl_wrapping)
    … …  
    96869738        }
    96879739
     9740        if (!lp_is_in_client()) {
     9741                switch (lp_client_ipc_signing()) {
     9742                case Required:
     9743                        lp_set_cmdline("client signing", "mandatory");
     9744                        break;
     9745                case Auto:
     9746                        lp_set_cmdline("client signing", "auto");
     9747                        break;
     9748                case False:
     9749                        lp_set_cmdline("client signing", "disabled");
     9750                        break;
     9751                }
     9752        }
     9753
    96889754        init_iconv();
    96899755

  • vendor/current/source3/passdb/pdb_get_set.c

    r917 r919  
    2626#include "../libcli/auth/libcli_auth.h"
    2727#include "../libcli/security/security.h"
     28#include "../lib/util/bitmap.h"
    2829
    2930#undef DBGC_CLASS

  • vendor/current/source3/rpc_client/cli_pipe.c

    r860 r919  
    2929#include "ntlmssp_wrap.h"
    3030#include "librpc/gen_ndr/ndr_dcerpc.h"
     31#include "librpc/gen_ndr/ndr_netlogon_c.h"
    3132#include "librpc/rpc/dcerpc.h"
    3233#include "librpc/crypto/gse.h"
    … …  
    400401                                                DATA_BLOB *pdu,
    401402                                                uint8_t expected_pkt_type,
     403                                                uint32_t call_id,
    402404                                                DATA_BLOB *rdata,
    403405                                                DATA_BLOB *reply_pdu)
    404406{
    405         struct dcerpc_response *r;
     407        const struct dcerpc_response *r = NULL;
     408        DATA_BLOB tmp_stub = data_blob_null;
    406409        NTSTATUS ret = NT_STATUS_OK;
    407         size_t pad_len = 0;
    408410
    409411        /*
    … …  
    413415        *rdata = *pdu;
    414416
     417        if ((pkt->ptype == DCERPC_PKT_BIND_ACK) &&
     418            !(pkt->pfc_flags & DCERPC_PFC_FLAG_LAST)) {
     419                /*
     420                 * TODO: do we still need this hack which was introduced
     421                 * in commit a42afcdcc7ab9aa9ed193ae36d3dbb10843447f0.
     422                 *
     423                 * I don't even know what AS/U might be...
     424                 */
     425                DEBUG(5, (__location__ ": bug in server (AS/U?), setting "
     426                          "fragment first/last ON.\n"));
     427                pkt->pfc_flags |= DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
     428        }
     429
    415430        /* Ensure we have the correct type. */
    416431        switch (pkt->ptype) {
     432        case DCERPC_PKT_BIND_NAK:
     433                DEBUG(1, (__location__ ": Bind NACK received from %s!\n",
     434                          rpccli_pipe_txt(talloc_tos(), cli)));
     435
     436                ret = dcerpc_verify_ncacn_packet_header(pkt,
     437                                                DCERPC_PKT_BIND_NAK,
     438                                                0, /* max_auth_info */
     439                                                DCERPC_PFC_FLAG_FIRST |
     440                                                DCERPC_PFC_FLAG_LAST,
     441                                                0); /* optional flags */
     442                if (!NT_STATUS_IS_OK(ret)) {
     443                        DEBUG(1, (__location__ ": Connection to %s got an unexpected "
     444                                  "RPC packet type - %u, expected %u: %s\n",
     445                                  rpccli_pipe_txt(talloc_tos(), cli),
     446                                  pkt->ptype, expected_pkt_type,
     447                                  nt_errstr(ret)));
     448                        NDR_PRINT_DEBUG(ncacn_packet, pkt);
     449                        return ret;
     450                }
     451
     452                /* Use this for now... */
     453                return NT_STATUS_NETWORK_ACCESS_DENIED;
     454
     455        case DCERPC_PKT_BIND_ACK:
     456                ret = dcerpc_verify_ncacn_packet_header(pkt,
     457                                        expected_pkt_type,
     458                                        pkt->u.bind_ack.auth_info.length,
     459                                        DCERPC_PFC_FLAG_FIRST |
     460                                        DCERPC_PFC_FLAG_LAST,
     461                                        DCERPC_PFC_FLAG_CONC_MPX |
     462                                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN);
     463                if (!NT_STATUS_IS_OK(ret)) {
     464                        DEBUG(1, (__location__ ": Connection to %s got an unexpected "
     465                                  "RPC packet type - %u, expected %u: %s\n",
     466                                  rpccli_pipe_txt(talloc_tos(), cli),
     467                                  pkt->ptype, expected_pkt_type,
     468                                  nt_errstr(ret)));
     469                        NDR_PRINT_DEBUG(ncacn_packet, pkt);
     470                        return ret;
     471                }
     472
     473                break;
     474
    417475        case DCERPC_PKT_ALTER_RESP:
    418         case DCERPC_PKT_BIND_ACK:
    419 
    420                 /* Client code never receives this kind of packets */
     476                ret = dcerpc_verify_ncacn_packet_header(pkt,
     477                                        expected_pkt_type,
     478                                        pkt->u.alter_resp.auth_info.length,
     479                                        DCERPC_PFC_FLAG_FIRST |
     480                                        DCERPC_PFC_FLAG_LAST,
     481                                        DCERPC_PFC_FLAG_CONC_MPX |
     482                                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN);
     483                if (!NT_STATUS_IS_OK(ret)) {
     484                        DEBUG(1, (__location__ ": Connection to %s got an unexpected "
     485                                  "RPC packet type - %u, expected %u: %s\n",
     486                                  rpccli_pipe_txt(talloc_tos(), cli),
     487                                  pkt->ptype, expected_pkt_type,
     488                                  nt_errstr(ret)));
     489                        NDR_PRINT_DEBUG(ncacn_packet, pkt);
     490                        return ret;
     491                }
     492
    421493                break;
    422494
    423 
    424495        case DCERPC_PKT_RESPONSE:
    425496
    426497                r = &pkt->u.response;
     498
     499                ret = dcerpc_verify_ncacn_packet_header(pkt,
     500                                                expected_pkt_type,
     501                                                r->stub_and_verifier.length,
     502                                                0, /* required_flags */
     503                                                DCERPC_PFC_FLAG_FIRST |
     504                                                DCERPC_PFC_FLAG_LAST);
     505                if (!NT_STATUS_IS_OK(ret)) {
     506                        DEBUG(1, (__location__ ": Connection to %s got an unexpected "
     507                                  "RPC packet type - %u, expected %u: %s\n",
     508                                  rpccli_pipe_txt(talloc_tos(), cli),
     509                                  pkt->ptype, expected_pkt_type,
     510                                  nt_errstr(ret)));
     511                        NDR_PRINT_DEBUG(ncacn_packet, pkt);
     512                        return ret;
     513                }
     514
     515                tmp_stub.data = r->stub_and_verifier.data;
     516                tmp_stub.length = r->stub_and_verifier.length;
    427517
    428518                /* Here's where we deal with incoming sign/seal. */
    429519                ret = dcerpc_check_auth(cli->auth, pkt,
    430                                         &r->stub_and_verifier,
     520                                        &tmp_stub,
    431521                                        DCERPC_RESPONSE_LENGTH,
    432                                         pdu, &pad_len);
     522                                        pdu);
    433523                if (!NT_STATUS_IS_OK(ret)) {
     524                        DEBUG(1, (__location__ ": Connection to %s got an unexpected "
     525                                  "RPC packet type - %u, expected %u: %s\n",
     526                                  rpccli_pipe_txt(talloc_tos(), cli),
     527                                  pkt->ptype, expected_pkt_type,
     528                                  nt_errstr(ret)));
     529                        NDR_PRINT_DEBUG(ncacn_packet, pkt);
    434530                        return ret;
    435531                }
    436532
    437                 if (pkt->frag_length < DCERPC_RESPONSE_LENGTH + pad_len) {
    438                         return NT_STATUS_BUFFER_TOO_SMALL;
    439                 }
    440 
    441533                /* Point the return values at the NDR data. */
    442                 rdata->data = r->stub_and_verifier.data;
    443 
    444                 if (pkt->auth_length) {
    445                         /* We've already done integer wrap tests in
    446                          * dcerpc_check_auth(). */
    447                         rdata->length = r->stub_and_verifier.length
    448                                          - pad_len
    449                                          - DCERPC_AUTH_TRAILER_LENGTH
    450                                          - pkt->auth_length;
    451                 } else {
    452                         rdata->length = r->stub_and_verifier.length;
    453                 }
    454 
    455                 DEBUG(10, ("Got pdu len %lu, data_len %lu, ss_len %u\n",
     534                *rdata = tmp_stub;
     535
     536                DEBUG(10, ("Got pdu len %lu, data_len %lu\n",
    456537                           (long unsigned int)pdu->length,
    457                            (long unsigned int)rdata->length,
    458                            (unsigned int)pad_len));
     538                           (long unsigned int)rdata->length));
    459539
    460540                /*
    … …  
    477557                break;
    478558
    479         case DCERPC_PKT_BIND_NAK:
    480                 DEBUG(1, (__location__ ": Bind NACK received from %s!\n",
    481                           rpccli_pipe_txt(talloc_tos(), cli)));
    482                 /* Use this for now... */
    483                 return NT_STATUS_NETWORK_ACCESS_DENIED;
    484 
    485559        case DCERPC_PKT_FAULT:
     560
     561                ret = dcerpc_verify_ncacn_packet_header(pkt,
     562                                                DCERPC_PKT_FAULT,
     563                                                0, /* max_auth_info */
     564                                                DCERPC_PFC_FLAG_FIRST |
     565                                                DCERPC_PFC_FLAG_LAST,
     566                                                DCERPC_PFC_FLAG_DID_NOT_EXECUTE);
     567                if (!NT_STATUS_IS_OK(ret)) {
     568                        DEBUG(1, (__location__ ": Connection to %s got an unexpected "
     569                                  "RPC packet type - %u, expected %u: %s\n",
     570                                  rpccli_pipe_txt(talloc_tos(), cli),
     571                                  pkt->ptype, expected_pkt_type,
     572                                  nt_errstr(ret)));
     573                        NDR_PRINT_DEBUG(ncacn_packet, pkt);
     574                        return ret;
     575                }
    486576
    487577                DEBUG(1, (__location__ ": RPC fault code %s received "
    … …  
    498588                          (unsigned int)pkt->ptype,
    499589                          rpccli_pipe_txt(talloc_tos(), cli)));
    500                 return NT_STATUS_INVALID_INFO_CLASS;
    501         }
    502 
    503         if (pkt->ptype != expected_pkt_type) {
     590                return NT_STATUS_RPC_PROTOCOL_ERROR;
     591        }
     592
     593
     594        if (pkt->call_id != call_id) {
    504595                DEBUG(3, (__location__ ": Connection to %s got an unexpected "
    505                           "RPC packet type - %u, not %u\n",
     596                          "RPC call_id - %u, not %u\n",
    506597                          rpccli_pipe_txt(talloc_tos(), cli),
    507                           pkt->ptype, expected_pkt_type));
    508                 return NT_STATUS_INVALID_INFO_CLASS;
    509         }
    510 
    511         /* Do this just before return - we don't want to modify any rpc header
    512            data before now as we may have needed to do cryptographic actions on
    513            it before. */
    514 
    515         if ((pkt->ptype == DCERPC_PKT_BIND_ACK) &&
    516             !(pkt->pfc_flags & DCERPC_PFC_FLAG_LAST)) {
    517                 DEBUG(5, (__location__ ": bug in server (AS/U?), setting "
    518                           "fragment first/last ON.\n"));
    519                 pkt->pfc_flags |= DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
     598                          pkt->call_id, call_id));
     599                return NT_STATUS_RPC_PROTOCOL_ERROR;
    520600        }
    521601
    … …  
    874954        state->pkt = talloc(state, struct ncacn_packet);
    875955        if (!state->pkt) {
     956                /*
     957                 * TODO: do a real async disconnect ...
     958                 *
     959                 * For now do it sync...
     960                 */
     961                TALLOC_FREE(state->cli->transport);
    876962                tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
    877963                return;
    … …  
    883969                                          !state->endianess);
    884970        if (!NT_STATUS_IS_OK(status)) {
     971                /*
     972                 * TODO: do a real async disconnect ...
     973                 *
     974                 * For now do it sync...
     975                 */
     976                TALLOC_FREE(state->cli->transport);
    885977                tevent_req_nterror(req, status);
    886                 return;
    887         }
    888 
    889         if (state->incoming_frag.length != state->pkt->frag_length) {
    890                 DEBUG(5, ("Incorrect pdu length %u, expected %u\n",
    891                           (unsigned int)state->incoming_frag.length,
    892                           (unsigned int)state->pkt->frag_length));
    893                 tevent_req_nterror(req,  NT_STATUS_INVALID_PARAMETER);
    894978                return;
    895979        }
    … …  
    899983                                                &state->incoming_frag,
    900984                                                state->expected_pkt_type,
     985                                                state->call_id,
    901986                                                &rdata,
    902987                                                &state->reply_pdu);
    … …  
    907992                  nt_errstr(status)));
    908993
     994        if (state->pkt->ptype != DCERPC_PKT_FAULT && !NT_STATUS_IS_OK(status)) {
     995                /*
     996                 * TODO: do a real async disconnect ...
     997                 *
     998                 * For now do it sync...
     999                 */
     1000                TALLOC_FREE(state->cli->transport);
     1001        } else if (NT_STATUS_EQUAL(status, NT_STATUS_RPC_PROTOCOL_ERROR)) {
     1002                /*
     1003                 * TODO: do a real async disconnect ...
     1004                 *
     1005                 * For now do it sync...
     1006                 */
     1007                TALLOC_FREE(state->cli->transport);
     1008        } else if (NT_STATUS_EQUAL(status, NT_STATUS_RPC_SEC_PKG_ERROR)) {
     1009                /*
     1010                 * TODO: do a real async disconnect ...
     1011                 *
     1012                 * For now do it sync...
     1013                 */
     1014                TALLOC_FREE(state->cli->transport);
     1015        }
    9091016        if (!NT_STATUS_IS_OK(status)) {
    9101017                tevent_req_nterror(req, status);
    … …  
    9311038                         state->endianess?"little":"big",
    9321039                         state->pkt->drep[0]?"little":"big"));
    933                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
     1040                /*
     1041                 * TODO: do a real async disconnect ...
     1042                 *
     1043                 * For now do it sync...
     1044                 */
     1045                TALLOC_FREE(state->cli->transport);
     1046                tevent_req_nterror(req, NT_STATUS_RPC_PROTOCOL_ERROR);
     1047                return;
     1048        }
     1049
     1050        if (state->reply_pdu_offset + rdata.length > MAX_RPC_DATA_SIZE) {
     1051                /*
     1052                 * TODO: do a real async disconnect ...
     1053                 *
     1054                 * For now do it sync...
     1055                 */
     1056                TALLOC_FREE(state->cli->transport);
     1057                tevent_req_nterror(req, NT_STATUS_RPC_PROTOCOL_ERROR);
    9341058                return;
    9351059        }
    … …  
    9391063                if (!data_blob_realloc(NULL, &state->reply_pdu,
    9401064                                state->reply_pdu_offset + rdata.length)) {
     1065                        /*
     1066                         * TODO: do a real async disconnect ...
     1067                         *
     1068                         * For now do it sync...
     1069                         */
     1070                        TALLOC_FREE(state->cli->transport);
    9411071                        tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
    9421072                        return;
    … …  
    9681098                                        state->call_id,
    9691099                                        &state->incoming_frag);
     1100        if (subreq == NULL) {
     1101                /*
     1102                 * TODO: do a real async disconnect ...
     1103                 *
     1104                 * For now do it sync...
     1105                 */
     1106                TALLOC_FREE(state->cli->transport);
     1107        }
    9701108        if (tevent_req_nomem(subreq, req)) {
    9711109                return;
    … …  
    12371375                                                auth->auth_level,
    12381376                                                0, /* auth_pad_length */
    1239                                                 1, /* auth_context_id */
     1377                                                auth->auth_context_id,
    12401378                                                &auth_token,
    12411379                                                &auth_info);
    … …  
    12701408        DATA_BLOB *req_data;
    12711409        uint32_t req_data_sent;
     1410        DATA_BLOB req_trailer;
     1411        uint32_t req_trailer_sent;
     1412        bool verify_bitmask1;
     1413        bool verify_pcontext;
    12721414        DATA_BLOB rpc_out;
    12731415        DATA_BLOB reply_pdu;
    … …  
    12761418static void rpc_api_pipe_req_write_done(struct tevent_req *subreq);
    12771419static void rpc_api_pipe_req_done(struct tevent_req *subreq);
     1420static NTSTATUS prepare_verification_trailer(struct rpc_api_pipe_req_state *state);
    12781421static NTSTATUS prepare_next_frag(struct rpc_api_pipe_req_state *state,
    12791422                                  bool *is_last_frag);
    … …  
    13111454        }
    13121455
     1456        status = prepare_verification_trailer(state);
     1457        if (!NT_STATUS_IS_OK(status)) {
     1458                goto post_status;
     1459        }
     1460
    13131461        status = prepare_next_frag(state, &is_last_frag);
    13141462        if (!NT_STATUS_IS_OK(status)) {
    … …  
    13451493}
    13461494
     1495static NTSTATUS prepare_verification_trailer(struct rpc_api_pipe_req_state *state)
     1496{
     1497        struct pipe_auth_data *a = state->cli->auth;
     1498        struct dcerpc_sec_verification_trailer *t;
     1499        struct dcerpc_sec_vt *c = NULL;
     1500        struct ndr_push *ndr = NULL;
     1501        enum ndr_err_code ndr_err;
     1502        size_t align = 0;
     1503        size_t pad = 0;
     1504
     1505        if (a == NULL) {
     1506                return NT_STATUS_OK;
     1507        }
     1508
     1509        if (a->auth_level < DCERPC_AUTH_LEVEL_INTEGRITY) {
     1510                return NT_STATUS_OK;
     1511        }
     1512
     1513        t = talloc_zero(state, struct dcerpc_sec_verification_trailer);
     1514        if (t == NULL) {
     1515                return NT_STATUS_NO_MEMORY;
     1516        }
     1517
     1518        if (!a->verified_bitmask1) {
     1519                t->commands = talloc_realloc(t, t->commands,
     1520                                             struct dcerpc_sec_vt,
     1521                                             t->count.count + 1);
     1522                if (t->commands == NULL) {
     1523                        return NT_STATUS_NO_MEMORY;
     1524                }
     1525                c = &t->commands[t->count.count++];
     1526                ZERO_STRUCTP(c);
     1527
     1528                c->command = DCERPC_SEC_VT_COMMAND_BITMASK1;
     1529                state->verify_bitmask1 = true;
     1530        }
     1531
     1532        if (!state->cli->verified_pcontext) {
     1533                t->commands = talloc_realloc(t, t->commands,
     1534                                             struct dcerpc_sec_vt,
     1535                                             t->count.count + 1);
     1536                if (t->commands == NULL) {
     1537                        return NT_STATUS_NO_MEMORY;
     1538                }
     1539                c = &t->commands[t->count.count++];
     1540                ZERO_STRUCTP(c);
     1541
     1542                c->command = DCERPC_SEC_VT_COMMAND_PCONTEXT;
     1543                c->u.pcontext.abstract_syntax = state->cli->abstract_syntax;
     1544                c->u.pcontext.transfer_syntax = state->cli->transfer_syntax;
     1545
     1546                state->verify_pcontext = true;
     1547        }
     1548
     1549        if (true) { /* We do not support header signing */
     1550                t->commands = talloc_realloc(t, t->commands,
     1551                                             struct dcerpc_sec_vt,
     1552                                             t->count.count + 1);
     1553                if (t->commands == NULL) {
     1554                        return NT_STATUS_NO_MEMORY;
     1555                }
     1556                c = &t->commands[t->count.count++];
     1557                ZERO_STRUCTP(c);
     1558
     1559                c->command = DCERPC_SEC_VT_COMMAND_HEADER2;
     1560                c->u.header2.ptype = DCERPC_PKT_REQUEST;
     1561                c->u.header2.drep[0] = DCERPC_DREP_LE;
     1562                c->u.header2.drep[1] = 0;
     1563                c->u.header2.drep[2] = 0;
     1564                c->u.header2.drep[3] = 0;
     1565                c->u.header2.call_id = state->call_id;
     1566                c->u.header2.context_id = 0;
     1567                c->u.header2.opnum = state->op_num;
     1568        }
     1569
     1570        if (t->count.count == 0) {
     1571                TALLOC_FREE(t);
     1572                return NT_STATUS_OK;
     1573        }
     1574
     1575        c = &t->commands[t->count.count - 1];
     1576        c->command |= DCERPC_SEC_VT_COMMAND_END;
     1577
     1578        if (DEBUGLEVEL >= 10) {
     1579                NDR_PRINT_DEBUG(dcerpc_sec_verification_trailer, t);
     1580        }
     1581
     1582        ndr = ndr_push_init_ctx(state);
     1583        if (ndr == NULL) {
     1584                return NT_STATUS_NO_MEMORY;
     1585        }
     1586
     1587        ndr_err = ndr_push_dcerpc_sec_verification_trailer(ndr,
     1588                                                NDR_SCALARS | NDR_BUFFERS,
     1589                                                t);
     1590        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
     1591                return ndr_map_error2ntstatus(ndr_err);
     1592        }
     1593        state->req_trailer = ndr_push_blob(ndr);
     1594
     1595        align = state->req_data->length & 0x3;
     1596        if (align > 0) {
     1597                pad = 4 - align;
     1598        }
     1599        if (pad > 0) {
     1600                bool ok;
     1601                uint8_t *p;
     1602                const uint8_t zeros[4] = { 0, };
     1603
     1604                ok = data_blob_append(ndr, &state->req_trailer, zeros, pad);
     1605                if (!ok) {
     1606                        return NT_STATUS_NO_MEMORY;
     1607                }
     1608
     1609                /* move the padding to the start */
     1610                p = state->req_trailer.data;
     1611                memmove(p + pad, p, state->req_trailer.length - pad);
     1612                memset(p, 0, pad);
     1613        }
     1614
     1615        return NT_STATUS_OK;
     1616}
     1617
    13471618static NTSTATUS prepare_next_frag(struct rpc_api_pipe_req_state *state,
    13481619                                  bool *is_last_frag)
    13491620{
    1350         size_t data_sent_thistime;
    13511621        size_t auth_len;
    13521622        size_t frag_len;
    … …  
    13541624        size_t pad_len;
    13551625        size_t data_left;
    1356         NTSTATUS status;
     1626        size_t data_thistime;
     1627        size_t trailer_left;
     1628        size_t trailer_thistime = 0;
     1629        size_t total_left;
     1630        size_t total_thistime;
     1631        NTSTATUS status;
     1632        bool ok;
    13571633        union dcerpc_payload u;
    13581634
    13591635        data_left = state->req_data->length - state->req_data_sent;
     1636        trailer_left = state->req_trailer.length - state->req_trailer_sent;
     1637        total_left = data_left + trailer_left;
     1638        if ((total_left < data_left) || (total_left < trailer_left)) {
     1639                /*
     1640                 * overflow
     1641                 */
     1642                return NT_STATUS_INVALID_PARAMETER_MIX;
     1643        }
    13601644
    13611645        status = dcerpc_guess_sizes(state->cli->auth,
    1362                                     DCERPC_REQUEST_LENGTH, data_left,
     1646                                    DCERPC_REQUEST_LENGTH, total_left,
    13631647                                    state->cli->max_xmit_frag,
    13641648                                    CLIENT_NDR_PADDING_SIZE,
    1365                                     &data_sent_thistime,
     1649                                    &total_thistime,
    13661650                                    &frag_len, &auth_len, &pad_len);
    13671651        if (!NT_STATUS_IS_OK(status)) {
    … …  
    13731657        }
    13741658
    1375         if (data_sent_thistime == data_left) {
     1659        if (total_thistime == total_left) {
    13761660                flags |= DCERPC_PFC_FLAG_LAST;
    13771661        }
    13781662
     1663        data_thistime = MIN(total_thistime, data_left);
     1664        if (data_thistime < total_thistime) {
     1665                trailer_thistime = total_thistime - data_thistime;
     1666        }
     1667
    13791668        data_blob_free(&state->rpc_out);
    13801669
    13811670        ZERO_STRUCT(u.request);
    13821671
    1383         u.request.alloc_hint    = state->req_data->length;
     1672        u.request.alloc_hint    = total_left;
    13841673        u.request.context_id    = 0;
    13851674        u.request.opnum         = state->op_num;
    … …  
    14011690        dcerpc_set_frag_length(&state->rpc_out, frag_len);
    14021691
    1403         /* Copy in the data. */
    1404         if (!data_blob_append(NULL, &state->rpc_out,
     1692        if (data_thistime > 0) {
     1693                /* Copy in the data. */
     1694                ok = data_blob_append(NULL, &state->rpc_out,
    14051695                                state->req_data->data + state->req_data_sent,
    1406                                 data_sent_thistime)) {
    1407                 return NT_STATUS_NO_MEMORY;
     1696                                data_thistime);
     1697                if (!ok) {
     1698                        return NT_STATUS_NO_MEMORY;
     1699                }
     1700                state->req_data_sent += data_thistime;
     1701        }
     1702
     1703        if (trailer_thistime > 0) {
     1704                /* Copy in the verification trailer. */
     1705                ok = data_blob_append(NULL, &state->rpc_out,
     1706                                state->req_trailer.data + state->req_trailer_sent,
     1707                                trailer_thistime);
     1708                if (!ok) {
     1709                        return NT_STATUS_NO_MEMORY;
     1710                }
     1711                state->req_trailer_sent += trailer_thistime;
    14081712        }
    14091713
    … …  
    14251729        }
    14261730
    1427         state->req_data_sent += data_sent_thistime;
    14281731        *is_last_frag = ((flags & DCERPC_PFC_FLAG_LAST) != 0);
    14291732
    … …  
    14891792                return;
    14901793        }
     1794
     1795        if (state->cli->auth == NULL) {
     1796                tevent_req_done(req);
     1797                return;
     1798        }
     1799
     1800        if (state->verify_bitmask1) {
     1801                state->cli->auth->verified_bitmask1 = true;
     1802        }
     1803
     1804        if (state->verify_pcontext) {
     1805                state->cli->verified_pcontext = true;
     1806        }
     1807
    14911808        tevent_req_done(req);
    14921809}
    … …  
    15601877static NTSTATUS create_rpc_bind_auth3(TALLOC_CTX *mem_ctx,
    15611878                                struct rpc_pipe_client *cli,
    1562                                 uint32 rpc_call_id,
    1563                                 enum dcerpc_AuthType auth_type,
    1564                                 enum dcerpc_AuthLevel auth_level,
     1879                                struct pipe_auth_data *auth,
     1880                                uint32_t rpc_call_id,
    15651881                                DATA_BLOB *pauth_blob,
    15661882                                DATA_BLOB *rpc_out)
    … …  
    15721888
    15731889        status = dcerpc_push_dcerpc_auth(mem_ctx,
    1574                                          auth_type,
    1575                                          auth_level,
     1890                                         auth->auth_type,
     1891                                         auth->auth_level,
    15761892                                         0, /* auth_pad_length */
    1577                                          1, /* auth_context_id */
     1893                                         auth->auth_context_id,
    15781894                                         pauth_blob,
    15791895                                         &u.auth3.auth_info);
    … …  
    16051921
    16061922static NTSTATUS create_rpc_alter_context(TALLOC_CTX *mem_ctx,
    1607                                         enum dcerpc_AuthType auth_type,
    1608                                         enum dcerpc_AuthLevel auth_level,
    1609                                         uint32 rpc_call_id,
     1923                                        struct pipe_auth_data *auth,
     1924                                        uint32_t rpc_call_id,
    16101925                                        const struct ndr_syntax_id *abstract,
    16111926                                        const struct ndr_syntax_id *transfer,
    … …  
    16171932
    16181933        status = dcerpc_push_dcerpc_auth(mem_ctx,
    1619                                          auth_type,
    1620                                          auth_level,
     1934                                         auth->auth_type,
     1935                                         auth->auth_level,
    16211936                                         0, /* auth_pad_length */
    1622                                          1, /* auth_context_id */
     1937                                         auth->auth_context_id,
    16231938                                         pauth_blob,
    16241939                                         &auth_info);
    … …  
    16481963        bool auth3;
    16491964        uint32_t rpc_call_id;
     1965        struct netr_Authenticator auth;
     1966        struct netr_Authenticator return_auth;
     1967        struct netlogon_creds_CredentialState *creds;
     1968        union netr_Capabilities capabilities;
     1969        struct netr_LogonGetCapabilities r;
    16501970};
    16511971
    16521972static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq);
     1973static void rpc_pipe_bind_step_two_trigger(struct tevent_req *req);
    16531974static NTSTATUS rpc_bind_next_send(struct tevent_req *req,
    16541975                                   struct rpc_pipe_bind_state *state,
    … …  
    17542075        case DCERPC_AUTH_TYPE_NONE:
    17552076        case DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM:
    1756         case DCERPC_AUTH_TYPE_SCHANNEL:
    17572077                /* Bind complete. */
    17582078                tevent_req_done(req);
    17592079                return;
    17602080
    1761         case DCERPC_AUTH_TYPE_NTLMSSP:
    1762         case DCERPC_AUTH_TYPE_SPNEGO:
    1763         case DCERPC_AUTH_TYPE_KRB5:
    1764                 /* Paranoid lenght checks */
    1765                 if (pkt->frag_length < DCERPC_AUTH_TRAILER_LENGTH
    1766                                                 + pkt->auth_length) {
    1767                         tevent_req_nterror(req,
    1768                                         NT_STATUS_INFO_LENGTH_MISMATCH);
     2081        case DCERPC_AUTH_TYPE_SCHANNEL:
     2082                rpc_pipe_bind_step_two_trigger(req);
     2083                return;
     2084
     2085        default:
     2086                if (pkt->auth_length == 0) {
     2087                        tevent_req_nterror(req, NT_STATUS_RPC_PROTOCOL_ERROR);
    17692088                        return;
    17702089                }
    17712090                /* get auth credentials */
    1772                 status = dcerpc_pull_dcerpc_auth(talloc_tos(),
    1773                                                  &pkt->u.bind_ack.auth_info,
    1774                                                  &auth, false);
     2091                status = dcerpc_pull_auth_trailer(pkt, talloc_tos(),
     2092                                                  &pkt->u.bind_ack.auth_info,
     2093                                                  &auth, NULL, true);
    17752094                if (!NT_STATUS_IS_OK(status)) {
    17762095                        DEBUG(0, ("Failed to pull dcerpc auth: %s.\n",
    … …  
    17792098                        return;
    17802099                }
     2100
     2101                if (auth.auth_type != pauth->auth_type) {
     2102                        DEBUG(0, (__location__ " Auth type %u mismatch expected %u.\n",
     2103                                  auth.auth_type, pauth->auth_type));
     2104                        tevent_req_nterror(req, NT_STATUS_RPC_PROTOCOL_ERROR);
     2105                        return;
     2106                }
     2107
     2108                if (auth.auth_level != pauth->auth_level) {
     2109                        DEBUG(0, (__location__ " Auth level %u mismatch expected %u.\n",
     2110                                  auth.auth_level, pauth->auth_level));
     2111                        tevent_req_nterror(req, NT_STATUS_RPC_PROTOCOL_ERROR);
     2112                        return;
     2113                }
     2114
     2115                if (auth.auth_context_id != pauth->auth_context_id) {
     2116                        DEBUG(0, (__location__ " Auth context id %u mismatch expected %u.\n",
     2117                                  (unsigned)auth.auth_context_id,
     2118                                  (unsigned)pauth->auth_context_id));
     2119                        tevent_req_nterror(req, NT_STATUS_RPC_PROTOCOL_ERROR);
     2120                        return;
     2121                }
     2122
    17812123                break;
    1782 
    1783         default:
    1784                 goto err_out;
    17852124        }
    17862125
    … …  
    18702209}
    18712210
     2211static void rpc_pipe_bind_step_two_done(struct tevent_req *subreq);
     2212
     2213static void rpc_pipe_bind_step_two_trigger(struct tevent_req *req)
     2214{
     2215        struct rpc_pipe_bind_state *state =
     2216                tevent_req_data(req,
     2217                                struct rpc_pipe_bind_state);
     2218        struct dcerpc_binding_handle *b = state->cli->binding_handle;
     2219        struct schannel_state *schannel_auth =
     2220                talloc_get_type_abort(state->cli->auth->auth_ctx,
     2221                                      struct schannel_state);
     2222        struct tevent_req *subreq;
     2223
     2224        if (schannel_auth == NULL ||
     2225            !ndr_syntax_id_equal(&state->cli->abstract_syntax,
     2226                                 &ndr_table_netlogon.syntax_id)) {
     2227                tevent_req_done(req);
     2228                return;
     2229        }
     2230
     2231        ZERO_STRUCT(state->return_auth);
     2232
     2233        state->creds = netlogon_creds_copy(state, schannel_auth->creds);
     2234        if (state->creds == NULL) {
     2235                tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
     2236                return;
     2237        }
     2238
     2239        netlogon_creds_client_authenticator(state->creds, &state->auth);
     2240
     2241        state->r.in.server_name = state->cli->srv_name_slash;
     2242        state->r.in.computer_name = state->creds->computer_name;
     2243        state->r.in.credential = &state->auth;
     2244        state->r.in.query_level = 1;
     2245        state->r.in.return_authenticator = &state->return_auth;
     2246
     2247        state->r.out.capabilities = &state->capabilities;
     2248        state->r.out.return_authenticator = &state->return_auth;
     2249
     2250        subreq = dcerpc_netr_LogonGetCapabilities_r_send(talloc_tos(),
     2251                                                         state->ev,
     2252                                                         b,
     2253                                                         &state->r);
     2254        if (subreq == NULL) {
     2255                tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
     2256                return;
     2257        }
     2258
     2259        tevent_req_set_callback(subreq, rpc_pipe_bind_step_two_done, req);
     2260        return;
     2261}
     2262
     2263static void rpc_pipe_bind_step_two_done(struct tevent_req *subreq)
     2264{
     2265        struct tevent_req *req =
     2266                tevent_req_callback_data(subreq,
     2267                                         struct tevent_req);
     2268        struct rpc_pipe_bind_state *state =
     2269                tevent_req_data(req,
     2270                                struct rpc_pipe_bind_state);
     2271        struct schannel_state *schannel_auth =
     2272                talloc_get_type_abort(state->cli->auth->auth_ctx,
     2273                                      struct schannel_state);
     2274        NTSTATUS status;
     2275
     2276        status = dcerpc_netr_LogonGetCapabilities_r_recv(subreq, talloc_tos());
     2277        TALLOC_FREE(subreq);
     2278        if (NT_STATUS_EQUAL(status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
     2279                if (state->cli->dc->negotiate_flags &
     2280                    NETLOGON_NEG_SUPPORTS_AES) {
     2281                        DEBUG(5, ("AES is not supported and the error was %s\n",
     2282                                  nt_errstr(status)));
     2283                        tevent_req_nterror(req,
     2284                                           NT_STATUS_INVALID_NETWORK_RESPONSE);
     2285                        return;
     2286                }
     2287
     2288                /* This is probably NT */
     2289                DEBUG(5, ("We are checking against an NT - %s\n",
     2290                          nt_errstr(status)));
     2291                tevent_req_done(req);
     2292                return;
     2293        } else if (!NT_STATUS_IS_OK(status)) {
     2294                DEBUG(0, ("dcerpc_netr_LogonGetCapabilities_r_recv failed with %s\n",
     2295                          nt_errstr(status)));
     2296                tevent_req_nterror(req, status);
     2297                return;
     2298        }
     2299
     2300        if (NT_STATUS_EQUAL(state->r.out.result, NT_STATUS_NOT_IMPLEMENTED)) {
     2301                if (state->creds->negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
     2302                        /* This means AES isn't supported. */
     2303                        DEBUG(5, ("AES is not supported and the error was %s\n",
     2304                                  nt_errstr(state->r.out.result)));
     2305                        tevent_req_nterror(req,
     2306                                           NT_STATUS_INVALID_NETWORK_RESPONSE);
     2307                        return;
     2308                }
     2309
     2310                /* This is probably an old Samba version */
     2311                DEBUG(5, ("We are checking against an old Samba version - %s\n",
     2312                          nt_errstr(state->r.out.result)));
     2313                tevent_req_done(req);
     2314                return;
     2315        }
     2316
     2317        /* We need to check the credential state here, cause win2k3 and earlier
     2318         * returns NT_STATUS_NOT_IMPLEMENTED */
     2319        if (!netlogon_creds_client_check(state->creds,
     2320                                         &state->r.out.return_authenticator->cred)) {
     2321                /*
     2322                 * Server replied with bad credential. Fail.
     2323                 */
     2324                DEBUG(0,("rpc_pipe_bind_step_two_done: server %s "
     2325                         "replied with bad credential\n",
     2326                         state->cli->desthost));
     2327                tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL);
     2328                return;
     2329        }
     2330
     2331        TALLOC_FREE(schannel_auth->creds);
     2332        schannel_auth->creds = talloc_steal(state->cli, state->creds);
     2333
     2334        if (!NT_STATUS_IS_OK(state->r.out.result)) {
     2335                DEBUG(0, ("dcerpc_netr_LogonGetCapabilities_r_recv failed with %s\n",
     2336                          nt_errstr(state->r.out.result)));
     2337                tevent_req_nterror(req, state->r.out.result);
     2338                return;
     2339        }
     2340
     2341        if (state->creds->negotiate_flags !=
     2342            state->r.out.capabilities->server_capabilities) {
     2343                DEBUG(0, ("The client capabilities don't match the server "
     2344                          "capabilities: local[0x%08X] remote[0x%08X]\n",
     2345                          state->creds->negotiate_flags,
     2346                          state->capabilities.server_capabilities));
     2347                tevent_req_nterror(req,
     2348                                   NT_STATUS_INVALID_NETWORK_RESPONSE);
     2349                return;
     2350        }
     2351
     2352        /* TODO: Add downgrade dectection. */
     2353
     2354        tevent_req_done(req);
     2355        return;
     2356}
     2357
    18722358static NTSTATUS rpc_bind_next_send(struct tevent_req *req,
    18732359                                   struct rpc_pipe_bind_state *state,
    … …  
    18812367        data_blob_free(&state->rpc_out);
    18822368
    1883         status = create_rpc_alter_context(state,
    1884                                           auth->auth_type,
    1885                                           auth->auth_level,
     2369        status = create_rpc_alter_context(state, auth,
    18862370                                          state->rpc_call_id,
    18872371                                          &state->cli->abstract_syntax,
    … …  
    19162400        data_blob_free(&state->rpc_out);
    19172401
    1918         status = create_rpc_bind_auth3(state, state->cli,
     2402        status = create_rpc_bind_auth3(state, state->cli, auth,
    19192403                                        state->rpc_call_id,
    1920                                         auth->auth_type,
    1921                                         auth->auth_level,
    19222404                                        auth_token,
    19232405                                        &state->rpc_out);
    … …  
    21532635         * TODO: do a real async disconnect ...
    21542636         *
    2155          * For now the caller needs to free rpc_cli
     2637         * For now we do it sync...
    21562638         */
     2639        TALLOC_FREE(hs->rpc_cli->transport);
    21572640        hs->rpc_cli = NULL;
    21582641
    … …  
    22912774        result->auth_type = DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM;
    22922775        result->auth_level = DCERPC_AUTH_LEVEL_CONNECT;
     2776        result->auth_context_id = 1;
    22932777
    22942778        result->user_name = talloc_strdup(result, "");
    … …  
    23152799        result->auth_type = DCERPC_AUTH_TYPE_NONE;
    23162800        result->auth_level = DCERPC_AUTH_LEVEL_NONE;
     2801        result->auth_context_id = 0;
    23172802
    23182803        result->user_name = talloc_strdup(result, "");
    … …  
    23522837        result->auth_type = auth_type;
    23532838        result->auth_level = auth_level;
     2839        result->auth_context_id = 1;
    23542840
    23552841        result->user_name = talloc_strdup(result, username);
    … …  
    24232909        result->auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
    24242910        result->auth_level = auth_level;
     2911        result->auth_context_id = 1;
    24252912
    24262913        result->user_name = talloc_strdup(result, "");
    … …  
    30873574        auth->auth_type = DCERPC_AUTH_TYPE_KRB5;
    30883575        auth->auth_level = auth_level;
     3576        auth->auth_context_id = 1;
    30893577
    30903578        if (!username) {
    … …  
    31573645        auth->auth_type = DCERPC_AUTH_TYPE_SPNEGO;
    31583646        auth->auth_level = auth_level;
     3647        auth->auth_context_id = 1;
    31593648
    31603649        if (!username) {
    … …  
    32313720        auth->auth_type = DCERPC_AUTH_TYPE_SPNEGO;
    32323721        auth->auth_level = auth_level;
     3722        auth->auth_context_id = 1;
    32333723
    32343724        if (!username) {

  • vendor/current/source3/rpc_client/rpc_client.h

    r917 r919  
    4040        struct ndr_syntax_id abstract_syntax;
    4141        struct ndr_syntax_id transfer_syntax;
     42        bool verified_pcontext;
    4243
    4344        char *desthost;

  • vendor/current/source3/rpc_server/dfs/srv_dfs_nt.c

    r917 r919  
    412412{
    413413        /* FIXME: Implement your code here */
    414         p->rng_fault_state = True;
     414        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    415415        return WERR_NOT_SUPPORTED;
    416416}
    … …  
    419419{
    420420        /* FIXME: Implement your code here */
    421         p->rng_fault_state = True;
     421        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    422422        return WERR_NOT_SUPPORTED;
    423423}
    … …  
    426426{
    427427        /* FIXME: Implement your code here */
    428         p->rng_fault_state = True;
     428        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    429429        return WERR_NOT_SUPPORTED;
    430430}
    … …  
    433433{
    434434        /* FIXME: Implement your code here */
    435         p->rng_fault_state = True;
     435        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    436436        return WERR_NOT_SUPPORTED;
    437437}
    … …  
    440440{
    441441        /* FIXME: Implement your code here */
    442         p->rng_fault_state = True;
     442        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    443443        return WERR_NOT_SUPPORTED;
    444444}
    … …  
    447447{
    448448        /* FIXME: Implement your code here */
    449         p->rng_fault_state = True;
     449        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    450450        return WERR_NOT_SUPPORTED;
    451451}
    … …  
    454454{
    455455        /* FIXME: Implement your code here */
    456         p->rng_fault_state = True;
     456        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    457457        return WERR_NOT_SUPPORTED;
    458458}
    … …  
    461461{
    462462        /* FIXME: Implement your code here */
    463         p->rng_fault_state = True;
     463        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    464464        return WERR_NOT_SUPPORTED;
    465465}
    … …  
    468468{
    469469        /* FIXME: Implement your code here */
    470         p->rng_fault_state = True;
     470        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    471471        return WERR_NOT_SUPPORTED;
    472472}
    … …  
    475475{
    476476        /* FIXME: Implement your code here */
    477         p->rng_fault_state = True;
     477        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    478478        return WERR_NOT_SUPPORTED;
    479479}
    … …  
    482482{
    483483        /* FIXME: Implement your code here */
    484         p->rng_fault_state = True;
     484        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    485485        return WERR_NOT_SUPPORTED;
    486486}
    … …  
    489489{
    490490        /* FIXME: Implement your code here */
    491         p->rng_fault_state = True;
     491        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    492492        return WERR_NOT_SUPPORTED;
    493493}
    … …  
    496496{
    497497        /* FIXME: Implement your code here */
    498         p->rng_fault_state = True;
     498        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    499499        return WERR_NOT_SUPPORTED;
    500500}
    … …  
    503503{
    504504        /* FIXME: Implement your code here */
    505         p->rng_fault_state = True;
     505        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    506506        return WERR_NOT_SUPPORTED;
    507507}
    … …  
    510510{
    511511        /* FIXME: Implement your code here */
    512         p->rng_fault_state = True;
     512        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    513513        return WERR_NOT_SUPPORTED;
    514514}
    … …  
    517517{
    518518        /* FIXME: Implement your code here */
    519         p->rng_fault_state = True;
     519        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    520520        return WERR_NOT_SUPPORTED;
    521521}
    … …  
    524524{
    525525        /* FIXME: Implement your code here */
    526         p->rng_fault_state = True;
     526        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    527527        return WERR_NOT_SUPPORTED;
    528528}
    … …  
    531531{
    532532        /* FIXME: Implement your code here */
    533         p->rng_fault_state = True;
    534         return WERR_NOT_SUPPORTED;
    535 }
     533        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     534        return WERR_NOT_SUPPORTED;
     535}

  • vendor/current/source3/rpc_server/dssetup/srv_dssetup_nt.c

    r917 r919  
    131131                                        struct dssetup_DsRoleDnsNameToFlatName *r)
    132132{
    133         p->rng_fault_state = true;
     133        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    134134        return WERR_NOT_SUPPORTED;
    135135}
    … …  
    141141                             struct dssetup_DsRoleDcAsDc *r)
    142142{
    143         p->rng_fault_state = true;
     143        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    144144        return WERR_NOT_SUPPORTED;
    145145}
    … …  
    151151                                  struct dssetup_DsRoleDcAsReplica *r)
    152152{
    153         p->rng_fault_state = true;
     153        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    154154        return WERR_NOT_SUPPORTED;
    155155}
    … …  
    161161                               struct dssetup_DsRoleDemoteDc *r)
    162162{
    163         p->rng_fault_state = true;
     163        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    164164        return WERR_NOT_SUPPORTED;
    165165}
    … …  
    171171                                             struct dssetup_DsRoleGetDcOperationProgress *r)
    172172{
    173         p->rng_fault_state = true;
     173        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    174174        return WERR_NOT_SUPPORTED;
    175175}
    … …  
    181181                                            struct dssetup_DsRoleGetDcOperationResults *r)
    182182{
    183         p->rng_fault_state = true;
     183        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    184184        return WERR_NOT_SUPPORTED;
    185185}
    … …  
    191191                             struct dssetup_DsRoleCancel *r)
    192192{
    193         p->rng_fault_state = true;
     193        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    194194        return WERR_NOT_SUPPORTED;
    195195}
    … …  
    201201                                                struct dssetup_DsRoleServerSaveStateForUpgrade *r)
    202202{
    203         p->rng_fault_state = true;
     203        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    204204        return WERR_NOT_SUPPORTED;
    205205}
    … …  
    211211                                             struct dssetup_DsRoleUpgradeDownlevelServer *r)
    212212{
    213         p->rng_fault_state = true;
     213        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    214214        return WERR_NOT_SUPPORTED;
    215215}
    … …  
    221221                                                  struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
    222222{
    223         p->rng_fault_state = true;
    224         return WERR_NOT_SUPPORTED;
    225 }
     223        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     224        return WERR_NOT_SUPPORTED;
     225}

  • vendor/current/source3/rpc_server/echo/srv_echo_nt.c

    r917 r919  
    8888void _echo_TestCall(struct pipes_struct *p, struct echo_TestCall *r)
    8989{
    90         p->rng_fault_state = True;
     90        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    9191        return;
    9292}
    … …  
    9494NTSTATUS _echo_TestCall2(struct pipes_struct *p, struct echo_TestCall2 *r)
    9595{
    96         p->rng_fault_state = True;
     96        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    9797        return NT_STATUS_OK;
    9898}
    … …  
    106106void _echo_TestEnum(struct pipes_struct *p, struct echo_TestEnum *r)
    107107{
    108         p->rng_fault_state = True;
     108        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    109109        return;
    110110}
    … …  
    112112void _echo_TestSurrounding(struct pipes_struct *p, struct echo_TestSurrounding *r)
    113113{
    114         p->rng_fault_state = True;
     114        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    115115        return;
    116116}
    … …  
    118118uint16 _echo_TestDoublePointer(struct pipes_struct *p, struct echo_TestDoublePointer *r)
    119119{
    120         p->rng_fault_state = True;
     120        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    121121        return 0;
    122122}

  • vendor/current/source3/rpc_server/epmapper/srv_epmapper.c

    r917 r919  
    298298        if (p->transport != NCALRPC ||
    299299            !is_priviledged_pipe(p->session_info)) {
     300                p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    300301                return EPMAPPER_STATUS_CANT_PERFORM_OP;
    301302        }
    … …  
    434435        if (p->transport != NCALRPC ||
    435436            !is_priviledged_pipe(p->session_info)) {
     437                p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    436438                return EPMAPPER_STATUS_CANT_PERFORM_OP;
    437439        }
    … …  
    10971099                      struct epm_InqObject *r)
    10981100{
    1099         p->rng_fault_state = true;
     1101        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11001102        return EPMAPPER_STATUS_CANT_PERFORM_OP;
    11011103}
    … …  
    11111113                       struct epm_MgmtDelete *r)
    11121114{
    1113         p->rng_fault_state = true;
     1115        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11141116        return EPMAPPER_STATUS_CANT_PERFORM_OP;
    11151117}
    … …  
    11221124                    struct epm_MapAuth *r)
    11231125{
    1124         p->rng_fault_state = true;
     1126        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11251127        return EPMAPPER_STATUS_CANT_PERFORM_OP;
    11261128}

  • vendor/current/source3/rpc_server/eventlog/srv_eventlog_nt.c

    r917 r919  
    696696NTSTATUS _eventlog_BackupEventLogW(struct pipes_struct *p, struct eventlog_BackupEventLogW *r)
    697697{
    698         p->rng_fault_state = True;
     698        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    699699        return NT_STATUS_NOT_IMPLEMENTED;
    700700}
    … …  
    839839                                         struct eventlog_DeregisterEventSource *r)
    840840{
    841         p->rng_fault_state = True;
     841        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    842842        return NT_STATUS_NOT_IMPLEMENTED;
    843843}
    … …  
    846846                                struct eventlog_ChangeNotify *r)
    847847{
    848         p->rng_fault_state = True;
     848        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    849849        return NT_STATUS_NOT_IMPLEMENTED;
    850850}
    … …  
    853853                                        struct eventlog_RegisterEventSourceW *r)
    854854{
    855         p->rng_fault_state = True;
     855        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    856856        return NT_STATUS_NOT_IMPLEMENTED;
    857857}
    … …  
    860860                                       struct eventlog_OpenBackupEventLogW *r)
    861861{
    862         p->rng_fault_state = True;
     862        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    863863        return NT_STATUS_NOT_IMPLEMENTED;
    864864}
    … …  
    867867                                  struct eventlog_ClearEventLogA *r)
    868868{
    869         p->rng_fault_state = True;
     869        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    870870        return NT_STATUS_NOT_IMPLEMENTED;
    871871}
    … …  
    874874                                   struct eventlog_BackupEventLogA *r)
    875875{
    876         p->rng_fault_state = True;
     876        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    877877        return NT_STATUS_NOT_IMPLEMENTED;
    878878}
    … …  
    881881                                 struct eventlog_OpenEventLogA *r)
    882882{
    883         p->rng_fault_state = True;
     883        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    884884        return NT_STATUS_NOT_IMPLEMENTED;
    885885}
    … …  
    888888                                        struct eventlog_RegisterEventSourceA *r)
    889889{
    890         p->rng_fault_state = True;
     890        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    891891        return NT_STATUS_NOT_IMPLEMENTED;
    892892}
    … …  
    895895                                       struct eventlog_OpenBackupEventLogA *r)
    896896{
    897         p->rng_fault_state = True;
     897        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    898898        return NT_STATUS_NOT_IMPLEMENTED;
    899899}
    … …  
    902902                                 struct eventlog_ReadEventLogA *r)
    903903{
    904         p->rng_fault_state = True;
     904        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    905905        return NT_STATUS_NOT_IMPLEMENTED;
    906906}
    … …  
    909909                                struct eventlog_ReportEventA *r)
    910910{
    911         p->rng_fault_state = True;
     911        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    912912        return NT_STATUS_NOT_IMPLEMENTED;
    913913}
    … …  
    916916                                      struct eventlog_RegisterClusterSvc *r)
    917917{
    918         p->rng_fault_state = True;
     918        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    919919        return NT_STATUS_NOT_IMPLEMENTED;
    920920}
    … …  
    923923                                        struct eventlog_DeregisterClusterSvc *r)
    924924{
    925         p->rng_fault_state = True;
     925        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    926926        return NT_STATUS_NOT_IMPLEMENTED;
    927927}
    … …  
    930930                                      struct eventlog_WriteClusterEvents *r)
    931931{
    932         p->rng_fault_state = True;
     932        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    933933        return NT_STATUS_NOT_IMPLEMENTED;
    934934}
    … …  
    937937                                         struct eventlog_ReportEventAndSourceW *r)
    938938{
    939         p->rng_fault_state = True;
    940         return NT_STATUS_NOT_IMPLEMENTED;
    941 }
     939        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     940        return NT_STATUS_NOT_IMPLEMENTED;
     941}

  • vendor/current/source3/rpc_server/lsa/srv_lsa_nt.c

    r917 r919  
    818818
    819819        if ((pdb_capabilities() & PDB_CAP_ADS) == 0) {
    820                 p->rng_fault_state = True;
     820                p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    821821                return NT_STATUS_NOT_IMPLEMENTED;
    822822        }
    … …  
    32113211NTSTATUS _lsa_SetSecObj(struct pipes_struct *p, struct lsa_SetSecObj *r)
    32123212{
    3213         p->rng_fault_state = True;
     3213        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32143214        return NT_STATUS_NOT_IMPLEMENTED;
    32153215}
    … …  
    32183218                             struct lsa_ChangePassword *r)
    32193219{
    3220         p->rng_fault_state = True;
     3220        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32213221        return NT_STATUS_NOT_IMPLEMENTED;
    32223222}
    … …  
    32243224NTSTATUS _lsa_SetInfoPolicy(struct pipes_struct *p, struct lsa_SetInfoPolicy *r)
    32253225{
    3226         p->rng_fault_state = True;
     3226        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32273227        return NT_STATUS_NOT_IMPLEMENTED;
    32283228}
    … …  
    32303230NTSTATUS _lsa_ClearAuditLog(struct pipes_struct *p, struct lsa_ClearAuditLog *r)
    32313231{
    3232         p->rng_fault_state = True;
     3232        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32333233        return NT_STATUS_NOT_IMPLEMENTED;
    32343234}
    … …  
    32373237                                  struct lsa_GetQuotasForAccount *r)
    32383238{
    3239         p->rng_fault_state = True;
     3239        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32403240        return NT_STATUS_NOT_IMPLEMENTED;
    32413241}
    … …  
    32443244                                  struct lsa_SetQuotasForAccount *r)
    32453245{
    3246         p->rng_fault_state = True;
     3246        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32473247        return NT_STATUS_NOT_IMPLEMENTED;
    32483248}
    … …  
    32513251                                          struct lsa_SetInformationTrustedDomain *r)
    32523252{
    3253         p->rng_fault_state = True;
     3253        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32543254        return NT_STATUS_NOT_IMPLEMENTED;
    32553255}
    … …  
    32573257NTSTATUS _lsa_QuerySecret(struct pipes_struct *p, struct lsa_QuerySecret *r)
    32583258{
    3259         p->rng_fault_state = True;
     3259        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32603260        return NT_STATUS_NOT_IMPLEMENTED;
    32613261}
    … …  
    32643264                                   struct lsa_SetTrustedDomainInfo *r)
    32653265{
    3266         p->rng_fault_state = True;
     3266        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32673267        return NT_STATUS_NOT_IMPLEMENTED;
    32683268}
    … …  
    32713271                               struct lsa_StorePrivateData *r)
    32723272{
    3273         p->rng_fault_state = True;
     3273        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32743274        return NT_STATUS_NOT_IMPLEMENTED;
    32753275}
    … …  
    32783278                                  struct lsa_RetrievePrivateData *r)
    32793279{
    3280         p->rng_fault_state = True;
     3280        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32813281        return NT_STATUS_NOT_IMPLEMENTED;
    32823282}
    … …  
    32853285                             struct lsa_SetInfoPolicy2 *r)
    32863286{
    3287         p->rng_fault_state = True;
     3287        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32883288        return NT_STATUS_NOT_IMPLEMENTED;
    32893289}
    … …  
    32923292                                         struct lsa_SetTrustedDomainInfoByName *r)
    32933293{
    3294         p->rng_fault_state = True;
     3294        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    32953295        return NT_STATUS_NOT_IMPLEMENTED;
    32963296}
    … …  
    33113311
    33123312        if (!(pdb_capabilities() & PDB_CAP_TRUSTED_DOMAINS_EX)) {
    3313                 p->rng_fault_state = True;
     3313                p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    33143314                return NT_STATUS_NOT_IMPLEMENTED;
    33153315        }
    … …  
    33803380                                           struct lsa_QueryDomainInformationPolicy *r)
    33813381{
    3382         p->rng_fault_state = True;
     3382        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    33833383        return NT_STATUS_NOT_IMPLEMENTED;
    33843384}
    … …  
    33873387                                         struct lsa_SetDomainInformationPolicy *r)
    33883388{
    3389         p->rng_fault_state = True;
     3389        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    33903390        return NT_STATUS_NOT_IMPLEMENTED;
    33913391}
    … …  
    33933393NTSTATUS _lsa_TestCall(struct pipes_struct *p, struct lsa_TestCall *r)
    33943394{
    3395         p->rng_fault_state = True;
     3395        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    33963396        return NT_STATUS_NOT_IMPLEMENTED;
    33973397}
    … …  
    33993399NTSTATUS _lsa_CREDRWRITE(struct pipes_struct *p, struct lsa_CREDRWRITE *r)
    34003400{
    3401         p->rng_fault_state = True;
     3401        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34023402        return NT_STATUS_NOT_IMPLEMENTED;
    34033403}
    … …  
    34053405NTSTATUS _lsa_CREDRREAD(struct pipes_struct *p, struct lsa_CREDRREAD *r)
    34063406{
    3407         p->rng_fault_state = True;
     3407        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34083408        return NT_STATUS_NOT_IMPLEMENTED;
    34093409}
    … …  
    34113411NTSTATUS _lsa_CREDRENUMERATE(struct pipes_struct *p, struct lsa_CREDRENUMERATE *r)
    34123412{
    3413         p->rng_fault_state = True;
     3413        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34143414        return NT_STATUS_NOT_IMPLEMENTED;
    34153415}
    … …  
    34183418                                          struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
    34193419{
    3420         p->rng_fault_state = True;
     3420        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34213421        return NT_STATUS_NOT_IMPLEMENTED;
    34223422}
    … …  
    34253425                                         struct lsa_CREDRREADDOMAINCREDENTIALS *r)
    34263426{
    3427         p->rng_fault_state = True;
     3427        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34283428        return NT_STATUS_NOT_IMPLEMENTED;
    34293429}
    … …  
    34313431NTSTATUS _lsa_CREDRDELETE(struct pipes_struct *p, struct lsa_CREDRDELETE *r)
    34323432{
    3433         p->rng_fault_state = True;
     3433        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34343434        return NT_STATUS_NOT_IMPLEMENTED;
    34353435}
    … …  
    34383438                                 struct lsa_CREDRGETTARGETINFO *r)
    34393439{
    3440         p->rng_fault_state = True;
     3440        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34413441        return NT_STATUS_NOT_IMPLEMENTED;
    34423442}
    … …  
    34453445                                 struct lsa_CREDRPROFILELOADED *r)
    34463446{
    3447         p->rng_fault_state = True;
     3447        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34483448        return NT_STATUS_NOT_IMPLEMENTED;
    34493449}
    … …  
    34523452                                   struct lsa_CREDRGETSESSIONTYPES *r)
    34533453{
    3454         p->rng_fault_state = True;
     3454        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34553455        return NT_STATUS_NOT_IMPLEMENTED;
    34563456}
    … …  
    34593459                                     struct lsa_LSARREGISTERAUDITEVENT *r)
    34603460{
    3461         p->rng_fault_state = True;
     3461        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34623462        return NT_STATUS_NOT_IMPLEMENTED;
    34633463}
    … …  
    34663466                                struct lsa_LSARGENAUDITEVENT *r)
    34673467{
    3468         p->rng_fault_state = True;
     3468        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34693469        return NT_STATUS_NOT_IMPLEMENTED;
    34703470}
    … …  
    34733473                                       struct lsa_LSARUNREGISTERAUDITEVENT *r)
    34743474{
    3475         p->rng_fault_state = True;
     3475        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34763476        return NT_STATUS_NOT_IMPLEMENTED;
    34773477}
    … …  
    34803480                                              struct lsa_lsaRQueryForestTrustInformation *r)
    34813481{
    3482         p->rng_fault_state = True;
     3482        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    34833483        return NT_STATUS_NOT_IMPLEMENTED;
    34843484}
    … …  
    39933993                          struct lsa_CREDRRENAME *r)
    39943994{
    3995         p->rng_fault_state = True;
     3995        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    39963996        return NT_STATUS_NOT_IMPLEMENTED;
    39973997}
    … …  
    40004000                                struct lsa_LSAROPENPOLICYSCE *r)
    40014001{
    4002         p->rng_fault_state = True;
     4002        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    40034003        return NT_STATUS_NOT_IMPLEMENTED;
    40044004}
    … …  
    40074007                                                 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
    40084008{
    4009         p->rng_fault_state = True;
     4009        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    40104010        return NT_STATUS_NOT_IMPLEMENTED;
    40114011}
    … …  
    40144014                                                   struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
    40154015{
    4016         p->rng_fault_state = True;
     4016        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    40174017        return NT_STATUS_NOT_IMPLEMENTED;
    40184018}
    … …  
    40214021                                         struct lsa_LSARADTREPORTSECURITYEVENT *r)
    40224022{
    4023         p->rng_fault_state = True;
     4023        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    40244024        return NT_STATUS_NOT_IMPLEMENTED;
    40254025}

  • vendor/current/source3/rpc_server/netlogon/srv_netlog_nt.c

    r914 r919  
    15091509        {
    15101510                const char *wksname = nt_workstation;
     1511                const char *workgroup = lp_workgroup();
    15111512
    15121513                status = make_auth_context_fixed(talloc_tos(), &auth_context,
    … …  
    15331534                        status = NT_STATUS_NO_MEMORY;
    15341535                }
     1536
     1537                if (NT_STATUS_IS_OK(status)) {
     1538                        status = NTLMv2_RESPONSE_verify_netlogon_creds(
     1539                                                user_info->client.account_name,
     1540                                                user_info->client.domain_name,
     1541                                                user_info->password.response.nt,
     1542                                                creds, workgroup);
     1543                }
    15351544                break;
    15361545        }
    … …  
    16371646                break;
    16381647        case 6:
     1648                /* Only allow this if the pipe is protected. */
     1649                if (p->auth.auth_level < DCERPC_AUTH_LEVEL_PRIVACY) {
     1650                        DEBUG(0,("netr_Validation6: client %s not using privacy for netlogon\n",
     1651                                get_remote_machine_name()));
     1652                        status = NT_STATUS_INVALID_PARAMETER;
     1653                        break;
     1654                }
     1655
    16391656                status = serverinfo_to_SamInfo6(server_info, pipe_session_key, 16,
    16401657                                                r->out.validation->sam6);
    … …  
    17881805                           struct netr_LogonUasLogon *r)
    17891806{
    1790         p->rng_fault_state = true;
     1807        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    17911808        return WERR_NOT_SUPPORTED;
    17921809}
    … …  
    17981815                            struct netr_LogonUasLogoff *r)
    17991816{
    1800         p->rng_fault_state = true;
     1817        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18011818        return WERR_NOT_SUPPORTED;
    18021819}
    … …  
    18081825                              struct netr_DatabaseDeltas *r)
    18091826{
    1810         p->rng_fault_state = true;
     1827        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18111828        return NT_STATUS_NOT_IMPLEMENTED;
    18121829}
    … …  
    18181835                            struct netr_DatabaseSync *r)
    18191836{
    1820         p->rng_fault_state = true;
     1837        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18211838        return NT_STATUS_NOT_IMPLEMENTED;
    18221839}
    … …  
    18281845                             struct netr_AccountDeltas *r)
    18291846{
    1830         p->rng_fault_state = true;
     1847        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18311848        return NT_STATUS_NOT_IMPLEMENTED;
    18321849}
    … …  
    18381855                           struct netr_AccountSync *r)
    18391856{
    1840         p->rng_fault_state = true;
     1857        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    18411858        return NT_STATUS_NOT_IMPLEMENTED;
    18421859}
    … …  
    19791996                             struct netr_DatabaseSync2 *r)
    19801997{
    1981         p->rng_fault_state = true;
     1998        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    19821999        return NT_STATUS_NOT_IMPLEMENTED;
    19832000}
    … …  
    19892006                            struct netr_DatabaseRedo *r)
    19902007{
    1991         p->rng_fault_state = true;
     2008        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    19922009        return NT_STATUS_NOT_IMPLEMENTED;
    19932010}
    … …  
    19992016                          struct netr_DsRGetDCName *r)
    20002017{
    2001         p->rng_fault_state = true;
     2018        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20022019        return WERR_NOT_SUPPORTED;
    20032020}
    … …  
    20182035                                     struct netr_NETRLOGONSETSERVICEBITS *r)
    20192036{
    2020         p->rng_fault_state = true;
     2037        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20212038        return WERR_NOT_SUPPORTED;
    20222039}
    … …  
    20282045                              struct netr_LogonGetTrustRid *r)
    20292046{
    2030         p->rng_fault_state = true;
     2047        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20312048        return WERR_NOT_SUPPORTED;
    20322049}
    … …  
    20382055                                          struct netr_NETRLOGONCOMPUTESERVERDIGEST *r)
    20392056{
    2040         p->rng_fault_state = true;
     2057        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20412058        return WERR_NOT_SUPPORTED;
    20422059}
    … …  
    20482065                                          struct netr_NETRLOGONCOMPUTECLIENTDIGEST *r)
    20492066{
    2050         p->rng_fault_state = true;
     2067        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20512068        return WERR_NOT_SUPPORTED;
    20522069}
    … …  
    20582075                            struct netr_DsRGetDCNameEx *r)
    20592076{
    2060         p->rng_fault_state = true;
     2077        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20612078        return WERR_NOT_SUPPORTED;
    20622079}
    … …  
    20682085                            struct netr_DsRGetSiteName *r)
    20692086{
    2070         p->rng_fault_state = true;
     2087        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20712088        return WERR_NOT_SUPPORTED;
    20722089}
    … …  
    20782095                                  struct netr_LogonGetDomainInfo *r)
    20792096{
    2080         p->rng_fault_state = true;
     2097        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20812098        return NT_STATUS_NOT_IMPLEMENTED;
    20822099}
    … …  
    20882105                               struct netr_ServerPasswordGet *r)
    20892106{
    2090         p->rng_fault_state = true;
     2107        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    20912108        return WERR_NOT_SUPPORTED;
    20922109}
    … …  
    20982115                                struct netr_NETRLOGONSENDTOSAM *r)
    20992116{
    2100         p->rng_fault_state = true;
     2117        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21012118        return WERR_NOT_SUPPORTED;
    21022119}
    … …  
    21082125                                    struct netr_DsRAddressToSitenamesW *r)
    21092126{
    2110         p->rng_fault_state = true;
     2127        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21112128        return WERR_NOT_SUPPORTED;
    21122129}
    … …  
    21182135                             struct netr_DsRGetDCNameEx2 *r)
    21192136{
    2120         p->rng_fault_state = true;
     2137        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21212138        return WERR_NOT_SUPPORTED;
    21222139}
    … …  
    21282145                                                 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *r)
    21292146{
    2130         p->rng_fault_state = true;
     2147        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21312148        return WERR_NOT_SUPPORTED;
    21322149}
    … …  
    21382155                                           struct netr_NetrEnumerateTrustedDomainsEx *r)
    21392156{
    2140         p->rng_fault_state = true;
     2157        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21412158        return WERR_NOT_SUPPORTED;
    21422159}
    … …  
    21482165                                      struct netr_DsRAddressToSitenamesExW *r)
    21492166{
    2150         p->rng_fault_state = true;
     2167        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21512168        return WERR_NOT_SUPPORTED;
    21522169}
    … …  
    21582175                                   struct netr_DsrGetDcSiteCoverageW *r)
    21592176{
    2160         p->rng_fault_state = true;
     2177        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21612178        return WERR_NOT_SUPPORTED;
    21622179}
    … …  
    21682185                                      struct netr_DsrEnumerateDomainTrusts *r)
    21692186{
    2170         p->rng_fault_state = true;
     2187        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21712188        return WERR_NOT_SUPPORTED;
    21722189}
    … …  
    21782195                                         struct netr_DsrDeregisterDNSHostRecords *r)
    21792196{
    2180         p->rng_fault_state = true;
     2197        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21812198        return WERR_NOT_SUPPORTED;
    21822199}
    … …  
    21882205                                       struct netr_ServerTrustPasswordsGet *r)
    21892206{
    2190         p->rng_fault_state = true;
     2207        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    21912208        return NT_STATUS_NOT_IMPLEMENTED;
    21922209}
    … …  
    21982215                                          struct netr_DsRGetForestTrustInformation *r)
    21992216{
    2200         p->rng_fault_state = true;
     2217        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    22012218        return WERR_NOT_SUPPORTED;
    22022219}
    … …  
    22722289        /* TODO: check server name */
    22732290
    2274         status = schannel_check_creds_state(p->mem_ctx, lp_private_dir(),
    2275                                             r->in.computer_name,
    2276                                             r->in.credential,
    2277                                             r->out.return_authenticator,
    2278                                             &creds);
     2291        become_root();
     2292        status = netr_creds_server_step_check(p, p->mem_ctx,
     2293                                              r->in.computer_name,
     2294                                              r->in.credential,
     2295                                              r->out.return_authenticator,
     2296                                              &creds);
     2297        unbecome_root();
    22792298        if (!NT_STATUS_IS_OK(status)) {
    22802299                return status;
    … …  
    23722391        /* TODO: check server name */
    23732392
    2374         status = schannel_check_creds_state(p->mem_ctx, lp_private_dir(),
    2375                                             r->in.computer_name,
    2376                                             r->in.credential,
    2377                                             r->out.return_authenticator,
    2378                                             &creds);
     2393        become_root();
     2394        status = netr_creds_server_step_check(p, p->mem_ctx,
     2395                                              r->in.computer_name,
     2396                                              r->in.credential,
     2397                                              r->out.return_authenticator,
     2398                                              &creds);
     2399        unbecome_root();
    23792400        if (!NT_STATUS_IS_OK(status)) {
    23802401                return status;
    … …  
    24772498                        struct netr_Unused47 *r)
    24782499{
    2479         p->rng_fault_state = true;
     2500        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    24802501        return NT_STATUS_NOT_IMPLEMENTED;
    24812502}
    … …  
    24872508                                                 struct netr_DsrUpdateReadOnlyServerDnsRecords *r)
    24882509{
    2489         p->rng_fault_state = true;
     2510        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    24902511        return NT_STATUS_NOT_IMPLEMENTED;
    24912512}

  • vendor/current/source3/rpc_server/ntsvcs/srv_ntsvcs_nt.c

    r917 r919  
    228228                       struct PNP_Disconnect *r)
    229229{
    230         p->rng_fault_state = true;
     230        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    231231        return WERR_NOT_SUPPORTED;
    232232}
    … …  
    238238                    struct PNP_Connect *r)
    239239{
    240         p->rng_fault_state = true;
     240        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    241241        return WERR_NOT_SUPPORTED;
    242242}
    … …  
    248248                           struct PNP_GetGlobalState *r)
    249249{
    250         p->rng_fault_state = true;
     250        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    251251        return WERR_NOT_SUPPORTED;
    252252}
    … …  
    258258                          struct PNP_InitDetection *r)
    259259{
    260         p->rng_fault_state = true;
     260        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    261261        return WERR_NOT_SUPPORTED;
    262262}
    … …  
    268268                        struct PNP_ReportLogOn *r)
    269269{
    270         p->rng_fault_state = true;
     270        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    271271        return WERR_NOT_SUPPORTED;
    272272}
    … …  
    278278                                  struct PNP_GetRootDeviceInstance *r)
    279279{
    280         p->rng_fault_state = true;
     280        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    281281        return WERR_NOT_SUPPORTED;
    282282}
    … …  
    288288                                     struct PNP_GetRelatedDeviceInstance *r)
    289289{
    290         p->rng_fault_state = true;
     290        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    291291        return WERR_NOT_SUPPORTED;
    292292}
    … …  
    298298                             struct PNP_EnumerateSubKeys *r)
    299299{
    300         p->rng_fault_state = true;
     300        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    301301        return WERR_NOT_SUPPORTED;
    302302}
    … …  
    308308                     struct PNP_GetDepth *r)
    309309{
    310         p->rng_fault_state = true;
     310        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    311311        return WERR_NOT_SUPPORTED;
    312312}
    … …  
    318318                             struct PNP_SetDeviceRegProp *r)
    319319{
    320         p->rng_fault_state = true;
     320        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    321321        return WERR_NOT_SUPPORTED;
    322322}
    … …  
    328328                             struct PNP_GetClassInstance *r)
    329329{
    330         p->rng_fault_state = true;
     330        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    331331        return WERR_NOT_SUPPORTED;
    332332}
    … …  
    338338                      struct PNP_CreateKey *r)
    339339{
    340         p->rng_fault_state = true;
     340        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    341341        return WERR_NOT_SUPPORTED;
    342342}
    … …  
    348348                              struct PNP_DeleteRegistryKey *r)
    349349{
    350         p->rng_fault_state = true;
     350        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    351351        return WERR_NOT_SUPPORTED;
    352352}
    … …  
    358358                          struct PNP_GetClassCount *r)
    359359{
    360         p->rng_fault_state = true;
     360        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    361361        return WERR_NOT_SUPPORTED;
    362362}
    … …  
    368368                         struct PNP_GetClassName *r)
    369369{
    370         p->rng_fault_state = true;
     370        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    371371        return WERR_NOT_SUPPORTED;
    372372}
    … …  
    378378                           struct PNP_DeleteClassKey *r)
    379379{
    380         p->rng_fault_state = true;
     380        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    381381        return WERR_NOT_SUPPORTED;
    382382}
    … …  
    388388                                    struct PNP_GetInterfaceDeviceAlias *r)
    389389{
    390         p->rng_fault_state = true;
     390        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    391391        return WERR_NOT_SUPPORTED;
    392392}
    … …  
    398398                                   struct PNP_GetInterfaceDeviceList *r)
    399399{
    400         p->rng_fault_state = true;
     400        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    401401        return WERR_NOT_SUPPORTED;
    402402}
    … …  
    408408                                       struct PNP_GetInterfaceDeviceListSize *r)
    409409{
    410         p->rng_fault_state = true;
     410        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    411411        return WERR_NOT_SUPPORTED;
    412412}
    … …  
    418418                                           struct PNP_RegisterDeviceClassAssociation *r)
    419419{
    420         p->rng_fault_state = true;
     420        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    421421        return WERR_NOT_SUPPORTED;
    422422}
    … …  
    428428                                             struct PNP_UnregisterDeviceClassAssociation *r)
    429429{
    430         p->rng_fault_state = true;
     430        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    431431        return WERR_NOT_SUPPORTED;
    432432}
    … …  
    438438                            struct PNP_GetClassRegProp *r)
    439439{
    440         p->rng_fault_state = true;
     440        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    441441        return WERR_NOT_SUPPORTED;
    442442}
    … …  
    448448                            struct PNP_SetClassRegProp *r)
    449449{
    450         p->rng_fault_state = true;
     450        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    451451        return WERR_NOT_SUPPORTED;
    452452}
    … …  
    458458                          struct PNP_CreateDevInst *r)
    459459{
    460         p->rng_fault_state = true;
     460        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    461461        return WERR_NOT_SUPPORTED;
    462462}
    … …  
    468468                                 struct PNP_DeviceInstanceAction *r)
    469469{
    470         p->rng_fault_state = true;
     470        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    471471        return WERR_NOT_SUPPORTED;
    472472}
    … …  
    478478                            struct PNP_GetDeviceStatus *r)
    479479{
    480         p->rng_fault_state = true;
     480        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    481481        return WERR_NOT_SUPPORTED;
    482482}
    … …  
    488488                             struct PNP_SetDeviceProblem *r)
    489489{
    490         p->rng_fault_state = true;
     490        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    491491        return WERR_NOT_SUPPORTED;
    492492}
    … …  
    498498                           struct PNP_DisableDevInst *r)
    499499{
    500         p->rng_fault_state = true;
     500        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    501501        return WERR_NOT_SUPPORTED;
    502502}
    … …  
    508508                             struct PNP_UninstallDevInst *r)
    509509{
    510         p->rng_fault_state = true;
     510        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    511511        return WERR_NOT_SUPPORTED;
    512512}
    … …  
    518518                  struct PNP_AddID *r)
    519519{
    520         p->rng_fault_state = true;
     520        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    521521        return WERR_NOT_SUPPORTED;
    522522}
    … …  
    528528                           struct PNP_RegisterDriver *r)
    529529{
    530         p->rng_fault_state = true;
     530        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    531531        return WERR_NOT_SUPPORTED;
    532532}
    … …  
    538538                        struct PNP_QueryRemove *r)
    539539{
    540         p->rng_fault_state = true;
     540        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    541541        return WERR_NOT_SUPPORTED;
    542542}
    … …  
    548548                               struct PNP_RequestDeviceEject *r)
    549549{
    550         p->rng_fault_state = true;
     550        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    551551        return WERR_NOT_SUPPORTED;
    552552}
    … …  
    558558                                 struct PNP_IsDockStationPresent *r)
    559559{
    560         p->rng_fault_state = true;
     560        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    561561        return WERR_NOT_SUPPORTED;
    562562}
    … …  
    568568                           struct PNP_RequestEjectPC *r)
    569569{
    570         p->rng_fault_state = true;
     570        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    571571        return WERR_NOT_SUPPORTED;
    572572}
    … …  
    578578                            struct PNP_AddEmptyLogConf *r)
    579579{
    580         p->rng_fault_state = true;
     580        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    581581        return WERR_NOT_SUPPORTED;
    582582}
    … …  
    588588                        struct PNP_FreeLogConf *r)
    589589{
    590         p->rng_fault_state = true;
     590        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    591591        return WERR_NOT_SUPPORTED;
    592592}
    … …  
    598598                            struct PNP_GetFirstLogConf *r)
    599599{
    600         p->rng_fault_state = true;
     600        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    601601        return WERR_NOT_SUPPORTED;
    602602}
    … …  
    608608                           struct PNP_GetNextLogConf *r)
    609609{
    610         p->rng_fault_state = true;
     610        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    611611        return WERR_NOT_SUPPORTED;
    612612}
    … …  
    618618                               struct PNP_GetLogConfPriority *r)
    619619{
    620         p->rng_fault_state = true;
     620        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    621621        return WERR_NOT_SUPPORTED;
    622622}
    … …  
    628628                      struct PNP_AddResDes *r)
    629629{
    630         p->rng_fault_state = true;
     630        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    631631        return WERR_NOT_SUPPORTED;
    632632}
    … …  
    638638                       struct PNP_FreeResDes *r)
    639639{
    640         p->rng_fault_state = true;
     640        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    641641        return WERR_NOT_SUPPORTED;
    642642}
    … …  
    648648                          struct PNP_GetNextResDes *r)
    649649{
    650         p->rng_fault_state = true;
     650        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    651651        return WERR_NOT_SUPPORTED;
    652652}
    … …  
    658658                          struct PNP_GetResDesData *r)
    659659{
    660         p->rng_fault_state = true;
     660        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    661661        return WERR_NOT_SUPPORTED;
    662662}
    … …  
    668668                              struct PNP_GetResDesDataSize *r)
    669669{
    670         p->rng_fault_state = true;
     670        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    671671        return WERR_NOT_SUPPORTED;
    672672}
    … …  
    678678                         struct PNP_ModifyResDes *r)
    679679{
    680         p->rng_fault_state = true;
     680        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    681681        return WERR_NOT_SUPPORTED;
    682682}
    … …  
    688688                                struct PNP_DetectResourceLimit *r)
    689689{
    690         p->rng_fault_state = true;
     690        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    691691        return WERR_NOT_SUPPORTED;
    692692}
    … …  
    698698                             struct PNP_QueryResConfList *r)
    699699{
    700         p->rng_fault_state = true;
     700        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    701701        return WERR_NOT_SUPPORTED;
    702702}
    … …  
    708708                      struct PNP_SetHwProf *r)
    709709{
    710         p->rng_fault_state = true;
     710        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    711711        return WERR_NOT_SUPPORTED;
    712712}
    … …  
    718718                                    struct PNP_QueryArbitratorFreeData *r)
    719719{
    720         p->rng_fault_state = true;
     720        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    721721        return WERR_NOT_SUPPORTED;
    722722}
    … …  
    728728                                    struct PNP_QueryArbitratorFreeSize *r)
    729729{
    730         p->rng_fault_state = true;
     730        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    731731        return WERR_NOT_SUPPORTED;
    732732}
    … …  
    738738                         struct PNP_RunDetection *r)
    739739{
    740         p->rng_fault_state = true;
     740        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    741741        return WERR_NOT_SUPPORTED;
    742742}
    … …  
    748748                                 struct PNP_RegisterNotification *r)
    749749{
    750         p->rng_fault_state = true;
     750        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    751751        return WERR_NOT_SUPPORTED;
    752752}
    … …  
    758758                                   struct PNP_UnregisterNotification *r)
    759759{
    760         p->rng_fault_state = true;
     760        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    761761        return WERR_NOT_SUPPORTED;
    762762}
    … …  
    768768                             struct PNP_GetCustomDevProp *r)
    769769{
    770         p->rng_fault_state = true;
     770        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    771771        return WERR_NOT_SUPPORTED;
    772772}
    … …  
    778778                               struct PNP_GetVersionInternal *r)
    779779{
    780         p->rng_fault_state = true;
     780        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    781781        return WERR_NOT_SUPPORTED;
    782782}
    … …  
    788788                                 struct PNP_GetBlockedDriverInfo *r)
    789789{
    790         p->rng_fault_state = true;
     790        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    791791        return WERR_NOT_SUPPORTED;
    792792}
    … …  
    798798                                            struct PNP_GetServerSideDeviceInstallFlags *r)
    799799{
    800         p->rng_fault_state = true;
    801         return WERR_NOT_SUPPORTED;
    802 }
     800        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     801        return WERR_NOT_SUPPORTED;
     802}

  • vendor/current/source3/rpc_server/rpc_handles.c

    r917 r919  
    243243        dump_data(4, (uint8_t *)hnd, sizeof(*hnd));
    244244
    245         p->bad_handle_fault_state = true;
     245        p->fault_state = DCERPC_FAULT_CONTEXT_MISMATCH;
    246246
    247247        return NULL;

  • vendor/current/source3/rpc_server/rpc_ncacn_np.c

    r917 r919  
    172172        p->syntax = *syntax;
    173173        p->transport = NCALRPC;
     174        p->allow_bind = true;
    174175
    175176        DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
    … …  
    217218
    218219        if (p->fault_state) {
    219                 p->fault_state = false;
     220                NTSTATUS status;
     221
     222                status = NT_STATUS(p->fault_state);
     223                p->fault_state = 0;
    220224                data_blob_free(&p->out_data.rdata);
    221225                talloc_free_children(p->mem_ctx);
    222                 return NT_STATUS_RPC_CALL_FAILED;
    223         }
    224 
    225         if (p->bad_handle_fault_state) {
    226                 p->bad_handle_fault_state = false;
    227                 data_blob_free(&p->out_data.rdata);
    228                 talloc_free_children(p->mem_ctx);
    229                 return NT_STATUS_RPC_SS_CONTEXT_MISMATCH;
    230         }
    231 
    232         if (p->rng_fault_state) {
    233                 p->rng_fault_state = false;
    234                 data_blob_free(&p->out_data.rdata);
    235                 talloc_free_children(p->mem_ctx);
    236                 return NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE;
     226                return status;
    237227        }
    238228
    … …  
    792782        result->auth->auth_type = DCERPC_AUTH_TYPE_NONE;
    793783        result->auth->auth_level = DCERPC_AUTH_LEVEL_NONE;
     784        result->auth->auth_context_id = 0;
    794785
    795786        status = rpccli_anon_bind_data(result, &auth);

  • vendor/current/source3/rpc_server/rpc_server.c

    r740 r919  
    103103        p->transport = transport;
    104104        p->ncalrpc_as_system = ncalrpc_as_system;
     105        p->allow_bind = true;
    105106
    106107        p->mem_ctx = talloc_named(p, 0, "pipe %s %p", pipe_name, p);
    … …  
    661662        if (ret == -1) {
    662663                DEBUG(2, ("Writev failed!\n"));
     664                goto fail;
     665        }
     666
     667        if (npc->p->fault_state != 0) {
     668                DEBUG(2, ("Disconnect after fault\n"));
     669                sys_errno = EINVAL;
    663670                goto fail;
    664671        }
    … …  
    13921399        }
    13931400
     1401        if (ncacn_conn->p->fault_state != 0) {
     1402                DEBUG(2, ("Disconnect after fault\n"));
     1403                sys_errno = EINVAL;
     1404                goto fail;
     1405        }
     1406
    13941407        /* clear out any data that may have been left around */
    13951408        ncacn_conn->count = 0;

  • vendor/current/source3/rpc_server/samr/srv_samr_nt.c

    r860 r919  
    66296629        struct samr_PwInfo dom_pw_info;
    66306630
     6631        if (p->auth.auth_level != DCERPC_AUTH_LEVEL_PRIVACY) {
     6632                p->fault_state = DCERPC_FAULT_ACCESS_DENIED;
     6633                return NT_STATUS_ACCESS_DENIED;
     6634        }
     6635
    66316636        if (r->in.level < 1 || r->in.level > 3) {
    66326637                return NT_STATUS_INVALID_INFO_CLASS;
    … …  
    66836688                        struct samr_Shutdown *r)
    66846689{
    6685         p->rng_fault_state = true;
     6690        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    66866691        return NT_STATUS_NOT_IMPLEMENTED;
    66876692}
    … …  
    66936698                                          struct samr_SetMemberAttributesOfGroup *r)
    66946699{
    6695         p->rng_fault_state = true;
     6700        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    66966701        return NT_STATUS_NOT_IMPLEMENTED;
    66976702}
    … …  
    67036708                                          struct samr_TestPrivateFunctionsDomain *r)
    67046709{
     6710        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67056711        return NT_STATUS_NOT_IMPLEMENTED;
    67066712}
    … …  
    67126718                                        struct samr_TestPrivateFunctionsUser *r)
    67136719{
     6720        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67146721        return NT_STATUS_NOT_IMPLEMENTED;
    67156722}
    … …  
    67216728                                         struct samr_AddMultipleMembersToAlias *r)
    67226729{
    6723         p->rng_fault_state = true;
     6730        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67246731        return NT_STATUS_NOT_IMPLEMENTED;
    67256732}
    … …  
    67316738                                              struct samr_RemoveMultipleMembersFromAlias *r)
    67326739{
    6733         p->rng_fault_state = true;
     6740        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67346741        return NT_STATUS_NOT_IMPLEMENTED;
    67356742}
    … …  
    67416748                                     struct samr_SetBootKeyInformation *r)
    67426749{
    6743         p->rng_fault_state = true;
     6750        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67446751        return NT_STATUS_NOT_IMPLEMENTED;
    67456752}
    … …  
    67516758                                     struct samr_GetBootKeyInformation *r)
    67526759{
    6753         p->rng_fault_state = true;
     6760        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67546761        return NT_STATUS_NOT_IMPLEMENTED;
    67556762}
    … …  
    67616768                               struct samr_SetDsrmPassword *r)
    67626769{
    6763         p->rng_fault_state = true;
     6770        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    67646771        return NT_STATUS_NOT_IMPLEMENTED;
    67656772}

  • vendor/current/source3/rpc_server/spoolss/srv_spoolss_nt.c

    r860 r919  
    24812481                "", /* domain */
    24822482                "", /* password */
    2483                 0, lp_client_signing());
     2483                0, False);
    24842484
    24852485        if ( !NT_STATUS_IS_OK( ret ) ) {
    … …  
    1015710157                                 struct spoolss_GetPrinterDriver *r)
    1015810158{
    10159         p->rng_fault_state = true;
     10159        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1016010160        return WERR_NOT_SUPPORTED;
    1016110161}
    … …  
    1016810168                            struct spoolss_ReadPrinter *r)
    1016910169{
    10170         p->rng_fault_state = true;
     10170        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1017110171        return WERR_NOT_SUPPORTED;
    1017210172}
    … …  
    1017910179                                     struct spoolss_WaitForPrinterChange *r)
    1018010180{
    10181         p->rng_fault_state = true;
     10181        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1018210182        return WERR_NOT_SUPPORTED;
    1018310183}
    … …  
    1019010190                              struct spoolss_ConfigurePort *r)
    1019110191{
    10192         p->rng_fault_state = true;
     10192        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1019310193        return WERR_NOT_SUPPORTED;
    1019410194}
    … …  
    1020110201                           struct spoolss_DeletePort *r)
    1020210202{
    10203         p->rng_fault_state = true;
     10203        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1020410204        return WERR_NOT_SUPPORTED;
    1020510205}
    … …  
    1021210212                                struct spoolss_CreatePrinterIC *r)
    1021310213{
    10214         p->rng_fault_state = true;
     10214        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1021510215        return WERR_NOT_SUPPORTED;
    1021610216}
    … …  
    1022310223                                         struct spoolss_PlayGDIScriptOnPrinterIC *r)
    1022410224{
    10225         p->rng_fault_state = true;
     10225        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1022610226        return WERR_NOT_SUPPORTED;
    1022710227}
    … …  
    1023410234                                struct spoolss_DeletePrinterIC *r)
    1023510235{
    10236         p->rng_fault_state = true;
     10236        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1023710237        return WERR_NOT_SUPPORTED;
    1023810238}
    … …  
    1024510245                                     struct spoolss_AddPrinterConnection *r)
    1024610246{
    10247         p->rng_fault_state = true;
     10247        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1024810248        return WERR_NOT_SUPPORTED;
    1024910249}
    … …  
    1025610256                                        struct spoolss_DeletePrinterConnection *r)
    1025710257{
    10258         p->rng_fault_state = true;
     10258        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1025910259        return WERR_NOT_SUPPORTED;
    1026010260}
    … …  
    1026710267                                  struct spoolss_PrinterMessageBox *r)
    1026810268{
    10269         p->rng_fault_state = true;
     10269        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1027010270        return WERR_NOT_SUPPORTED;
    1027110271}
    … …  
    1027810278                           struct spoolss_AddMonitor *r)
    1027910279{
    10280         p->rng_fault_state = true;
     10280        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1028110281        return WERR_NOT_SUPPORTED;
    1028210282}
    … …  
    1028910289                              struct spoolss_DeleteMonitor *r)
    1029010290{
    10291         p->rng_fault_state = true;
     10291        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1029210292        return WERR_NOT_SUPPORTED;
    1029310293}
    … …  
    1030010300                                     struct spoolss_DeletePrintProcessor *r)
    1030110301{
    10302         p->rng_fault_state = true;
     10302        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1030310303        return WERR_NOT_SUPPORTED;
    1030410304}
    … …  
    1031110311                                 struct spoolss_AddPrintProvidor *r)
    1031210312{
    10313         p->rng_fault_state = true;
     10313        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1031410314        return WERR_NOT_SUPPORTED;
    1031510315}
    … …  
    1032210322                                    struct spoolss_DeletePrintProvidor *r)
    1032310323{
    10324         p->rng_fault_state = true;
     10324        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1032510325        return WERR_NOT_SUPPORTED;
    1032610326}
    … …  
    1033310333                                                   struct spoolss_FindFirstPrinterChangeNotification *r)
    1033410334{
    10335         p->rng_fault_state = true;
     10335        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1033610336        return WERR_NOT_SUPPORTED;
    1033710337}
    … …  
    1034410344                                                  struct spoolss_FindNextPrinterChangeNotification *r)
    1034510345{
    10346         p->rng_fault_state = true;
     10346        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1034710347        return WERR_NOT_SUPPORTED;
    1034810348}
    … …  
    1035510355                                                            struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
    1035610356{
    10357         p->rng_fault_state = true;
     10357        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1035810358        return WERR_NOT_SUPPORTED;
    1035910359}
    … …  
    1036610366                                 struct spoolss_ReplyOpenPrinter *r)
    1036710367{
    10368         p->rng_fault_state = true;
     10368        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1036910369        return WERR_NOT_SUPPORTED;
    1037010370}
    … …  
    1037710377                                   struct spoolss_RouterReplyPrinter *r)
    1037810378{
    10379         p->rng_fault_state = true;
     10379        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1038010380        return WERR_NOT_SUPPORTED;
    1038110381}
    … …  
    1038810388                                  struct spoolss_ReplyClosePrinter *r)
    1038910389{
    10390         p->rng_fault_state = true;
     10390        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1039110391        return WERR_NOT_SUPPORTED;
    1039210392}
    … …  
    1039910399                          struct spoolss_AddPortEx *r)
    1040010400{
    10401         p->rng_fault_state = true;
     10401        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1040210402        return WERR_NOT_SUPPORTED;
    1040310403}
    … …  
    1041010410                                                         struct spoolss_RouterFindFirstPrinterChangeNotification *r)
    1041110411{
    10412         p->rng_fault_state = true;
     10412        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1041310413        return WERR_NOT_SUPPORTED;
    1041410414}
    … …  
    1042110421                            struct spoolss_SpoolerInit *r)
    1042210422{
    10423         p->rng_fault_state = true;
     10423        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1042410424        return WERR_NOT_SUPPORTED;
    1042510425}
    … …  
    1043210432                               struct spoolss_ResetPrinterEx *r)
    1043310433{
    10434         p->rng_fault_state = true;
     10434        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1043510435        return WERR_NOT_SUPPORTED;
    1043610436}
    … …  
    1044310443                                     struct spoolss_RouterReplyPrinterEx *r)
    1044410444{
    10445         p->rng_fault_state = true;
     10445        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1044610446        return WERR_NOT_SUPPORTED;
    1044710447}
    … …  
    1045410454                   struct spoolss_44 *r)
    1045510455{
    10456         p->rng_fault_state = true;
     10456        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1045710457        return WERR_NOT_SUPPORTED;
    1045810458}
    … …  
    1046510465                        struct spoolss_SetPort *r)
    1046610466{
    10467         p->rng_fault_state = true;
     10467        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1046810468        return WERR_NOT_SUPPORTED;
    1046910469}
    … …  
    1047610476                   struct spoolss_4a *r)
    1047710477{
    10478         p->rng_fault_state = true;
     10478        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1047910479        return WERR_NOT_SUPPORTED;
    1048010480}
    … …  
    1048710487                   struct spoolss_4b *r)
    1048810488{
    10489         p->rng_fault_state = true;
     10489        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1049010490        return WERR_NOT_SUPPORTED;
    1049110491}
    … …  
    1049810498                   struct spoolss_4c *r)
    1049910499{
    10500         p->rng_fault_state = true;
     10500        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1050110501        return WERR_NOT_SUPPORTED;
    1050210502}
    … …  
    1050910509                   struct spoolss_53 *r)
    1051010510{
    10511         p->rng_fault_state = true;
     10511        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1051210512        return WERR_NOT_SUPPORTED;
    1051310513}
    … …  
    1052010520                                        struct spoolss_AddPerMachineConnection *r)
    1052110521{
    10522         p->rng_fault_state = true;
     10522        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1052310523        return WERR_NOT_SUPPORTED;
    1052410524}
    … …  
    1053110531                                           struct spoolss_DeletePerMachineConnection *r)
    1053210532{
    10533         p->rng_fault_state = true;
     10533        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1053410534        return WERR_NOT_SUPPORTED;
    1053510535}
    … …  
    1054210542                                          struct spoolss_EnumPerMachineConnections *r)
    1054310543{
    10544         p->rng_fault_state = true;
     10544        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1054510545        return WERR_NOT_SUPPORTED;
    1054610546}
    … …  
    1055310553                   struct spoolss_5a *r)
    1055410554{
    10555         p->rng_fault_state = true;
     10555        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1055610556        return WERR_NOT_SUPPORTED;
    1055710557}
    … …  
    1056410564                   struct spoolss_5b *r)
    1056510565{
    10566         p->rng_fault_state = true;
     10566        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1056710567        return WERR_NOT_SUPPORTED;
    1056810568}
    … …  
    1057510575                   struct spoolss_5c *r)
    1057610576{
    10577         p->rng_fault_state = true;
     10577        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1057810578        return WERR_NOT_SUPPORTED;
    1057910579}
    … …  
    1058610586                   struct spoolss_5d *r)
    1058710587{
    10588         p->rng_fault_state = true;
     10588        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1058910589        return WERR_NOT_SUPPORTED;
    1059010590}
    … …  
    1059710597                   struct spoolss_5e *r)
    1059810598{
    10599         p->rng_fault_state = true;
     10599        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1060010600        return WERR_NOT_SUPPORTED;
    1060110601}
    … …  
    1060810608                   struct spoolss_5f *r)
    1060910609{
    10610         p->rng_fault_state = true;
     10610        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1061110611        return WERR_NOT_SUPPORTED;
    1061210612}
    … …  
    1061910619                   struct spoolss_60 *r)
    1062010620{
    10621         p->rng_fault_state = true;
     10621        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1062210622        return WERR_NOT_SUPPORTED;
    1062310623}
    … …  
    1063010630                   struct spoolss_61 *r)
    1063110631{
    10632         p->rng_fault_state = true;
     10632        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1063310633        return WERR_NOT_SUPPORTED;
    1063410634}
    … …  
    1064110641                   struct spoolss_62 *r)
    1064210642{
    10643         p->rng_fault_state = true;
     10643        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1064410644        return WERR_NOT_SUPPORTED;
    1064510645}
    … …  
    1065210652                   struct spoolss_63 *r)
    1065310653{
    10654         p->rng_fault_state = true;
     10654        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1065510655        return WERR_NOT_SUPPORTED;
    1065610656}
    … …  
    1066310663                   struct spoolss_64 *r)
    1066410664{
    10665         p->rng_fault_state = true;
     10665        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1066610666        return WERR_NOT_SUPPORTED;
    1066710667}
    … …  
    1067410674                   struct spoolss_65 *r)
    1067510675{
    10676         p->rng_fault_state = true;
     10676        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1067710677        return WERR_NOT_SUPPORTED;
    1067810678}
    … …  
    1068510685                                      struct spoolss_GetCorePrinterDrivers *r)
    1068610686{
    10687         p->rng_fault_state = true;
     10687        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1068810688        return WERR_NOT_SUPPORTED;
    1068910689}
    … …  
    1069610696                   struct spoolss_67 *r)
    1069710697{
    10698         p->rng_fault_state = true;
     10698        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1069910699        return WERR_NOT_SUPPORTED;
    1070010700}
    … …  
    1070710707                                            struct spoolss_GetPrinterDriverPackagePath *r)
    1070810708{
    10709         p->rng_fault_state = true;
     10709        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1071010710        return WERR_NOT_SUPPORTED;
    1071110711}
    … …  
    1071810718                   struct spoolss_69 *r)
    1071910719{
    10720         p->rng_fault_state = true;
     10720        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1072110721        return WERR_NOT_SUPPORTED;
    1072210722}
    … …  
    1072910729                   struct spoolss_6a *r)
    1073010730{
    10731         p->rng_fault_state = true;
     10731        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1073210732        return WERR_NOT_SUPPORTED;
    1073310733}
    … …  
    1074010740                   struct spoolss_6b *r)
    1074110741{
    10742         p->rng_fault_state = true;
     10742        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1074310743        return WERR_NOT_SUPPORTED;
    1074410744}
    … …  
    1075110751                   struct spoolss_6c *r)
    1075210752{
    10753         p->rng_fault_state = true;
     10753        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1075410754        return WERR_NOT_SUPPORTED;
    1075510755}
    … …  
    1076210762                   struct spoolss_6d *r)
    1076310763{
    10764         p->rng_fault_state = true;
     10764        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    1076510765        return WERR_NOT_SUPPORTED;
    1076610766}

  • vendor/current/source3/rpc_server/srv_pipe.c

    r917 r919  
    4343#include "ntdomain.h"
    4444#include "rpc_server/srv_pipe.h"
     45#include "../librpc/gen_ndr/ndr_dcerpc.h"
     46#include "../librpc/ndr/ndr_dcerpc.h"
     47#include "../librpc/gen_ndr/ndr_samr.h"
     48#include "../librpc/gen_ndr/ndr_lsa.h"
     49#include "../librpc/gen_ndr/ndr_netlogon.h"
     50#include "../librpc/gen_ndr/ndr_epmapper.h"
     51#include "../librpc/gen_ndr/ndr_echo.h"
    4552
    4653#undef DBGC_CLASS
    … …  
    203210         */
    204211        if (p->fault_state) {
    205                 setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
     212                setup_fault_pdu(p, NT_STATUS(p->fault_state));
    206213                return true;
    207214        }
    … …  
    270277        p->out_data.current_pdu_sent = 0;
    271278
     279        set_incoming_fault(p);
    272280        TALLOC_FREE(p->auth.auth_ctx);
    273281        p->auth.auth_level = DCERPC_AUTH_LEVEL_NONE;
    274282        p->auth.auth_type = DCERPC_AUTH_TYPE_NONE;
    275283        p->pipe_bound = False;
     284        p->allow_bind = false;
     285        p->allow_alter = false;
     286        p->allow_auth3 = false;
    276287
    277288        return True;
    … …  
    335346{
    336347        struct pipe_rpc_fns *context_fns;
     348        const char *interface_name = NULL;
     349        bool ok;
    337350
    338351        DEBUG(3,("check_bind_req for %s\n",
    339                  get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     352                 get_pipe_name_from_syntax(talloc_tos(), abstract)));
     353
     354        ok = ndr_syntax_id_equal(transfer, &ndr_transfer_syntax);
     355        if (!ok) {
     356                DEBUG(1,("check_bind_req unknown transfer syntax for "
     357                         "%s context_id=%u\n",
     358                         get_pipe_name_from_syntax(talloc_tos(), abstract),
     359                         (unsigned)context_id));
     360                return false;
     361        }
     362
     363        for (context_fns = p->contexts;
     364             context_fns != NULL;
     365             context_fns = context_fns->next)
     366        {
     367                if (context_fns->context_id != context_id) {
     368                        continue;
     369                }
     370
     371                ok = ndr_syntax_id_equal(&context_fns->syntax,
     372                                         abstract);
     373                if (ok) {
     374                        return true;
     375                }
     376
     377                DEBUG(1,("check_bind_req: changing abstract syntax for "
     378                         "%s context_id=%u into %s not supported\n",
     379                         get_pipe_name_from_syntax(talloc_tos(), &context_fns->syntax),
     380                         (unsigned)context_id,
     381                         get_pipe_name_from_syntax(talloc_tos(), abstract)));
     382                return false;
     383        }
    340384
    341385        /* we have to check all now since win2k introduced a new UUID on the lsaprpc pipe */
    342         if (rpc_srv_pipe_exists_by_id(abstract) &&
    343            ndr_syntax_id_equal(transfer, &ndr_transfer_syntax)) {
    344                 DEBUG(3, ("check_bind_req: \\PIPE\\%s -> \\PIPE\\%s\n",
    345                         rpc_srv_get_pipe_cli_name(abstract),
    346                         rpc_srv_get_pipe_srv_name(abstract)));
    347         } else {
     386        if (!rpc_srv_pipe_exists_by_id(abstract)) {
    348387                return false;
    349388        }
     389
     390        DEBUG(3, ("check_bind_req: %s -> %s rpc service\n",
     391                  rpc_srv_get_pipe_cli_name(abstract),
     392                  rpc_srv_get_pipe_srv_name(abstract)));
    350393
    351394        context_fns = SMB_MALLOC_P(struct pipe_rpc_fns);
    … …  
    355398        }
    356399
     400        interface_name = get_pipe_name_from_syntax(talloc_tos(),
     401                                                   abstract);
     402
     403        SMB_ASSERT(interface_name != NULL);
     404
    357405        context_fns->next = context_fns->prev = NULL;
    358406        context_fns->n_cmds = rpc_srv_get_pipe_num_cmds(abstract);
    359407        context_fns->cmds = rpc_srv_get_pipe_cmds(abstract);
    360408        context_fns->context_id = context_id;
     409        context_fns->syntax = *abstract;
     410
     411        context_fns->allow_connect = lp_allow_dcerpc_auth_level_connect();
     412        /*
     413         * for the samr and the lsarpc interfaces we don't allow "connect"
     414         * auth_level by default.
     415         */
     416        ok = ndr_syntax_id_equal(abstract, &ndr_table_samr.syntax_id);
     417        if (ok) {
     418                context_fns->allow_connect = false;
     419        }
     420        ok = ndr_syntax_id_equal(abstract, &ndr_table_lsarpc.syntax_id);
     421        if (ok) {
     422                context_fns->allow_connect = false;
     423        }
     424        ok = ndr_syntax_id_equal(abstract, &ndr_table_netlogon.syntax_id);
     425        if (ok) {
     426                context_fns->allow_connect = false;
     427        }
     428        /*
     429         * for the epmapper and echo interfaces we allow "connect"
     430         * auth_level by default.
     431         */
     432        ok = ndr_syntax_id_equal(abstract, &ndr_table_epmapper.syntax_id);
     433        if (ok) {
     434                context_fns->allow_connect = true;
     435        }
     436        ok = ndr_syntax_id_equal(abstract, &ndr_table_rpcecho.syntax_id);
     437        if (ok) {
     438                context_fns->allow_connect = true;
     439        }
     440        /*
     441         * every interface can be modified to allow "connect" auth_level by
     442         * using a parametric option like:
     443         * allow dcerpc auth level connect:<interface>
     444         * e.g.
     445         * allow dcerpc auth level connect:samr = yes
     446         */
     447        context_fns->allow_connect = lp_parm_bool(-1,
     448                "allow dcerpc auth level connect",
     449                interface_name, context_fns->allow_connect);
    361450
    362451        /* add to the list of open contexts */
    … …  
    446535        p->auth.auth_ctx = spnego_ctx;
    447536        p->auth.auth_type = DCERPC_AUTH_TYPE_SPNEGO;
     537        p->auth.auth_context_id = auth_info->auth_context_id;
    448538
    449539        DEBUG(10, ("SPNEGO auth started\n"));
    … …  
    556646        p->auth.auth_ctx = schannel_auth;
    557647        p->auth.auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
     648        p->auth.auth_context_id = auth_info->auth_context_id;
    558649
    559650        p->pipe_bound = True;
    … …  
    600691        p->auth.auth_ctx = ntlmssp_state;
    601692        p->auth.auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
     693        p->auth.auth_context_id = auth_info->auth_context_id;
    602694
    603695        DEBUG(10, (__location__ ": NTLMSSP auth started\n"));
    … …  
    774866        void *mech_ctx;
    775867        NTSTATUS status;
     868
     869        if (p->auth.auth_type == DCERPC_AUTH_TYPE_NONE) {
     870                p->pipe_bound = true;
     871                return NT_STATUS_OK;
     872        }
    776873
    777874        switch (p->auth.auth_type) {
    … …  
    866963        DATA_BLOB auth_blob = data_blob_null;
    867964
    868         /* No rebinds on a bound pipe - use alter context. */
    869         if (p->pipe_bound) {
    870                 DEBUG(2,("api_pipe_bind_req: rejecting bind request on bound "
    871                          "pipe %s.\n",
    872                          get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     965        if (!p->allow_bind) {
     966                DEBUG(2,("Pipe not in allow bind state\n"));
    873967                return setup_bind_nak(p, pkt);
    874968        }
     969        p->allow_bind = false;
     970
     971        status = dcerpc_verify_ncacn_packet_header(pkt,
     972                        DCERPC_PKT_BIND,
     973                        pkt->u.bind.auth_info.length,
     974                        0, /* required flags */
     975                        DCERPC_PFC_FLAG_FIRST |
     976                        DCERPC_PFC_FLAG_LAST |
     977                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
     978                        0x08 | /* this is not defined, but should be ignored */
     979                        DCERPC_PFC_FLAG_CONC_MPX |
     980                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
     981                        DCERPC_PFC_FLAG_MAYBE |
     982                        DCERPC_PFC_FLAG_OBJECT_UUID);
     983        if (!NT_STATUS_IS_OK(status)) {
     984                DEBUG(1, ("api_pipe_bind_req: invalid pdu: %s\n",
     985                          nt_errstr(status)));
     986                NDR_PRINT_DEBUG(ncacn_packet, pkt);
     987                goto err_exit;
     988        }
    875989
    876990        if (pkt->u.bind.num_contexts == 0) {
    877                 DEBUG(0, ("api_pipe_bind_req: no rpc contexts around\n"));
     991                DEBUG(1, ("api_pipe_bind_req: no rpc contexts around\n"));
     992                goto err_exit;
     993        }
     994
     995        if (pkt->u.bind.ctx_list[0].num_transfer_syntaxes == 0) {
     996                DEBUG(1, ("api_pipe_bind_req: no transfer syntaxes around\n"));
    878997                goto err_exit;
    879998        }
    … …  
    9591078         */
    9601079        if (pkt->auth_length) {
    961                 /* Quick length check. Won't catch a bad auth footer,
    962                  * prevents overrun. */
    963 
    964                 if (pkt->frag_length < RPC_HEADER_LEN +
    965                                         DCERPC_AUTH_TRAILER_LENGTH +
    966                                         pkt->auth_length) {
    967                         DEBUG(0,("api_pipe_bind_req: auth_len (%u) "
    968                                 "too long for fragment %u.\n",
    969                                 (unsigned int)pkt->auth_length,
    970                                 (unsigned int)pkt->frag_length));
    971                         goto err_exit;
    972                 }
    973 
    9741080                /*
    9751081                 * Decode the authentication verifier.
    9761082                 */
    977                 status = dcerpc_pull_dcerpc_auth(pkt,
    978                                                  &pkt->u.bind.auth_info,
    979                                                  &auth_info, p->endian);
     1083                status = dcerpc_pull_auth_trailer(pkt, pkt,
     1084                                                  &pkt->u.bind.auth_info,
     1085                                                  &auth_info, NULL, true);
    9801086                if (!NT_STATUS_IS_OK(status)) {
    9811087                        DEBUG(0, ("Unable to unmarshall dcerpc_auth.\n"));
    … …  
    10711177                /* The session key was initialized from the SMB
    10721178                 * session in make_internal_rpc_pipe_p */
     1179                p->auth.auth_context_id = 0;
    10731180        }
    10741181
    … …  
    11121219                DEBUG(0, ("Failed to marshall bind_ack packet. (%s)\n",
    11131220                          nt_errstr(status)));
     1221                goto err_exit;
    11141222        }
    11151223
    11161224        if (auth_resp.length) {
    1117 
    11181225                status = dcerpc_push_dcerpc_auth(pkt,
    11191226                                                 auth_type,
    11201227                                                 auth_info.auth_level,
    1121                                                  0,
    1122                                                  1, /* auth_context_id */
     1228                                                 0, /* pad_len */
     1229                                                 p->auth.auth_context_id,
    11231230                                                 &auth_resp,
    11241231                                                 &auth_blob);
    … …  
    11511258
    11521259        TALLOC_FREE(auth_blob.data);
     1260
     1261        if (bind_ack_ctx.result == 0) {
     1262                p->allow_alter = true;
     1263                p->allow_auth3 = true;
     1264                if (p->auth.auth_type == DCERPC_AUTH_TYPE_NONE) {
     1265                        status = pipe_auth_verify_final(p);
     1266                        if (!NT_STATUS_IS_OK(status)) {
     1267                                DEBUG(0, ("pipe_auth_verify_final failed: %s\n",
     1268                                          nt_errstr(status)));
     1269                                goto err_exit;
     1270                        }
     1271                }
     1272        } else {
     1273                goto err_exit;
     1274        }
     1275
    11531276        return True;
    11541277
    … …  
    11751298        DEBUG(5, ("api_pipe_bind_auth3: decode request. %d\n", __LINE__));
    11761299
     1300        if (!p->allow_auth3) {
     1301                DEBUG(1, ("Pipe not in allow auth3 state.\n"));
     1302                goto err;
     1303        }
     1304
     1305        status = dcerpc_verify_ncacn_packet_header(pkt,
     1306                        DCERPC_PKT_AUTH3,
     1307                        pkt->u.auth3.auth_info.length,
     1308                        0, /* required flags */
     1309                        DCERPC_PFC_FLAG_FIRST |
     1310                        DCERPC_PFC_FLAG_LAST |
     1311                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
     1312                        0x08 | /* this is not defined, but should be ignored */
     1313                        DCERPC_PFC_FLAG_CONC_MPX |
     1314                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
     1315                        DCERPC_PFC_FLAG_MAYBE |
     1316                        DCERPC_PFC_FLAG_OBJECT_UUID);
     1317        if (!NT_STATUS_IS_OK(status)) {
     1318                DEBUG(1, ("api_pipe_bind_auth3: invalid pdu: %s\n",
     1319                          nt_errstr(status)));
     1320                NDR_PRINT_DEBUG(ncacn_packet, pkt);
     1321                goto err;
     1322        }
     1323
     1324        /* We can only finish if the pipe is unbound for now */
     1325        if (p->pipe_bound) {
     1326                DEBUG(0, (__location__ ": Pipe already bound, "
     1327                          "AUTH3 not supported!\n"));
     1328                goto err;
     1329        }
     1330
    11771331        if (pkt->auth_length == 0) {
    1178                 DEBUG(0, ("No auth field sent for bind request!\n"));
     1332                DEBUG(1, ("No auth field sent for auth3 request!\n"));
    11791333                goto err;
    11801334        }
    11811335
    1182         /* Ensure there's enough data for an authenticated request. */
    1183         if (pkt->frag_length < RPC_HEADER_LEN
    1184                                 + DCERPC_AUTH_TRAILER_LENGTH
    1185                                 + pkt->auth_length) {
    1186                         DEBUG(0,("api_pipe_ntlmssp_auth_process: auth_len "
    1187                                 "%u is too large.\n",
    1188                         (unsigned int)pkt->auth_length));
    1189                 goto err;
    1190         }
    1191 
    11921336        /*
    11931337         * Decode the authentication verifier response.
    11941338         */
    11951339
    1196         status = dcerpc_pull_dcerpc_auth(pkt,
    1197                                          &pkt->u.auth3.auth_info,
    1198                                          &auth_info, p->endian);
     1340        status = dcerpc_pull_auth_trailer(pkt, pkt,
     1341                                          &pkt->u.auth3.auth_info,
     1342                                          &auth_info, NULL, true);
    11991343        if (!NT_STATUS_IS_OK(status)) {
    12001344                DEBUG(0, ("Failed to unmarshall dcerpc_auth.\n"));
    … …  
    12111355                          "but auth was started as type %d!\n",
    12121356                          auth_info.auth_type, p->auth.auth_type));
     1357                goto err;
     1358        }
     1359
     1360        if (auth_info.auth_level != p->auth.auth_level) {
     1361                DEBUG(1, ("Auth level mismatch! Client sent %d, "
     1362                          "but auth was started as level %d!\n",
     1363                          auth_info.auth_level, p->auth.auth_level));
     1364                goto err;
     1365        }
     1366
     1367        if (auth_info.auth_context_id != p->auth.auth_context_id) {
     1368                DEBUG(0, ("Auth context id mismatch! Client sent %u, "
     1369                          "but auth was started as level %u!\n",
     1370                          (unsigned)auth_info.auth_context_id,
     1371                          (unsigned)p->auth.auth_context_id));
    12131372                goto err;
    12141373        }
    … …  
    12661425
    12671426err:
     1427        p->pipe_bound = false;
     1428        p->allow_bind = false;
     1429        p->allow_alter = false;
     1430        p->allow_auth3 = false;
    12681431
    12691432        TALLOC_FREE(p->auth.auth_ctx);
    … …  
    12831446        NTSTATUS status;
    12841447        union dcerpc_payload u;
    1285         struct dcerpc_ack_ctx bind_ack_ctx;
     1448        struct dcerpc_ack_ctx alter_ack_ctx;
    12861449        DATA_BLOB auth_resp = data_blob_null;
    12871450        DATA_BLOB auth_blob = data_blob_null;
    … …  
    12931456        DEBUG(5,("api_pipe_alter_context: make response. %d\n", __LINE__));
    12941457
    1295         if (pkt->u.bind.assoc_group_id != 0) {
    1296                 assoc_gid = pkt->u.bind.assoc_group_id;
     1458        if (!p->allow_alter) {
     1459                DEBUG(1, ("Pipe not in allow alter state.\n"));
     1460                goto err_exit;
     1461        }
     1462
     1463        status = dcerpc_verify_ncacn_packet_header(pkt,
     1464                        DCERPC_PKT_ALTER,
     1465                        pkt->u.alter.auth_info.length,
     1466                        0, /* required flags */
     1467                        DCERPC_PFC_FLAG_FIRST |
     1468                        DCERPC_PFC_FLAG_LAST |
     1469                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
     1470                        0x08 | /* this is not defined, but should be ignored */
     1471                        DCERPC_PFC_FLAG_CONC_MPX |
     1472                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
     1473                        DCERPC_PFC_FLAG_MAYBE |
     1474                        DCERPC_PFC_FLAG_OBJECT_UUID);
     1475        if (!NT_STATUS_IS_OK(status)) {
     1476                DEBUG(1, ("api_pipe_alter_context: invalid pdu: %s\n",
     1477                          nt_errstr(status)));
     1478                NDR_PRINT_DEBUG(ncacn_packet, pkt);
     1479                goto err_exit;
     1480        }
     1481
     1482        if (pkt->u.alter.num_contexts == 0) {
     1483                DEBUG(1, ("api_pipe_alter_context: no rpc contexts around\n"));
     1484                goto err_exit;
     1485        }
     1486
     1487        if (pkt->u.alter.ctx_list[0].num_transfer_syntaxes == 0) {
     1488                DEBUG(1, ("api_pipe_alter_context: no transfer syntaxes around\n"));
     1489                goto err_exit;
     1490        }
     1491
     1492        if (pkt->u.alter.assoc_group_id != 0) {
     1493                assoc_gid = pkt->u.alter.assoc_group_id;
    12971494        } else {
    12981495                assoc_gid = 0x53f0;
    … …  
    13041501
    13051502        /* If the requested abstract synt uuid doesn't match our client pipe,
    1306                 reject the bind_ack & set the transfer interface synt to all 0's,
     1503                reject the alter_ack & set the transfer interface synt to all 0's,
    13071504                ver 0 (observed when NT5 attempts to bind to abstract interfaces
    13081505                unknown to NT4)
    … …  
    13101507
    13111508        if (check_bind_req(p,
    1312                         &pkt->u.bind.ctx_list[0].abstract_syntax,
    1313                         &pkt->u.bind.ctx_list[0].transfer_syntaxes[0],
    1314                         pkt->u.bind.ctx_list[0].context_id)) {
    1315 
    1316                 bind_ack_ctx.result = 0;
    1317                 bind_ack_ctx.reason = 0;
    1318                 bind_ack_ctx.syntax = pkt->u.bind.ctx_list[0].transfer_syntaxes[0];
     1509                        &pkt->u.alter.ctx_list[0].abstract_syntax,
     1510                        &pkt->u.alter.ctx_list[0].transfer_syntaxes[0],
     1511                        pkt->u.alter.ctx_list[0].context_id)) {
     1512
     1513                alter_ack_ctx.result = 0;
     1514                alter_ack_ctx.reason = 0;
     1515                alter_ack_ctx.syntax = pkt->u.alter.ctx_list[0].transfer_syntaxes[0];
    13191516        } else {
    1320                 p->pipe_bound = False;
    13211517                /* Rejection reason: abstract syntax not supported */
    1322                 bind_ack_ctx.result = DCERPC_BIND_PROVIDER_REJECT;
    1323                 bind_ack_ctx.reason = DCERPC_BIND_REASON_ASYNTAX;
    1324                 bind_ack_ctx.syntax = null_ndr_syntax_id;
     1518                alter_ack_ctx.result = DCERPC_BIND_PROVIDER_REJECT;
     1519                alter_ack_ctx.reason = DCERPC_BIND_REASON_ASYNTAX;
     1520                alter_ack_ctx.syntax = null_ndr_syntax_id;
    13251521        }
    13261522
    … …  
    13291525         */
    13301526        if (pkt->auth_length) {
    1331                 /* Quick length check. Won't catch a bad auth footer,
    1332                  * prevents overrun. */
    1333 
    1334                 if (pkt->frag_length < RPC_HEADER_LEN +
    1335                                         DCERPC_AUTH_TRAILER_LENGTH +
    1336                                         pkt->auth_length) {
    1337                         DEBUG(0,("api_pipe_alter_context: auth_len (%u) "
    1338                                 "too long for fragment %u.\n",
    1339                                 (unsigned int)pkt->auth_length,
    1340                                 (unsigned int)pkt->frag_length ));
    1341                         goto err_exit;
    1342                 }
    1343 
    1344                 status = dcerpc_pull_dcerpc_auth(pkt,
    1345                                                  &pkt->u.bind.auth_info,
    1346                                                  &auth_info, p->endian);
    1347                 if (!NT_STATUS_IS_OK(status)) {
    1348                         DEBUG(0, ("Unable to unmarshall dcerpc_auth.\n"));
    1349                         goto err_exit;
    1350                 }
    1351 
    13521527                /* We can only finish if the pipe is unbound for now */
    13531528                if (p->pipe_bound) {
    … …  
    13571532                }
    13581533
     1534                status = dcerpc_pull_auth_trailer(pkt, pkt,
     1535                                                  &pkt->u.alter.auth_info,
     1536                                                  &auth_info, NULL, true);
     1537                if (!NT_STATUS_IS_OK(status)) {
     1538                        DEBUG(0, ("Unable to unmarshall dcerpc_auth.\n"));
     1539                        goto err_exit;
     1540                }
     1541
    13591542                if (auth_info.auth_type != p->auth.auth_type) {
    13601543                        DEBUG(0, ("Auth type mismatch! Client sent %d, "
    … …  
    13641547                }
    13651548
     1549                if (auth_info.auth_level != p->auth.auth_level) {
     1550                        DEBUG(0, ("Auth level mismatch! Client sent %d, "
     1551                                  "but auth was started as level %d!\n",
     1552                                  auth_info.auth_level, p->auth.auth_level));
     1553                        goto err_exit;
     1554                }
     1555
     1556                if (auth_info.auth_context_id != p->auth.auth_context_id) {
     1557                        DEBUG(0, ("Auth context id mismatch! Client sent %u, "
     1558                                  "but auth was started as level %u!\n",
     1559                                  (unsigned)auth_info.auth_context_id,
     1560                                  (unsigned)p->auth.auth_context_id));
     1561                        goto err_exit;
     1562                }
    13661563
    13671564                switch (auth_info.auth_type) {
    … …  
    14301627
    14311628        u.alter_resp.num_results = 1;
    1432         u.alter_resp.ctx_list = &bind_ack_ctx;
     1629        u.alter_resp.ctx_list = &alter_ack_ctx;
    14331630
    14341631        /* NOTE: We leave the auth_info empty so we can calculate the padding
    … …  
    14501647                                          &p->out_data.frag);
    14511648        if (!NT_STATUS_IS_OK(status)) {
    1452                 DEBUG(0, ("Failed to marshall bind_ack packet. (%s)\n",
     1649                DEBUG(0, ("Failed to marshall alter_resp packet. (%s)\n",
    14531650                          nt_errstr(status)));
     1651                goto err_exit;
    14541652        }
    14551653
    … …  
    14681666                                                 auth_info.auth_level,
    14691667                                                 pad_len,
    1470                                                  1, /* auth_context_id */
     1668                                                 p->auth.auth_context_id,
    14711669                                                 &auth_resp,
    14721670                                                 &auth_blob);
    … …  
    15421740
    15431741static bool api_rpcTNP(struct pipes_struct *p, struct ncacn_packet *pkt,
    1544                        const struct api_struct *api_rpc_cmds, int n_cmds);
     1742                       const struct api_struct *api_rpc_cmds, int n_cmds,
     1743                       const struct ndr_syntax_id *syntax);
     1744
     1745static bool srv_pipe_check_verification_trailer(struct pipes_struct *p,
     1746                                                struct ncacn_packet *pkt,
     1747                                                struct pipe_rpc_fns *pipe_fns)
     1748{
     1749        TALLOC_CTX *frame = talloc_stackframe();
     1750        struct dcerpc_sec_verification_trailer *vt = NULL;
     1751        const uint32_t bitmask1 = 0;
     1752        const struct dcerpc_sec_vt_pcontext pcontext = {
     1753                .abstract_syntax = pipe_fns->syntax,
     1754                .transfer_syntax = ndr_transfer_syntax,
     1755        };
     1756        const struct dcerpc_sec_vt_header2 header2 =
     1757               dcerpc_sec_vt_header2_from_ncacn_packet(pkt);
     1758        struct ndr_pull *ndr;
     1759        enum ndr_err_code ndr_err;
     1760        bool ret = false;
     1761
     1762        ndr = ndr_pull_init_blob(&p->in_data.data, frame);
     1763        if (ndr == NULL) {
     1764                goto done;
     1765        }
     1766
     1767        ndr_err = ndr_pop_dcerpc_sec_verification_trailer(ndr, frame, &vt);
     1768        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
     1769                goto done;
     1770        }
     1771
     1772        ret = dcerpc_sec_verification_trailer_check(vt, &bitmask1,
     1773                                                    &pcontext, &header2);
     1774done:
     1775        TALLOC_FREE(frame);
     1776        return ret;
     1777}
    15451778
    15461779/****************************************************************************
    … …  
    15531786                                struct ncacn_packet *pkt)
    15541787{
     1788        TALLOC_CTX *frame = talloc_stackframe();
    15551789        bool ret = False;
    1556         bool changed_user = False;
    15571790        PIPE_RPC_FNS *pipe_fns;
    1558 
    1559         if (p->pipe_bound &&
    1560             ((p->auth.auth_type == DCERPC_AUTH_TYPE_NTLMSSP) ||
    1561              (p->auth.auth_type == DCERPC_AUTH_TYPE_KRB5) ||
    1562              (p->auth.auth_type == DCERPC_AUTH_TYPE_SPNEGO))) {
    1563                 if(!become_authenticated_pipe_user(p->session_info)) {
    1564                         data_blob_free(&p->out_data.rdata);
    1565                         return False;
    1566                 }
    1567                 changed_user = True;
    1568         }
    1569 
    1570         DEBUG(5, ("Requested \\PIPE\\%s\n",
    1571                   get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     1791        const char *interface_name = NULL;
     1792
     1793        if (!p->pipe_bound) {
     1794                DEBUG(1, ("Pipe not bound!\n"));
     1795                data_blob_free(&p->out_data.rdata);
     1796                TALLOC_FREE(frame);
     1797                return false;
     1798        }
    15721799
    15731800        /* get the set of RPC functions for this context */
    … …  
    15751802        pipe_fns = find_pipe_fns_by_context(p->contexts,
    15761803                                            pkt->u.request.context_id);
    1577 
    1578         if ( pipe_fns ) {
    1579                 TALLOC_CTX *frame = talloc_stackframe();
    1580                 ret = api_rpcTNP(p, pkt, pipe_fns->cmds, pipe_fns->n_cmds);
     1804        if (pipe_fns == NULL) {
     1805                DEBUG(0, ("No rpc function table associated with context "
     1806                          "[%d]\n",
     1807                          pkt->u.request.context_id));
     1808                data_blob_free(&p->out_data.rdata);
    15811809                TALLOC_FREE(frame);
    1582         }
    1583         else {
    1584                 DEBUG(0, ("No rpc function table associated with context "
    1585                           "[%d] on pipe [%s]\n",
    1586                           pkt->u.request.context_id,
    1587                           get_pipe_name_from_syntax(talloc_tos(),
    1588                                                     &p->syntax)));
    1589         }
    1590 
    1591         if (changed_user) {
    1592                 unbecome_authenticated_pipe_user();
    1593         }
    1594 
     1810                return false;
     1811        }
     1812
     1813        interface_name = get_pipe_name_from_syntax(talloc_tos(),
     1814                                                   &pipe_fns->syntax);
     1815
     1816        SMB_ASSERT(interface_name != NULL);
     1817
     1818        DEBUG(5, ("Requested \\PIPE\\%s\n",
     1819                  interface_name));
     1820
     1821        switch (p->auth.auth_level) {
     1822        case DCERPC_AUTH_LEVEL_NONE:
     1823        case DCERPC_AUTH_LEVEL_INTEGRITY:
     1824        case DCERPC_AUTH_LEVEL_PRIVACY:
     1825                break;
     1826        default:
     1827                if (!pipe_fns->allow_connect) {
     1828                        DEBUG(1, ("%s: restrict auth_level_connect access "
     1829                                  "to [%s] with auth[type=0x%x,level=0x%x] "
     1830                                  "on [%s] from [%s]\n",
     1831                                  __func__, interface_name,
     1832                                  p->auth.auth_type,
     1833                                  p->auth.auth_level,
     1834                                  derpc_transport_string_by_transport(p->transport),
     1835                                  p->client_id->name));
     1836
     1837                        setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_ACCESS_DENIED));
     1838                        TALLOC_FREE(frame);
     1839                        return true;
     1840                }
     1841                break;
     1842        }
     1843
     1844        if (!srv_pipe_check_verification_trailer(p, pkt, pipe_fns)) {
     1845                DEBUG(1, ("srv_pipe_check_verification_trailer: failed\n"));
     1846                set_incoming_fault(p);
     1847                setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_ACCESS_DENIED));
     1848                data_blob_free(&p->out_data.rdata);
     1849                TALLOC_FREE(frame);
     1850                return true;
     1851        }
     1852
     1853        if (!become_authenticated_pipe_user(p->session_info)) {
     1854                DEBUG(1, ("Failed to become pipe user!\n"));
     1855                data_blob_free(&p->out_data.rdata);
     1856                TALLOC_FREE(frame);
     1857                return false;
     1858        }
     1859
     1860        ret = api_rpcTNP(p, pkt, pipe_fns->cmds, pipe_fns->n_cmds,
     1861                         &pipe_fns->syntax);
     1862        unbecome_authenticated_pipe_user();
     1863
     1864        TALLOC_FREE(frame);
    15951865        return ret;
    15961866}
    … …  
    16011871
    16021872static bool api_rpcTNP(struct pipes_struct *p, struct ncacn_packet *pkt,
    1603                        const struct api_struct *api_rpc_cmds, int n_cmds)
     1873                       const struct api_struct *api_rpc_cmds, int n_cmds,
     1874                       const struct ndr_syntax_id *syntax)
    16041875{
    16051876        int fn_num;
    … …  
    16081879        /* interpret the command */
    16091880        DEBUG(4,("api_rpcTNP: %s op 0x%x - ",
    1610                  get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
     1881                 get_pipe_name_from_syntax(talloc_tos(), syntax),
    16111882                 pkt->u.request.opnum));
    16121883
    … …  
    16141885                fstring name;
    16151886                slprintf(name, sizeof(name)-1, "in_%s",
    1616                          get_pipe_name_from_syntax(talloc_tos(), &p->syntax));
     1887                         get_pipe_name_from_syntax(talloc_tos(), syntax));
    16171888                dump_pdu_region(name, pkt->u.request.opnum,
    16181889                                &p->in_data.data, 0,
    … …  
    16471918        if(!api_rpc_cmds[fn_num].fn(p)) {
    16481919                DEBUG(0,("api_rpcTNP: %s: %s failed.\n",
    1649                          get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
     1920                         get_pipe_name_from_syntax(talloc_tos(), syntax),
    16501921                         api_rpc_cmds[fn_num].name));
    16511922                data_blob_free(&p->out_data.rdata);
    … …  
    16531924        }
    16541925
    1655         if (p->bad_handle_fault_state) {
    1656                 DEBUG(4,("api_rpcTNP: bad handle fault return.\n"));
    1657                 p->bad_handle_fault_state = False;
    1658                 setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_CONTEXT_MISMATCH));
    1659                 return True;
    1660         }
    1661 
    1662         if (p->rng_fault_state) {
    1663                 DEBUG(4, ("api_rpcTNP: rng fault return\n"));
    1664                 p->rng_fault_state = False;
    1665                 setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
    1666                 return True;
     1926        if (p->fault_state) {
     1927                DEBUG(4,("api_rpcTNP: fault(%d) return.\n", p->fault_state));
     1928                setup_fault_pdu(p, NT_STATUS(p->fault_state));
     1929                p->fault_state = 0;
     1930                return true;
    16671931        }
    16681932
    … …  
    16701934                fstring name;
    16711935                slprintf(name, sizeof(name)-1, "out_%s",
    1672                          get_pipe_name_from_syntax(talloc_tos(), &p->syntax));
     1936                         get_pipe_name_from_syntax(talloc_tos(), syntax));
    16731937                dump_pdu_region(name, pkt->u.request.opnum,
    16741938                                &p->out_data.rdata, offset1,
    … …  
    16771941
    16781942        DEBUG(5,("api_rpcTNP: called %s successfully\n",
    1679                  get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     1943                 get_pipe_name_from_syntax(talloc_tos(), syntax)));
    16801944
    16811945        /* Check for buffer underflow in rpc parsing */
    … …  
    17191983        p->in_data.pdu_needed_len = 0;
    17201984        p->in_data.pdu.length = 0;
    1721         p->fault_state = True;
    1722         DEBUG(10, ("set_incoming_fault: Setting fault state on pipe %s\n",
    1723                    get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
     1985        p->fault_state = DCERPC_NCA_S_PROTO_ERROR;
     1986
     1987        p->allow_alter = false;
     1988        p->allow_auth3 = false;
     1989        p->pipe_bound = false;
     1990
     1991        DEBUG(10, ("Setting fault state\n"));
    17241992}
    17251993
    … …  
    17301998        NTSTATUS status;
    17311999        size_t hdr_size = DCERPC_REQUEST_LENGTH;
    1732         size_t pad_len;
    17332000
    17342001        DEBUG(10, ("Checking request auth.\n"));
    … …  
    17412008        status = dcerpc_check_auth(auth, pkt,
    17422009                                   &pkt->u.request.stub_and_verifier,
    1743                                    hdr_size, raw_pkt,
    1744                                    &pad_len);
     2010                                   hdr_size, raw_pkt);
    17452011        if (!NT_STATUS_IS_OK(status)) {
    17462012                return status;
    1747         }
    1748 
    1749 
    1750         /* remove padding and auth trailer,
    1751          * this way the caller will get just the data */
    1752         if (pkt->auth_length) {
    1753                 size_t trail_len = pad_len
    1754                                         + DCERPC_AUTH_TRAILER_LENGTH
    1755                                         + pkt->auth_length;
    1756                 if (pkt->u.request.stub_and_verifier.length < trail_len) {
    1757                         return NT_STATUS_INFO_LENGTH_MISMATCH;
    1758                 }
    1759                 pkt->u.request.stub_and_verifier.length -= trail_len;
    17602013        }
    17612014
    … …  
    17772030                set_incoming_fault(p);
    17782031                return False;
     2032        }
     2033
     2034        /*
     2035         * We don't ignore DCERPC_PFC_FLAG_PENDING_CANCEL.
     2036         * TODO: we can reject it with DCERPC_FAULT_NO_CALL_ACTIVE later.
     2037         */
     2038        status = dcerpc_verify_ncacn_packet_header(pkt,
     2039                        DCERPC_PKT_REQUEST,
     2040                        pkt->u.request.stub_and_verifier.length,
     2041                        0, /* required_flags */
     2042                        DCERPC_PFC_FLAG_FIRST |
     2043                        DCERPC_PFC_FLAG_LAST |
     2044                        0x08 | /* this is not defined, but should be ignored */
     2045                        DCERPC_PFC_FLAG_CONC_MPX |
     2046                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
     2047                        DCERPC_PFC_FLAG_MAYBE |
     2048                        DCERPC_PFC_FLAG_OBJECT_UUID);
     2049        if (!NT_STATUS_IS_OK(status)) {
     2050                DEBUG(1, ("process_request_pdu: invalid pdu: %s\n",
     2051                          nt_errstr(status)));
     2052                NDR_PRINT_DEBUG(ncacn_packet, pkt);
     2053                set_incoming_fault(p);
     2054                return false;
    17792055        }
    17802056
    … …  
    20282304                                                                &p->syntax)));
    20292305                set_incoming_fault(p);
    2030                 setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
     2306                setup_fault_pdu(p, NT_STATUS(DCERPC_NCA_S_PROTO_ERROR));
    20312307                TALLOC_FREE(pkt);
    20322308        } else {

  • vendor/current/source3/rpc_server/srvsvc/srv_srvsvc_nt.c

    r917 r919  
    25492549                              struct srvsvc_NetCharDevEnum *r)
    25502550{
    2551         p->rng_fault_state = True;
     2551        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    25522552        return WERR_NOT_SUPPORTED;
    25532553}
    … …  
    25562556                                 struct srvsvc_NetCharDevGetInfo *r)
    25572557{
    2558         p->rng_fault_state = True;
     2558        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    25592559        return WERR_NOT_SUPPORTED;
    25602560}
    … …  
    25632563                                 struct srvsvc_NetCharDevControl *r)
    25642564{
    2565         p->rng_fault_state = True;
     2565        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    25662566        return WERR_NOT_SUPPORTED;
    25672567}
    … …  
    25702570                               struct srvsvc_NetCharDevQEnum *r)
    25712571{
    2572         p->rng_fault_state = True;
     2572        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    25732573        return WERR_NOT_SUPPORTED;
    25742574}
    … …  
    25772577                                  struct srvsvc_NetCharDevQGetInfo *r)
    25782578{
    2579         p->rng_fault_state = True;
     2579        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    25802580        return WERR_NOT_SUPPORTED;
    25812581}
    … …  
    25842584                                  struct srvsvc_NetCharDevQSetInfo *r)
    25852585{
    2586         p->rng_fault_state = True;
     2586        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    25872587        return WERR_NOT_SUPPORTED;
    25882588}
    … …  
    25912591                                struct srvsvc_NetCharDevQPurge *r)
    25922592{
    2593         p->rng_fault_state = True;
     2593        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    25942594        return WERR_NOT_SUPPORTED;
    25952595}
    … …  
    25982598                                    struct srvsvc_NetCharDevQPurgeSelf *r)
    25992599{
    2600         p->rng_fault_state = True;
     2600        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26012601        return WERR_NOT_SUPPORTED;
    26022602}
    … …  
    26052605                              struct srvsvc_NetFileGetInfo *r)
    26062606{
    2607         p->rng_fault_state = True;
     2607        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26082608        return WERR_NOT_SUPPORTED;
    26092609}
    … …  
    26122612                             struct srvsvc_NetShareCheck *r)
    26132613{
    2614         p->rng_fault_state = True;
     2614        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26152615        return WERR_NOT_SUPPORTED;
    26162616}
    … …  
    26192619                                      struct srvsvc_NetServerStatisticsGet *r)
    26202620{
    2621         p->rng_fault_state = True;
     2621        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26222622        return WERR_NOT_SUPPORTED;
    26232623}
    … …  
    26262626                               struct srvsvc_NetTransportAdd *r)
    26272627{
    2628         p->rng_fault_state = True;
     2628        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26292629        return WERR_NOT_SUPPORTED;
    26302630}
    … …  
    26332633                                struct srvsvc_NetTransportEnum *r)
    26342634{
    2635         p->rng_fault_state = True;
     2635        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26362636        return WERR_NOT_SUPPORTED;
    26372637}
    … …  
    26402640                               struct srvsvc_NetTransportDel *r)
    26412641{
    2642         p->rng_fault_state = True;
     2642        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26432643        return WERR_NOT_SUPPORTED;
    26442644}
    … …  
    26472647                                 struct srvsvc_NetSetServiceBits *r)
    26482648{
    2649         p->rng_fault_state = True;
     2649        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26502650        return WERR_NOT_SUPPORTED;
    26512651}
    … …  
    26542654                           struct srvsvc_NetPathType *r)
    26552655{
    2656         p->rng_fault_state = True;
     2656        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26572657        return WERR_NOT_SUPPORTED;
    26582658}
    … …  
    26612661                                   struct srvsvc_NetPathCanonicalize *r)
    26622662{
    2663         p->rng_fault_state = True;
     2663        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26642664        return WERR_NOT_SUPPORTED;
    26652665}
    … …  
    26682668                              struct srvsvc_NetPathCompare *r)
    26692669{
    2670         p->rng_fault_state = True;
     2670        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26712671        return WERR_NOT_SUPPORTED;
    26722672}
    … …  
    26752675                                      struct srvsvc_NETRPRNAMECANONICALIZE *r)
    26762676{
    2677         p->rng_fault_state = True;
     2677        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26782678        return WERR_NOT_SUPPORTED;
    26792679}
    … …  
    26822682                                struct srvsvc_NetPRNameCompare *r)
    26832683{
    2684         p->rng_fault_state = True;
     2684        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26852685        return WERR_NOT_SUPPORTED;
    26862686}
    … …  
    26892689                                struct srvsvc_NetShareDelStart *r)
    26902690{
    2691         p->rng_fault_state = True;
     2691        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26922692        return WERR_NOT_SUPPORTED;
    26932693}
    … …  
    26962696                                 struct srvsvc_NetShareDelCommit *r)
    26972697{
    2698         p->rng_fault_state = True;
     2698        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    26992699        return WERR_NOT_SUPPORTED;
    27002700}
    … …  
    27032703                                       struct srvsvc_NetServerTransportAddEx *r)
    27042704{
    2705         p->rng_fault_state = True;
     2705        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27062706        return WERR_NOT_SUPPORTED;
    27072707}
    … …  
    27102710                                         struct srvsvc_NetServerSetServiceBitsEx *r)
    27112711{
    2712         p->rng_fault_state = True;
     2712        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27132713        return WERR_NOT_SUPPORTED;
    27142714}
    … …  
    27172717                                 struct srvsvc_NETRDFSGETVERSION *r)
    27182718{
    2719         p->rng_fault_state = True;
     2719        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27202720        return WERR_NOT_SUPPORTED;
    27212721}
    … …  
    27242724                                           struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
    27252725{
    2726         p->rng_fault_state = True;
     2726        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27272727        return WERR_NOT_SUPPORTED;
    27282728}
    … …  
    27312731                                           struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
    27322732{
    2733         p->rng_fault_state = True;
     2733        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27342734        return WERR_NOT_SUPPORTED;
    27352735}
    … …  
    27382738                                          struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
    27392739{
    2740         p->rng_fault_state = True;
     2740        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27412741        return WERR_NOT_SUPPORTED;
    27422742}
    … …  
    27452745                                    struct srvsvc_NETRDFSSETSERVERINFO *r)
    27462746{
    2747         p->rng_fault_state = True;
     2747        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27482748        return WERR_NOT_SUPPORTED;
    27492749}
    … …  
    27522752                                      struct srvsvc_NETRDFSCREATEEXITPOINT *r)
    27532753{
    2754         p->rng_fault_state = True;
     2754        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27552755        return WERR_NOT_SUPPORTED;
    27562756}
    … …  
    27592759                                      struct srvsvc_NETRDFSDELETEEXITPOINT *r)
    27602760{
    2761         p->rng_fault_state = True;
     2761        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27622762        return WERR_NOT_SUPPORTED;
    27632763}
    … …  
    27662766                                   struct srvsvc_NETRDFSMODIFYPREFIX *r)
    27672767{
    2768         p->rng_fault_state = True;
     2768        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27692769        return WERR_NOT_SUPPORTED;
    27702770}
    … …  
    27732773                                     struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
    27742774{
    2775         p->rng_fault_state = True;
     2775        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27762776        return WERR_NOT_SUPPORTED;
    27772777}
    … …  
    27802780                                            struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
    27812781{
    2782         p->rng_fault_state = True;
     2782        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    27832783        return WERR_NOT_SUPPORTED;
    27842784}
    … …  
    27872787                                        struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
    27882788{
    2789         p->rng_fault_state = True;
    2790         return WERR_NOT_SUPPORTED;
    2791 }
     2789        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     2790        return WERR_NOT_SUPPORTED;
     2791}

  • vendor/current/source3/rpc_server/svcctl/srv_svcctl_nt.c

    r917 r919  
    10051005                             struct svcctl_DeleteService *r)
    10061006{
    1007         p->rng_fault_state = True;
     1007        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10081008        return WERR_NOT_SUPPORTED;
    10091009}
    … …  
    10121012                                struct svcctl_SetServiceStatus *r)
    10131013{
    1014         p->rng_fault_state = True;
     1014        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10151015        return WERR_NOT_SUPPORTED;
    10161016}
    … …  
    10191019                                      struct svcctl_NotifyBootConfigStatus *r)
    10201020{
    1021         p->rng_fault_state = True;
     1021        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10221022        return WERR_NOT_SUPPORTED;
    10231023}
    … …  
    10261026                                 struct svcctl_SCSetServiceBitsW *r)
    10271027{
    1028         p->rng_fault_state = True;
     1028        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10291029        return WERR_NOT_SUPPORTED;
    10301030}
    … …  
    10331033                                    struct svcctl_ChangeServiceConfigW *r)
    10341034{
    1035         p->rng_fault_state = True;
     1035        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10361036        return WERR_NOT_SUPPORTED;
    10371037}
    … …  
    10401040                              struct svcctl_CreateServiceW *r)
    10411041{
    1042         p->rng_fault_state = True;
     1042        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10431043        return WERR_NOT_SUPPORTED;
    10441044}
    … …  
    10471047                                       struct svcctl_QueryServiceLockStatusW *r)
    10481048{
    1049         p->rng_fault_state = True;
     1049        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10501050        return WERR_NOT_SUPPORTED;
    10511051}
    … …  
    10541054                                  struct svcctl_GetServiceKeyNameW *r)
    10551055{
    1056         p->rng_fault_state = True;
     1056        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10571057        return WERR_NOT_SUPPORTED;
    10581058}
    … …  
    10611061                                 struct svcctl_SCSetServiceBitsA *r)
    10621062{
    1063         p->rng_fault_state = True;
     1063        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10641064        return WERR_NOT_SUPPORTED;
    10651065}
    … …  
    10681068                                    struct svcctl_ChangeServiceConfigA *r)
    10691069{
    1070         p->rng_fault_state = True;
     1070        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10711071        return WERR_NOT_SUPPORTED;
    10721072}
    … …  
    10751075                              struct svcctl_CreateServiceA *r)
    10761076{
    1077         p->rng_fault_state = True;
     1077        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10781078        return WERR_NOT_SUPPORTED;
    10791079}
    … …  
    10821082                                      struct svcctl_EnumDependentServicesA *r)
    10831083{
    1084         p->rng_fault_state = True;
     1084        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10851085        return WERR_NOT_SUPPORTED;
    10861086}
    … …  
    10891089                                   struct svcctl_EnumServicesStatusA *r)
    10901090{
    1091         p->rng_fault_state = True;
     1091        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10921092        return WERR_NOT_SUPPORTED;
    10931093}
    … …  
    10961096                              struct svcctl_OpenSCManagerA *r)
    10971097{
    1098         p->rng_fault_state = True;
     1098        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10991099        return WERR_NOT_SUPPORTED;
    11001100}
    … …  
    11031103                            struct svcctl_OpenServiceA *r)
    11041104{
    1105         p->rng_fault_state = True;
     1105        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11061106        return WERR_NOT_SUPPORTED;
    11071107}
    … …  
    11101110                                   struct svcctl_QueryServiceConfigA *r)
    11111111{
    1112         p->rng_fault_state = True;
     1112        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11131113        return WERR_NOT_SUPPORTED;
    11141114}
    … …  
    11171117                                       struct svcctl_QueryServiceLockStatusA *r)
    11181118{
    1119         p->rng_fault_state = True;
     1119        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11201120        return WERR_NOT_SUPPORTED;
    11211121}
    … …  
    11241124                             struct svcctl_StartServiceA *r)
    11251125{
    1126         p->rng_fault_state = True;
     1126        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11271127        return WERR_NOT_SUPPORTED;
    11281128}
    … …  
    11311131                                      struct svcctl_GetServiceDisplayNameA *r)
    11321132{
    1133         p->rng_fault_state = True;
     1133        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11341134        return WERR_NOT_SUPPORTED;
    11351135}
    … …  
    11381138                                  struct svcctl_GetServiceKeyNameA *r)
    11391139{
    1140         p->rng_fault_state = True;
     1140        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11411141        return WERR_NOT_SUPPORTED;
    11421142}
    … …  
    11451145                                      struct svcctl_GetCurrentGroupeStateW *r)
    11461146{
    1147         p->rng_fault_state = True;
     1147        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11481148        return WERR_NOT_SUPPORTED;
    11491149}
    … …  
    11521152                                 struct svcctl_EnumServiceGroupW *r)
    11531153{
    1154         p->rng_fault_state = True;
     1154        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11551155        return WERR_NOT_SUPPORTED;
    11561156}
    … …  
    11591159                                     struct svcctl_ChangeServiceConfig2A *r)
    11601160{
    1161         p->rng_fault_state = True;
     1161        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11621162        return WERR_NOT_SUPPORTED;
    11631163}
    … …  
    11661166                                     struct svcctl_ChangeServiceConfig2W *r)
    11671167{
    1168         p->rng_fault_state = True;
     1168        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11691169        return WERR_NOT_SUPPORTED;
    11701170}
    … …  
    11731173                                    struct svcctl_QueryServiceConfig2A *r)
    11741174{
    1175         p->rng_fault_state = True;
     1175        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11761176        return WERR_NOT_SUPPORTED;
    11771177}
    … …  
    11801180                              struct EnumServicesStatusExA *r)
    11811181{
    1182         p->rng_fault_state = True;
     1182        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11831183        return WERR_NOT_SUPPORTED;
    11841184}
    … …  
    11871187                              struct EnumServicesStatusExW *r)
    11881188{
    1189         p->rng_fault_state = True;
     1189        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11901190        return WERR_NOT_SUPPORTED;
    11911191}
    … …  
    11941194                               struct svcctl_SCSendTSMessage *r)
    11951195{
    1196         p->rng_fault_state = True;
    1197         return WERR_NOT_SUPPORTED;
    1198 }
     1196        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     1197        return WERR_NOT_SUPPORTED;
     1198}

  • vendor/current/source3/rpc_server/winreg/srv_winreg_nt.c

    r917 r919  
    761761           do anything */
    762762
    763         p->rng_fault_state = True;
     763        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    764764        return WERR_NOT_SUPPORTED;
    765765}
    … …  
    949949           do anything */
    950950
    951         p->rng_fault_state = True;
     951        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    952952        return WERR_NOT_SUPPORTED;
    953953}
    … …  
    963963           do anything */
    964964
    965         p->rng_fault_state = True;
     965        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    966966        return WERR_NOT_SUPPORTED;
    967967}
    … …  
    977977           do anything */
    978978
    979         p->rng_fault_state = True;
     979        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    980980        return WERR_NOT_SUPPORTED;
    981981}
    … …  
    11401140           do anything */
    11411141
    1142         p->rng_fault_state = True;
     1142        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    11431143        return WERR_NOT_SUPPORTED;
    11441144}

  • vendor/current/source3/rpc_server/wkssvc/srv_wkssvc_nt.c

    r860 r919  
    406406{
    407407        /* FIXME: Add implementation code here */
    408         p->rng_fault_state = True;
     408        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    409409        return WERR_NOT_SUPPORTED;
    410410}
    … …  
    609609{
    610610        /* FIXME: Add implementation code here */
    611         p->rng_fault_state = True;
     611        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    612612        return WERR_NOT_SUPPORTED;
    613613}
    … …  
    620620{
    621621        /* FIXME: Add implementation code here */
    622         p->rng_fault_state = True;
     622        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    623623        return WERR_NOT_SUPPORTED;
    624624}
    … …  
    631631{
    632632        /* FIXME: Add implementation code here */
    633         p->rng_fault_state = True;
     633        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    634634        return WERR_NOT_SUPPORTED;
    635635}
    … …  
    642642{
    643643        /* FIXME: Add implementation code here */
    644         p->rng_fault_state = True;
     644        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    645645        return WERR_NOT_SUPPORTED;
    646646}
    … …  
    653653{
    654654        /* FIXME: Add implementation code here */
    655         p->rng_fault_state = True;
     655        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    656656        return WERR_NOT_SUPPORTED;
    657657}
    … …  
    664664{
    665665        /* FIXME: Add implementation code here */
    666         p->rng_fault_state = True;
     666        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    667667        return WERR_NOT_SUPPORTED;
    668668}
    … …  
    675675{
    676676        /* FIXME: Add implementation code here */
    677         p->rng_fault_state = True;
     677        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    678678        return WERR_NOT_SUPPORTED;
    679679}
    … …  
    686686{
    687687        /* FIXME: Add implementation code here */
    688         p->rng_fault_state = True;
     688        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    689689        return WERR_NOT_SUPPORTED;
    690690}
    … …  
    697697{
    698698        /* FIXME: Add implementation code here */
    699         p->rng_fault_state = True;
     699        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    700700        return WERR_NOT_SUPPORTED;
    701701}
    … …  
    708708{
    709709        /* FIXME: Add implementation code here */
    710         p->rng_fault_state = True;
     710        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    711711        return WERR_NOT_SUPPORTED;
    712712}
    … …  
    719719{
    720720        /* FIXME: Add implementation code here */
    721         p->rng_fault_state = True;
     721        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    722722        return WERR_NOT_SUPPORTED;
    723723}
    … …  
    730730{
    731731        /* FIXME: Add implementation code here */
    732         p->rng_fault_state = True;
     732        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    733733        return WERR_NOT_SUPPORTED;
    734734}
    … …  
    741741{
    742742        /* FIXME: Add implementation code here */
    743         p->rng_fault_state = True;
     743        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    744744        return WERR_NOT_SUPPORTED;
    745745}
    … …  
    752752{
    753753        /* FIXME: Add implementation code here */
    754         p->rng_fault_state = True;
     754        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    755755        return WERR_NOT_SUPPORTED;
    756756}
    … …  
    763763{
    764764        /* FIXME: Add implementation code here */
    765         p->rng_fault_state = True;
     765        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    766766        return WERR_NOT_SUPPORTED;
    767767}
    … …  
    774774{
    775775        /* FIXME: Add implementation code here */
    776         p->rng_fault_state = True;
     776        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    777777        return WERR_NOT_SUPPORTED;
    778778}
    … …  
    785785{
    786786        /* FIXME: Add implementation code here */
    787         p->rng_fault_state = True;
     787        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    788788        return WERR_NOT_SUPPORTED;
    789789}
    … …  
    796796{
    797797        /* FIXME: Add implementation code here */
    798         p->rng_fault_state = True;
     798        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    799799        return WERR_NOT_SUPPORTED;
    800800}
    … …  
    807807{
    808808        /* FIXME: Add implementation code here */
    809         p->rng_fault_state = True;
     809        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    810810        return WERR_NOT_SUPPORTED;
    811811}
    … …  
    963963{
    964964        /* for now just return not supported */
     965        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    965966        return WERR_NOT_SUPPORTED;
    966967}
    … …  
    973974{
    974975        /* FIXME: Add implementation code here */
    975         p->rng_fault_state = True;
     976        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    976977        return WERR_NOT_SUPPORTED;
    977978}
    … …  
    984985{
    985986        /* FIXME: Add implementation code here */
    986         p->rng_fault_state = True;
     987        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    987988        return WERR_NOT_SUPPORTED;
    988989}
    … …  
    995996{
    996997        /* FIXME: Add implementation code here */
    997         p->rng_fault_state = True;
     998        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    998999        return WERR_NOT_SUPPORTED;
    9991000}
    … …  
    10061007{
    10071008        /* FIXME: Add implementation code here */
    1008         p->rng_fault_state = True;
     1009        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10091010        return WERR_NOT_SUPPORTED;
    10101011}
    … …  
    10171018{
    10181019        /* FIXME: Add implementation code here */
    1019         p->rng_fault_state = True;
     1020        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
    10201021        return WERR_NOT_SUPPORTED;
    10211022}
    … …  
    10281029{
    10291030        /* FIXME: Add implementation code here */
    1030         p->rng_fault_state = True;
    1031         return WERR_NOT_SUPPORTED;
    1032 }
     1031        p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
     1032        return WERR_NOT_SUPPORTED;
     1033}

  • vendor/current/source3/rpcclient/rpcclient.c

    r917 r919  
    10321032        }
    10331033
     1034        if (binding->flags & DCERPC_CONNECT) {
     1035                pipe_default_auth_level = DCERPC_AUTH_LEVEL_CONNECT;
     1036                pipe_default_auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
     1037        }
    10341038        if (binding->flags & DCERPC_SIGN) {
    10351039                pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
    … …  
    10451049        }
    10461050        if (binding->flags & DCERPC_AUTH_NTLM) {
    1047                 /* If neither Integrity or Privacy are requested then
    1048                  * Use just Connect level */
    1049                 if (pipe_default_auth_level == DCERPC_AUTH_LEVEL_NONE) {
    1050                         pipe_default_auth_level = DCERPC_AUTH_LEVEL_CONNECT;
    1051                 }
    1052 
    10531051                if (pipe_default_auth_type == DCERPC_AUTH_TYPE_SPNEGO) {
    10541052                        pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_NTLMSSP;
    … …  
    10581056        }
    10591057        if (binding->flags & DCERPC_AUTH_KRB5) {
    1060                 /* If neither Integrity or Privacy are requested then
    1061                  * Use just Connect level */
    1062                 if (pipe_default_auth_level == DCERPC_AUTH_LEVEL_NONE) {
    1063                         pipe_default_auth_level = DCERPC_AUTH_LEVEL_CONNECT;
    1064                 }
    1065 
    10661058                if (pipe_default_auth_type == DCERPC_AUTH_TYPE_SPNEGO) {
    10671059                        pipe_default_auth_spnego_type = PIPE_AUTH_TYPE_SPNEGO_KRB5;
    10681060                } else {
    10691061                        pipe_default_auth_type = DCERPC_AUTH_TYPE_KRB5;
     1062                }
     1063        }
     1064        if (pipe_default_auth_type != DCERPC_AUTH_TYPE_NONE) {
     1065                /* If nothing is requested then default to integrity */
     1066                if (pipe_default_auth_level == DCERPC_AUTH_LEVEL_NONE) {
     1067                        pipe_default_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
    10701068                }
    10711069        }

  • vendor/current/source3/selftest/knownfail

    r917 r919  
    1919samba3.*rap.sam.*.userdelete # Not provided by Samba 3
    2020samba3.*rap.basic.*.netsessiongetinfo # Not provided by Samba 3
     21samba3.blackbox.rpcclient.over.ncacn_np.with.*connect.* # we don't allow auth_level_connect anymore
     22samba3.posix_s3.rpc.lsa.lookupsids.*ncacn_ip_tcp.*connect.* # we don't allow auth_level_connect anymore

  • vendor/current/source3/selftest/skip

    r860 r919  
    2323samba3.*raw.qfsinfo
    2424samba3.*raw.sfileinfo.base
     25# skip, don't work for badlock backports
     26samba3.posix_s3.raw.eas
     27samba3.posix_s3.raw.rename
     28samba3.posix_s3.raw.search
     29samba3.posix_s3.raw.streams

  • vendor/current/source3/selftest/tests.py

    r917 r919  
    202202        elif t == "raw.samba3posixtimedlock":
    203203            plansmbtorturetestsuite(t, "s3dc", '//$SERVER_IP/tmpguest -U$USERNAME%$PASSWORD --option=torture:localdir=$SELFTEST_PREFIX/dc/share')
     204        elif t == "rpc.samr.passwords.validate":
     205            plansmbtorturetestsuite(t, "s3dc", 'ncacn_np:$SERVER_IP[seal] -U$USERNAME%$PASSWORD', 'over ncacn_np ')
    204206        else:
    205207            plansmbtorturetestsuite(t, "s3dc", '//$SERVER_IP/tmp -U$USERNAME%$PASSWORD')
    … …  
    209211
    210212    test = 'rpc.lsa.lookupsids'
    211     auth_options = ["", "ntlm", "spnego" ]
     213    auth_options = ["", "ntlm", "spnego", "spnego,ntlm" ]
    212214    signseal_options = ["", ",connect", ",sign", ",seal"]
    213215    smb_options = ["", ",smb2"]
    … …  
    220222                    options = binding_string + " -U$USERNAME%$PASSWORD"
    221223                    plansmbtorturetestsuite(test, "s3dc", options, 'over ncacn_np with [%s%s%s%s] ' % (a, s, z, e))
     224                    plantestsuite("samba3.blackbox.rpcclient over ncacn_np with [%s%s%s%s] " % (a, s, z, e), "s3dc:local", [os.path.join(samba3srcdir, "script/tests/test_rpcclient.sh"),
     225                                                                 "none", options, configuration])
     226
    222227    for e in endianness_options:
    223228        for a in auth_options:

  • vendor/current/source3/smbd/conn.c

    r860 r919  
    2424#include "smbd/globals.h"
    2525#include "rpc_server/rpc_ncacn_np.h"
     26#include "lib/util/bitmap.h"
    2627
    2728/* The connections bitmap is expanded in increments of BITMAP_BLOCK_SZ. The

  • vendor/current/source3/smbd/dir.c

    r860 r919  
    2424#include "smbd/globals.h"
    2525#include "libcli/security/security.h"
     26#include "lib/util/bitmap.h"
    2627
    2728/*

  • vendor/current/source3/smbd/files.c

    r917 r919  
    2323#include "libcli/security/security.h"
    2424#include "util_tdb.h"
     25#include "lib/util/bitmap.h"
    2526
    2627#define VALID_FNUM(fnum)   (((fnum) >= 0) && ((fnum) < real_max_open_files))

  • vendor/current/source3/smbd/smb2_server.c

    r860 r919  
    2727#include "../lib/util/tevent_ntstatus.h"
    2828#include "smbprofile.h"
     29#include "../lib/util/bitmap.h"
    2930
    3031#define OUTVEC_ALLOC_SIZE (SMB2_HDR_BODY + 9)

  • vendor/current/source3/smbd/vfs.c

    r917 r919  
    983983                const char *conn_rootdir;
    984984                size_t rootdir_len;
     985                bool matched;
    985986
    986987                conn_rootdir = SMB_VFS_CONNECTPATH(conn, fname);
    … …  
    993994
    994995                rootdir_len = strlen(conn_rootdir);
    995                 if (strncmp(conn_rootdir, resolved_name,
    996                                 rootdir_len) != 0) {
     996                matched = (strncmp(conn_rootdir, resolved_name,
     997                                rootdir_len) == 0);
     998                if (!matched || (resolved_name[rootdir_len] != '/' &&
     999                                 resolved_name[rootdir_len] != '\0')) {
    9971000                        DEBUG(2, ("check_reduced_name: Bad access "
    9981001                                "attempt: %s is a symlink outside the "

  • vendor/current/source3/winbindd/winbindd_cm.c

    r860 r919  
    23852385
    23862386 anonymous:
     2387        if (lp_winbind_sealed_pipes() && (IS_DC || domain->primary)) {
     2388                status = NT_STATUS_DOWNGRADE_DETECTED;
     2389                DEBUG(1, ("Unwilling to make SAMR connection to domain %s "
     2390                          "without connection level security, "
     2391                          "must set 'winbind sealed pipes = false' "
     2392                          "to proceed: %s\n",
     2393                          domain->name, nt_errstr(status)));
     2394                goto done;
     2395        }
    23872396
    23882397        /* Finally fall back to anonymous. */
    … …  
    26112620 anonymous:
    26122621
     2622        if (lp_winbind_sealed_pipes() && (IS_DC || domain->primary)) {
     2623                result = NT_STATUS_DOWNGRADE_DETECTED;
     2624                DEBUG(1, ("Unwilling to make LSA connection to domain %s "
     2625                          "without connection level security, "
     2626                          "must set 'winbind sealed pipes = false' "
     2627                          "to proceed: %s\n",
     2628                          domain->name, nt_errstr(result)));
     2629                goto done;
     2630        }
     2631
    26132632        result = cli_rpc_pipe_open_noauth(conn->cli,
    26142633                                          &ndr_table_lsarpc.syntax_id,
    … …  
    27502769 no_schannel:
    27512770        if ((lp_client_schannel() == False) ||
    2752                         ((neg_flags & NETLOGON_NEG_SCHANNEL) == 0)) {
     2771                ((neg_flags & NETLOGON_NEG_SCHANNEL) == 0)) {
     2772                if (lp_winbind_sealed_pipes() && (IS_DC || domain->primary)) {
     2773                        result = NT_STATUS_DOWNGRADE_DETECTED;
     2774                        DEBUG(1, ("Unwilling to make connection to domain %s "
     2775                                  "without connection level security, "
     2776                                  "must set 'winbind sealed pipes = false' "
     2777                                  "to proceed: %s\n",
     2778                                  domain->name, nt_errstr(result)));
     2779                        TALLOC_FREE(netlogon_pipe);
     2780                        invalidate_cm_connection(conn);
     2781                        return result;
     2782                }
    27532783                /*
    27542784                 * NetSamLogonEx only works for schannel

  • vendor/current/source4/heimdal/cf/make-proto.pl

    r917 r919  
    22# $Id$
    33
    4 ##use Getopt::Std;
    5 require 'getopts.pl';
     4use Getopt::Std;
     5#require 'getopts.pl';
    66
    77my $comment = 0;
    … …  
    1313my $private_func_re = "^_";
    1414
    15 Getopts('x:m:o:p:dqE:R:P:') || die "foo";
     15getopts('x:m:o:p:dqE:R:P:') || die "foo";
    1616
    1717if($opt_d) {

  • vendor/current/source4/lib/ldb/wscript

    r917 r919  
    136136                          vnum=VERSION,
    137137                          private_library=private_library,
    138                           manpages='man/ldb.3',
    139                           abi_directory = 'ABI',
    140                           abi_match = abi_match)
     138                          manpages='man/ldb.3')
    141139
    142140        # generate a include/ldb_version.h

  • vendor/current/source4/librpc/rpc/dcerpc.c

    r860 r919  
    700700        default:
    701701                return NT_STATUS_INVALID_LEVEL;
     702        }
     703
     704        if (pkt->auth_length == 0) {
     705                return NT_STATUS_INVALID_NETWORK_RESPONSE;
     706        }
     707
     708        if (c->security_state.generic_state == NULL) {
     709                return NT_STATUS_INTERNAL_ERROR;
    702710        }
    703711
    … …  
    10751083
    10761084        /* the bind_ack might contain a reply set of credentials */
    1077         if (conn->security_state.auth_info && pkt->u.bind_ack.auth_info.length) {
     1085        if (conn->security_state.auth_info && pkt->auth_length) {
    10781086                NTSTATUS status;
    10791087                uint32_t auth_length;
    … …  
    18481856
    18491857        /* the alter_resp might contain a reply set of credentials */
    1850         if (recv_pipe->conn->security_state.auth_info &&
    1851             pkt->u.alter_resp.auth_info.length) {
     1858        if (recv_pipe->conn->security_state.auth_info && pkt->auth_length) {
    18521859                struct dcecli_connection *conn = recv_pipe->conn;
    18531860                NTSTATUS status;

  • vendor/current/source4/librpc/rpc/dcerpc_util.c

    r917 r919  
    594594        /* Perform an authenticated DCE-RPC bind
    595595         */
    596         if (!(conn->flags & (DCERPC_SIGN|DCERPC_SEAL))) {
     596        if (!(conn->flags & (DCERPC_CONNECT|DCERPC_SEAL))) {
    597597                /*
    598598                  we are doing an authenticated connection,
    599                   but not using sign or seal. We must force
    600                   the CONNECT dcerpc auth type as a NONE auth
    601                   type doesn't allow authentication
    602                   information to be passed.
     599                  which needs to use [connect], [sign] or [seal].
     600                  If nothing is specified, we default to [sign] now.
     601                  This give roughly the same protection as
     602                  ncacn_np with smb signing.
    603603                */
    604                 conn->flags |= DCERPC_CONNECT;
     604                conn->flags |= DCERPC_SIGN;
    605605        }
    606606

  • vendor/current/source4/rpc_server/dcesrv_auth.c

    r740 r919  
    4747        uint32_t auth_length;
    4848
    49         if (pkt->u.bind.auth_info.length == 0) {
     49        if (pkt->auth_length == 0) {
    5050                dce_conn->auth_state.auth_info = NULL;
    5151                return true;
    … …  
    109109        NTSTATUS status;
    110110
    111         if (!call->conn->auth_state.gensec_security) {
     111        if (call->pkt.auth_length == 0) {
    112112                return NT_STATUS_OK;
    113113        }
    … …  
    156156        uint32_t auth_length;
    157157
    158         /* We can't work without an existing gensec state, and an new blob to feed it */
    159         if (!dce_conn->auth_state.auth_info ||
    160             !dce_conn->auth_state.gensec_security ||
    161             pkt->u.auth3.auth_info.length == 0) {
     158        if (pkt->auth_length == 0) {
     159                return false;
     160        }
     161
     162        if (!dce_conn->auth_state.auth_info) {
     163                return false;
     164        }
     165
     166        /* We can't work without an existing gensec state */
     167        if (!dce_conn->auth_state.gensec_security) {
    162168                return false;
    163169        }
    … …  
    204210
    205211        /* on a pure interface change there is no auth blob */
    206         if (pkt->u.alter.auth_info.length == 0) {
     212        if (pkt->auth_length == 0) {
    207213                return true;
    208214        }
    … …  
    239245        /* on a pure interface change there is no auth_info structure
    240246           setup */
    241         if (!call->conn->auth_state.auth_info ||
    242             dce_conn->auth_state.auth_info->credentials.length == 0) {
     247        if (call->pkt.auth_length == 0) {
    243248                return NT_STATUS_OK;
    244249        }
    … …  
    313318
    314319        default:
     320                return false;
     321        }
     322
     323        if (pkt->auth_length == 0) {
     324                DEBUG(1,("dcesrv_auth_request: unexpected auth_length of 0\n"));
    315325                return false;
    316326        }

  • vendor/current/source4/torture/basic/base.c

    r917 r919  
    14771477{
    14781478        bool nt_status_support;
     1479        bool client_ntlmv2_auth;
    14791480        struct smbcli_state *cli_nt = NULL, *cli_dos = NULL;
    14801481        bool result = false;
    … …  
    14861487
    14871488        nt_status_support = lpcfg_nt_status_support(tctx->lp_ctx);
     1489        client_ntlmv2_auth = lpcfg_client_ntlmv2_auth(tctx->lp_ctx);
    14881490
    14891491        if (!lpcfg_set_cmdline(tctx->lp_ctx, "nt status support", "yes")) {
    … …  
    14911493                goto fail;
    14921494        }
     1495        if (!lpcfg_set_cmdline(tctx->lp_ctx, "client ntlmv2 auth", "yes")) {
     1496                torture_result(tctx, TORTURE_FAIL, "Could not set 'client ntlmv2 auth = yes'\n");
     1497                goto fail;
     1498        }
    14931499
    14941500        if (!torture_open_connection(&cli_nt, tctx, 0)) {
    … …  
    14971503
    14981504        if (!lpcfg_set_cmdline(tctx->lp_ctx, "nt status support", "no")) {
    1499                 torture_comment(tctx, "Could not set 'nt status support = yes'\n");
     1505                torture_result(tctx, TORTURE_FAIL, "Could not set 'nt status support = no'\n");
     1506                goto fail;
     1507        }
     1508        if (!lpcfg_set_cmdline(tctx->lp_ctx, "client ntlmv2 auth", "no")) {
     1509                torture_result(tctx, TORTURE_FAIL, "Could not set 'client ntlmv2 auth = no'\n");
    15001510                goto fail;
    15011511        }
    … …  
    15071517        if (!lpcfg_set_cmdline(tctx->lp_ctx, "nt status support",
    15081518                            nt_status_support ? "yes":"no")) {
    1509                 torture_comment(tctx, "Could not reset 'nt status support = yes'");
     1519                torture_result(tctx, TORTURE_FAIL, "Could not reset 'nt status support'");
     1520                goto fail;
     1521        }
     1522        if (!lpcfg_set_cmdline(tctx->lp_ctx, "client ntlmv2 auth",
     1523                               client_ntlmv2_auth ? "yes":"no")) {
     1524                torture_result(tctx, TORTURE_FAIL, "Could not reset 'client ntlmv2 auth'");
    15101525                goto fail;
    15111526        }

  • vendor/current/source4/torture/ndr/dfsblob.c

    r917 r919  
    7575        struct torture_suite *suite = torture_suite_create(ctx, "dfsblob");
    7676
    77         torture_suite_add_ndr_pull_fn_test(suite, dfs_GetDFSReferral_in, dfs_get_ref_in, NDR_IN, NULL);
     77        torture_suite_add_ndr_pull_test(suite, dfs_GetDFSReferral_in, dfs_get_ref_in, NULL);
    7878
    79         torture_suite_add_ndr_pull_fn_test(suite, dfs_referral_resp, dfs_get_ref_out2, NDR_BUFFERS|NDR_SCALARS, NULL);
     79        torture_suite_add_ndr_pull_test(suite, dfs_referral_resp, dfs_get_ref_out2, NULL);
    8080
    81         torture_suite_add_ndr_pull_fn_test(suite, dfs_referral_resp, dfs_get_ref_out, NDR_BUFFERS|NDR_SCALARS,dfs_referral_out_check);
     81        torture_suite_add_ndr_pull_test(suite, dfs_referral_resp, dfs_get_ref_out,dfs_referral_out_check);
    8282
    8383        return suite;

  • vendor/current/source4/torture/ndr/drsblobs.c

    r917 r919  
    116116};
    117117
     118/* these are taken from the trust objects of a w2k8r2 forest, with a
     119 * trust relationship between the forest parent and a child domain
     120 */
     121static const char *trustAuthIncoming =
     122"AQAAAAwAAAAcAQAASuQ+RXJdzAECAAAAAAEAAMOWL6UVfVKiJOUsGcT03H"
     123"jHxr2ACsMMOV5ynM617Tp7idNC+c4egdqk4S9YEpvR2YvHmdZdymL6F7QKm8OkXazYZF2r/gZ/bI+"
     124"jkWbsn4O8qyAc3OUKQRZwBbf+lxBW+vM4O3ZpUjz5BSKCcFQgM+MY91yVU8Nji3HNnvGnDquobFAZ"
     125"hxjL+S1l5+QZgkfyfv5mQScGRbU1Lar1xg9G3JznUb7S6pvrBO2nwK8g+KZBfJy5UeULigDH4IWo/"
     126"JmtaEGkKE2uiKIjdsEQd/uwnkouW26XzRc0ulfJnPFftGnT9KIcShPf7DLj/tstmQAAceRMFHJTY3"
     127"PmxoowoK8HUyBK5D5Fcl3MAQIAAAAAAQAAw5YvpRV9UqIk5SwZxPTceMfGvYAKwww5XnKczrXtOnu"
     128"J00L5zh6B2qThL1gSm9HZi8eZ1l3KYvoXtAqbw6RdrNhkXav+Bn9sj6ORZuyfg7yrIBzc5QpBFnAF"
     129"t/6XEFb68zg7dmlSPPkFIoJwVCAz4xj3XJVTw2OLcc2e8acOq6hsUBmHGMv5LWXn5BmCR/J+/mZBJ"
     130"wZFtTUtqvXGD0bcnOdRvtLqm+sE7afAryD4pkF8nLlR5QuKAMfghaj8ma1oQaQoTa6IoiN2wRB3+7"
     131"CeSi5bbpfNFzS6V8mc8V+0adP0ohxKE9/sMuP+2y2ZAABx5EwUclNjc+bGijCgrwdTIA==";
     132
     133static const char *trustAuthOutgoing =
     134"AQAAAAwAAAAcAQAASuQ+RXJdzAECAAAAAAEAAMOWL6UVfVKiJOUsGcT03H"
     135"jHxr2ACsMMOV5ynM617Tp7idNC+c4egdqk4S9YEpvR2YvHmdZdymL6F7QKm8OkXazYZF2r/gZ/bI+"
     136"jkWbsn4O8qyAc3OUKQRZwBbf+lxBW+vM4O3ZpUjz5BSKCcFQgM+MY91yVU8Nji3HNnvGnDquobFAZ"
     137"hxjL+S1l5+QZgkfyfv5mQScGRbU1Lar1xg9G3JznUb7S6pvrBO2nwK8g+KZBfJy5UeULigDH4IWo/"
     138"JmtaEGkKE2uiKIjdsEQd/uwnkouW26XzRc0ulfJnPFftGnT9KIcShPf7DLj/tstmQAAceRMFHJTY3"
     139"PmxoowoK8HUyBK5D5Fcl3MAQIAAAAAAQAAw5YvpRV9UqIk5SwZxPTceMfGvYAKwww5XnKczrXtOnu"
     140"J00L5zh6B2qThL1gSm9HZi8eZ1l3KYvoXtAqbw6RdrNhkXav+Bn9sj6ORZuyfg7yrIBzc5QpBFnAF"
     141"t/6XEFb68zg7dmlSPPkFIoJwVCAz4xj3XJVTw2OLcc2e8acOq6hsUBmHGMv5LWXn5BmCR/J+/mZBJ"
     142"wZFtTUtqvXGD0bcnOdRvtLqm+sE7afAryD4pkF8nLlR5QuKAMfghaj8ma1oQaQoTa6IoiN2wRB3+7"
     143"CeSi5bbpfNFzS6V8mc8V+0adP0ohxKE9/sMuP+2y2ZAABx5EwUclNjc+bGijCgrwdTIA==";
     144
     145
    118146static bool trust_domain_passwords_check_in(struct torture_context *tctx,
    119147                                            struct trustDomainPasswords *r)
    … …  
    155183        struct torture_suite *suite = torture_suite_create(ctx, "drsblobs");
    156184
    157         torture_suite_add_ndr_pull_fn_test(suite, ForestTrustInfo, forest_trust_info_data_out, NDR_IN, forest_trust_info_check_out);
    158         torture_suite_add_ndr_pull_fn_test(suite, trustDomainPasswords, trust_domain_passwords_in, NDR_IN, trust_domain_passwords_check_in);
     185        torture_suite_add_ndr_pull_test(suite, ForestTrustInfo, forest_trust_info_data_out, forest_trust_info_check_out);
     186        torture_suite_add_ndr_pull_test(suite, trustDomainPasswords, trust_domain_passwords_in, trust_domain_passwords_check_in);
     187
     188#if 0
     189        torture_suite_add_ndr_pullpush_test(suite,
     190                                            trustAuthInOutBlob,
     191                                            base64_decode_data_blob_talloc(suite, trustAuthIncoming),
     192                                            NULL);
     193
     194        torture_suite_add_ndr_pullpush_test(suite,
     195                                            trustAuthInOutBlob,
     196                                            base64_decode_data_blob_talloc(suite, trustAuthOutgoing),
     197                                            NULL);
     198#endif
    159199
    160200        return suite;

  • vendor/current/source4/torture/ndr/nbt.c

    r917 r919  
    6363        struct torture_suite *suite = torture_suite_create(ctx, "nbt");
    6464
    65         torture_suite_add_ndr_pull_fn_test(suite, nbt_netlogon_packet, netlogon_logon_request_req_data, NDR_IN, netlogon_logon_request_req_check);
     65        torture_suite_add_ndr_pull_test(suite, nbt_netlogon_packet, netlogon_logon_request_req_data, netlogon_logon_request_req_check);
    6666
    67         torture_suite_add_ndr_pull_fn_test(suite, nbt_netlogon_response2, netlogon_logon_request_resp_data, NDR_IN, netlogon_logon_request_resp_check);
     67        torture_suite_add_ndr_pull_test(suite, nbt_netlogon_response2, netlogon_logon_request_resp_data, netlogon_logon_request_resp_check);
    6868
    6969        return suite;

  • vendor/current/source4/torture/ndr/ndr.c

    r917 r919  
    3030        size_t struct_size;
    3131        ndr_pull_flags_fn_t pull_fn;
     32        ndr_push_flags_fn_t push_fn;
    3233        int ndr_flags;
     34        int flags;
    3335};
    3436
    35 static bool wrap_ndr_pull_test(struct torture_context *tctx,
    36                                struct torture_tcase *tcase,
    37                                struct torture_test *test)
     37static bool wrap_ndr_pullpush_test(struct torture_context *tctx,
     38                                   struct torture_tcase *tcase,
     39                                   struct torture_test *test)
    3840{
    3941        bool (*check_fn) (struct torture_context *ctx, void *data) = test->fn;
    4042        const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;
    41         void *ds = talloc_zero_size(tctx, data->struct_size);
    4243        struct ndr_pull *ndr = ndr_pull_init_blob(&(data->data), tctx);
     44        void *ds = talloc_zero_size(ndr, data->struct_size);
     45        bool ret;
     46        uint32_t highest_ofs;
     47
     48        ndr->flags |= data->flags;
    4349
    4450        ndr->flags |= LIBNDR_FLAG_REF_ALLOC;
    … …  
    4753                                   "pulling");
    4854
    49         torture_assert(tctx, ndr->offset == ndr->data_size,
     55        if (ndr->offset > ndr->relative_highest_offset) {
     56                highest_ofs = ndr->offset;
     57        } else {
     58                highest_ofs = ndr->relative_highest_offset;
     59        }
     60
     61        torture_assert(tctx, highest_ofs == ndr->data_size,
    5062                                   talloc_asprintf(tctx,
    51                                            "%d unread bytes", ndr->data_size - ndr->offset));
    52 
    53         if (check_fn != NULL)
    54                 return check_fn(tctx, ds);
    55         else
    56                 return true;
    57 }
    58 
    59 _PUBLIC_ struct torture_test *_torture_suite_add_ndr_pull_test(
    60                                         struct torture_suite *suite,
    61                                         const char *name, ndr_pull_flags_fn_t pull_fn,
    62                                         DATA_BLOB db,
    63                                         size_t struct_size,
    64                                         int ndr_flags,
    65                                         bool (*check_fn) (struct torture_context *ctx, void *data))
     63                                           "%d unread bytes", ndr->data_size - highest_ofs));
     64
     65        if (check_fn != NULL) {
     66                ret = check_fn(tctx, ds);
     67        } else {
     68                ret = true;
     69        }
     70
     71        if (data->push_fn != NULL) {
     72                DATA_BLOB outblob;
     73                torture_assert_ndr_success(tctx, ndr_push_struct_blob(&outblob, ndr, ds, data->push_fn), "pushing");
     74                torture_assert_data_blob_equal(tctx, outblob, data->data, "ndr push compare");
     75        }
     76
     77        talloc_free(ndr);
     78        return ret;
     79}
     80
     81_PUBLIC_ struct torture_test *_torture_suite_add_ndr_pullpush_test(
     82        struct torture_suite *suite,
     83        const char *name,
     84        ndr_pull_flags_fn_t pull_fn,
     85        ndr_push_flags_fn_t push_fn,
     86        DATA_BLOB db,
     87        size_t struct_size,
     88        int ndr_flags,
     89        int flags,
     90        bool (*check_fn) (struct torture_context *ctx, void *data))
    6691{
    6792        struct torture_test *test;
    … …  
    75100        test->name = talloc_strdup(test, name);
    76101        test->description = NULL;
    77         test->run = wrap_ndr_pull_test;
     102        test->run = wrap_ndr_pullpush_test;
     103
    78104        data = talloc(test, struct ndr_pull_test_data);
    79105        data->data = db;
    80106        data->ndr_flags = ndr_flags;
     107        data->flags = flags;
    81108        data->struct_size = struct_size;
    82109        data->pull_fn = pull_fn;
     110        data->push_fn = push_fn;
     111
    83112        test->data = data;
    84113        test->fn = check_fn;
    … …  
    89118        return test;
    90119}
     120
    91121
    92122static bool wrap_ndr_inout_pull_test(struct torture_context *tctx,
    … …  
    98128        void *ds = talloc_zero_size(tctx, data->struct_size);
    99129        struct ndr_pull *ndr;
     130        uint32_t highest_ofs;
    100131
    101132        /* handle NDR_IN context */
    … …  
    110141                "ndr pull of context failed");
    111142
    112         torture_assert(tctx, ndr->offset == ndr->data_size,
    113                 talloc_asprintf(tctx, "%d unread bytes", ndr->data_size - ndr->offset));
     143        if (ndr->offset > ndr->relative_highest_offset) {
     144                highest_ofs = ndr->offset;
     145        } else {
     146                highest_ofs = ndr->relative_highest_offset;
     147        }
     148
     149        torture_assert(tctx, highest_ofs == ndr->data_size,
     150                talloc_asprintf(tctx, "%d unread bytes", ndr->data_size - highest_ofs));
    114151
    115152        talloc_free(ndr);
    … …  
    126163                "ndr pull failed");
    127164
    128         torture_assert(tctx, ndr->offset == ndr->data_size,
    129                 talloc_asprintf(tctx, "%d unread bytes", ndr->data_size - ndr->offset));
     165        if (ndr->offset > ndr->relative_highest_offset) {
     166                highest_ofs = ndr->offset;
     167        } else {
     168                highest_ofs = ndr->relative_highest_offset;
     169        }
     170
     171        torture_assert(tctx, highest_ofs == ndr->data_size,
     172                talloc_asprintf(tctx, "%d unread bytes", ndr->data_size - highest_ofs));
    130173
    131174        talloc_free(ndr);

  • vendor/current/source4/torture/ndr/ndr.h

    r917 r919  
    2525#include "libcli/security/security.h"
    2626
    27 _PUBLIC_ struct torture_test *_torture_suite_add_ndr_pull_test(
     27_PUBLIC_ struct torture_test *_torture_suite_add_ndr_pullpush_test(
    2828                                        struct torture_suite *suite,
    29                                         const char *name, ndr_pull_flags_fn_t fn,
     29                                        const char *name,
     30                                        ndr_pull_flags_fn_t pull_fn,
     31                                        ndr_push_flags_fn_t push_fn,
    3032                                        DATA_BLOB db,
    3133                                        size_t struct_size,
    3234                                        int ndr_flags,
     35                                        int flags,
    3336                                        bool (*check_fn) (struct torture_context *, void *data));
    3437
    … …  
    4245
    4346#define torture_suite_add_ndr_pull_test(suite,name,data,check_fn) \
    44                 _torture_suite_add_ndr_pull_test(suite, #name, \
    45                          (ndr_pull_flags_fn_t)ndr_pull_ ## name, data_blob_talloc(suite, data, sizeof(data)), \
    46                          sizeof(struct name), NDR_SCALARS|NDR_BUFFERS, (bool (*) (struct torture_context *, void *)) check_fn);
     47                _torture_suite_add_ndr_pullpush_test(suite, #name, \
     48                         (ndr_pull_flags_fn_t)ndr_pull_ ## name, NULL, data_blob_const(data, sizeof(data)), \
     49                         sizeof(struct name), NDR_SCALARS|NDR_BUFFERS, 0, (bool (*) (struct torture_context *, void *)) check_fn);
    4750
    4851#define torture_suite_add_ndr_pull_fn_test(suite,name,data,flags,check_fn) \
    49                 _torture_suite_add_ndr_pull_test(suite, #name "_" #flags, \
    50                          (ndr_pull_flags_fn_t)ndr_pull_ ## name, data_blob_talloc(suite, data, sizeof(data)), \
    51                          sizeof(struct name), flags, (bool (*) (struct torture_context *, void *)) check_fn);
     52                _torture_suite_add_ndr_pullpush_test(suite, #name "_" #flags, \
     53                         (ndr_pull_flags_fn_t)ndr_pull_ ## name, NULL, data_blob_const(data, sizeof(data)), \
     54                         sizeof(struct name), flags, 0, (bool (*) (struct torture_context *, void *)) check_fn);
     55
     56#define torture_suite_add_ndr_pull_fn_test_flags(suite,name,data,flags,flags2,check_fn) \
     57                _torture_suite_add_ndr_pullpush_test(suite, #name "_" #flags "_" #flags2, \
     58                         (ndr_pull_flags_fn_t)ndr_pull_ ## name, NULL, data_blob_const(data, sizeof(data)), \
     59                         sizeof(struct name), flags, flags2, (bool (*) (struct torture_context *, void *)) check_fn);
     60
     61#define torture_suite_add_ndr_pullpush_test(suite,name,data_blob,check_fn) \
     62                _torture_suite_add_ndr_pullpush_test(suite, #name, \
     63                         (ndr_pull_flags_fn_t)ndr_pull_ ## name, \
     64                         (ndr_push_flags_fn_t)ndr_push_ ## name, \
     65                         data_blob, \
     66                         sizeof(struct name), NDR_SCALARS|NDR_BUFFERS, 0, (bool (*) (struct torture_context *, void *)) check_fn);
    5267
    5368#define torture_suite_add_ndr_pull_io_test(suite,name,data_in,data_out,check_fn_out) \
    5469                _torture_suite_add_ndr_pull_inout_test(suite, #name "_INOUT", \
    5570                         (ndr_pull_flags_fn_t)ndr_pull_ ## name, \
    56                          data_blob_talloc(suite, data_in, sizeof(data_in)), \
    57                          data_blob_talloc(suite, data_out, sizeof(data_out)), \
     71                         data_blob_const(data_in, sizeof(data_in)), \
     72                         data_blob_const(data_out, sizeof(data_out)), \
    5873                         sizeof(struct name), \
    5974                         (bool (*) (struct torture_context *, void *)) check_fn_out);

  • vendor/current/source4/torture/ndr/ntlmssp.c

    r917 r919  
    112112        struct torture_suite *suite = torture_suite_create(ctx, "ntlmssp");
    113113
    114         torture_suite_add_ndr_pull_fn_test(suite, NEGOTIATE_MESSAGE, ntlmssp_NEGOTIATE_MESSAGE_data, NDR_IN, ntlmssp_NEGOTIATE_MESSAGE_check);
    115         /* torture_suite_add_ndr_pull_fn_test(suite, CHALLENGE_MESSAGE, ntlmssp_CHALLENGE_MESSAGE_data, NDR_IN, ntlmssp_CHALLENGE_MESSAGE_check);
    116         torture_suite_add_ndr_pull_fn_test(suite, AUTHENTICATE_MESSAGE, ntlmssp_AUTHENTICATE_MESSAGE_data, NDR_IN, ntlmssp_AUTHENTICATE_MESSAGE_check); */
    117 
     114        torture_suite_add_ndr_pull_test(suite, NEGOTIATE_MESSAGE, ntlmssp_NEGOTIATE_MESSAGE_data, ntlmssp_NEGOTIATE_MESSAGE_check);
     115#if 0
     116        torture_suite_add_ndr_pull_test(suite, CHALLENGE_MESSAGE, ntlmssp_CHALLENGE_MESSAGE_data, ntlmssp_CHALLENGE_MESSAGE_check);
     117        torture_suite_add_ndr_pull_test(suite, AUTHENTICATE_MESSAGE, ntlmssp_AUTHENTICATE_MESSAGE_data, ntlmssp_AUTHENTICATE_MESSAGE_check);
     118#endif
    118119        return suite;
    119120}

  • vendor/current/source4/torture/raw/samba3misc.c

    r917 r919  
    341341        TALLOC_CTX *mem_ctx;
    342342        bool nt_status_support;
     343        bool client_ntlmv2_auth;
    343344
    344345        if (!(mem_ctx = talloc_init("torture_samba3_badpath"))) {
    … …  
    348349
    349350        nt_status_support = lpcfg_nt_status_support(torture->lp_ctx);
    350 
    351         if (!lpcfg_set_cmdline(torture->lp_ctx, "nt status support", "yes")) {
    352                 printf("Could not set 'nt status support = yes'\n");
    353                 goto fail;
    354         }
     351        client_ntlmv2_auth = lpcfg_client_ntlmv2_auth(torture->lp_ctx);
     352
     353        torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "nt status support", "yes"), ret, fail, "Could not set 'nt status support = yes'\n");
     354        torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "client ntlmv2 auth", "yes"), ret, fail, "Could not set 'client ntlmv2 auth = yes'\n");
    355355
    356356        if (!torture_open_connection(&cli_nt, torture, 0)) {
    … …  
    358358        }
    359359
    360         if (!lpcfg_set_cmdline(torture->lp_ctx, "nt status support", "no")) {
    361                 printf("Could not set 'nt status support = yes'\n");
    362                 goto fail;
    363         }
     360        torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "nt status support", "no"), ret, fail, "Could not set 'nt status support = no'\n");
     361        torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "client ntlmv2 auth", "no"), ret, fail, "Could not set 'client ntlmv2 auth = no'\n");
    364362
    365363        if (!torture_open_connection(&cli_dos, torture, 1)) {
    … …  
    374372
    375373        smbcli_deltree(cli_nt->tree, dirname);
     374        torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "nt status support",
     375                                                       nt_status_support ? "yes":"no"),
     376                            ret, fail, "Could not set 'nt status support' back to where it was\n");
     377        torture_assert_goto(torture, lpcfg_set_cmdline(torture->lp_ctx, "client ntlmv2 auth",
     378                                                       client_ntlmv2_auth ? "yes":"no"),
     379                            ret, fail, "Could not set 'client ntlmv2 auth' back to where it was\n");
    376380
    377381        status = smbcli_mkdir(cli_nt->tree, dirname);

  • vendor/current/source4/torture/rpc/rpc.c

    r917 r919  
    502502        torture_suite_add_suite(suite, torture_rpc_samr_passwords_badpwdcount(suite));
    503503        torture_suite_add_suite(suite, torture_rpc_samr_passwords_lockout(suite));
     504        torture_suite_add_suite(suite, torture_rpc_samr_passwords_validate(suite));
    504505        torture_suite_add_suite(suite, torture_rpc_samr_user_privileges(suite));
    505506        torture_suite_add_suite(suite, torture_rpc_samr_large_dc(suite));

  • vendor/current/source4/torture/rpc/samba3rpc.c

    r917 r919  
    11231123                names_blob = NTLMv2_generate_names_blob(
    11241124                        mem_ctx,
    1125                         cli_credentials_get_workstation(user_creds),
    1126                         cli_credentials_get_domain(user_creds));
     1125                        cli_credentials_get_workstation(wks_creds),
     1126                        cli_credentials_get_domain(wks_creds));
    11271127                status = cli_credentials_get_ntlm_response(
    11281128                        user_creds, mem_ctx, &flags, chal, names_blob,

  • vendor/current/source4/torture/rpc/samr.c

    r860 r919  
    79397939
    79407940
    7941 static bool test_samr_ValidatePassword(struct dcerpc_pipe *p,
    7942                                        struct torture_context *tctx)
     7941static bool test_samr_ValidatePassword(struct torture_context *tctx,
     7942                                       struct dcerpc_pipe *p)
    79437943{
    79447944        struct samr_ValidatePassword r;
    … …  
    79527952        torture_comment(tctx, "Testing samr_ValidatePassword\n");
    79537953
     7954        if (p->conn->transport.transport != NCACN_IP_TCP) {
     7955                torture_comment(tctx, "samr_ValidatePassword only should succeed over NCACN_IP_TCP!\n");
     7956        }
     7957
    79547958        ZERO_STRUCT(r);
    79557959        r.in.level = NetValidatePasswordReset;
    … …  
    80758079        ret &= test_samr_handle_Close(b, torture, &ctx->handle);
    80768080
    8077         ret &= test_samr_ValidatePassword(p, torture);
    8078 
    80798081        return ret;
    80808082}
    … …  
    83718373}
    83728374
    8373 
     8375struct torture_suite *torture_rpc_samr_passwords_validate(TALLOC_CTX *mem_ctx)
     8376{
     8377        struct torture_suite *suite = torture_suite_create(mem_ctx, "samr.passwords.validate");
     8378        struct torture_rpc_tcase *tcase;
     8379
     8380        tcase = torture_suite_add_rpc_iface_tcase(suite, "samr",
     8381                                                  &ndr_table_samr);
     8382        torture_rpc_tcase_add_test(tcase, "validate",
     8383                                   test_samr_ValidatePassword);
     8384
     8385        return suite;
     8386}
Note: See TracChangeset for help on using the changeset viewer.