source3/libads/cldap.c

   1 /*
   2    Samba Unix/Linux SMB client library
   3    net ads cldap functions
   4    Copyright (C) 2001 Andrew Tridgell (tridge@samba.org)
   5    Copyright (C) 2003 Jim McDonough (jmcd@us.ibm.com)
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 /*
  25   These seem to be strings as described in RFC1035 4.1.4 and can be:
  26
  27    - a sequence of labels ending in a zero octet
  28    - a pointer
  29    - a sequence of labels ending with a pointer
  30
  31   A label is a byte where the first two bits must be zero and the remaining
  32   bits represent the length of the label followed by the label itself.
  33   Therefore, the length of a label is at max 64 bytes.  Under RFC1035, a
  34   sequence of labels cannot exceed 255 bytes.
  35
  36   A pointer consists of a 14 bit offset from the beginning of the data.
  37
  38   struct ptr {
  39     unsigned ident:2; // must be 11
  40     unsigned offset:14; // from the beginning of data
  41   };
  42
  43   This is used as a method to compress the packet by eliminated duplicate
  44   domain components.  Since a UDP packet should probably be < 512 bytes and a
  45   DNS name can be up to 255 bytes, this actually makes a lot of sense.
  46 */
  47 static unsigned pull_netlogon_string(char *ret, const char *ptr,
  48                                      const char *data)
  49 {
  50         char *pret = ret;
  51         int followed_ptr = 0;
  52         unsigned ret_len = 0;
  53
  54         memset(pret, 0, MAX_DNS_LABEL);
  55         do {
  56                 if ((*ptr & 0xc0) == 0xc0) {
  57                         uint16 len;
  58
  59                         if (!followed_ptr) {
  60                                 ret_len += 2;
  61                                 followed_ptr = 1;
  62                         }
  63                         len = ((ptr[0] & 0x3f) << 8) | ptr[1];
  64                         ptr = data + len;
  65                 } else if (*ptr) {
  66                         uint8 len = (uint8)*(ptr++);
  67
  68                         if ((pret - ret + len + 1) >= MAX_DNS_LABEL) {
  69                                 DEBUG(1,("DC returning too long DNS name\n"));
  70                                 return 0;
  71                         }
  72
  73                         if (pret != ret) {
  74                                 *pret = '.';
  75                                 pret++;
  76                         }
  77                         memcpy(pret, ptr, len);
  78                         pret += len;
  79                         ptr += len;
  80
  81                         if (!followed_ptr) {
  82                                 ret_len += (len + 1);
  83                         }
  84                 }
  85         } while (*ptr);
  86
  87         return followed_ptr ? ret_len : ret_len + 1;
  88 }
  89
  90 /*
  91   do a cldap netlogon query
  92 */
  93 static int send_cldap_netlogon(int sock, const char *domain,
  94                                const char *hostname, unsigned ntversion)
  95 {
  96         ASN1_DATA data;
  97         char ntver[4];
  98 #ifdef CLDAP_USER_QUERY
  99         char aac[4];
 100
 101         SIVAL(aac, 0, 0x00000180);
 102 #endif
 103         SIVAL(ntver, 0, ntversion);
 104
 105         memset(&data, 0, sizeof(data));
 106
 107         asn1_push_tag(&data,ASN1_SEQUENCE(0));
 108         asn1_write_Integer(&data, 4);
 109         asn1_push_tag(&data, ASN1_APPLICATION(3));
 110         asn1_write_OctetString(&data, NULL, 0);
 111         asn1_write_enumerated(&data, 0);
 112         asn1_write_enumerated(&data, 0);
 113         asn1_write_Integer(&data, 0);
 114         asn1_write_Integer(&data, 0);
 115         asn1_write_BOOLEAN2(&data, False);
 116         asn1_push_tag(&data, ASN1_CONTEXT(0));
 117
 118         if (domain) {
 119                 asn1_push_tag(&data, ASN1_CONTEXT(3));
 120                 asn1_write_OctetString(&data, "DnsDomain", 9);
 121                 asn1_write_OctetString(&data, domain, strlen(domain));
 122                 asn1_pop_tag(&data);
 123         }
 124
 125         asn1_push_tag(&data, ASN1_CONTEXT(3));
 126         asn1_write_OctetString(&data, "Host", 4);
 127         asn1_write_OctetString(&data, hostname, strlen(hostname));
 128         asn1_pop_tag(&data);
 129
 130 #ifdef CLDAP_USER_QUERY
 131         asn1_push_tag(&data, ASN1_CONTEXT(3));
 132         asn1_write_OctetString(&data, "User", 4);
 133         asn1_write_OctetString(&data, "SAMBA$", 6);
 134         asn1_pop_tag(&data);
 135
 136         asn1_push_tag(&data, ASN1_CONTEXT(3));
 137         asn1_write_OctetString(&data, "AAC", 4);
 138         asn1_write_OctetString(&data, aac, 4);
 139         asn1_pop_tag(&data);
 140 #endif
 141
 142         asn1_push_tag(&data, ASN1_CONTEXT(3));
 143         asn1_write_OctetString(&data, "NtVer", 5);
 144         asn1_write_OctetString(&data, ntver, 4);
 145         asn1_pop_tag(&data);
 146
 147         asn1_pop_tag(&data);
 148
 149         asn1_push_tag(&data,ASN1_SEQUENCE(0));
 150         asn1_write_OctetString(&data, "NetLogon", 8);
 151         asn1_pop_tag(&data);
 152         asn1_pop_tag(&data);
 153         asn1_pop_tag(&data);
 154
 155         if (data.has_error) {
 156                 DEBUG(2,("Failed to build cldap netlogon at offset %d\n", (int)data.ofs));
 157                 asn1_free(&data);
 158                 return -1;
 159         }
 160
 161         if (write(sock, data.data, data.length) != (ssize_t)data.length) {
 162                 DEBUG(2,("failed to send cldap query (%s)\n", strerror(errno)));
 163         }
 164
 165         asn1_free(&data);
 166
 167         return 0;
 168 }
 169
 170 static SIG_ATOMIC_T gotalarm;
 171
 172 /***************************************************************
 173  Signal function to tell us we timed out.
 174 ****************************************************************/
 175
 176 static void gotalarm_sig(void)
 177 {
 178         gotalarm = 1;
 179 }
 180
 181 /*
 182   receive a cldap netlogon reply
 183 */
 184 static int recv_cldap_netlogon(int sock, struct cldap_netlogon_reply *reply)
 185 {
 186         int ret;
 187         ASN1_DATA data;
 188         DATA_BLOB blob;
 189         DATA_BLOB os1, os2, os3;
 190         int i1;
 191         char *p;
 192
 193         blob = data_blob(NULL, 8192);
 194         if (blob.data == NULL) {
 195                 DEBUG(1, ("data_blob failed\n"));
 196                 errno = ENOMEM;
 197                 return -1;
 198         }
 199
 200         /* Setup timeout */
 201         gotalarm = 0;
 202         CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
 203         alarm(lp_ldap_timeout());
 204         /* End setup timeout. */
 205
 206         ret = read(sock, blob.data, blob.length);
 207
 208         /* Teardown timeout. */
 209         CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
 210         alarm(0);
 211
 212         if (ret <= 0) {
 213                 DEBUG(1,("no reply received to cldap netlogon\n"));
 214                 data_blob_free(&blob);
 215                 return -1;
 216         }
 217         blob.length = ret;
 218
 219         asn1_load(&data, blob);
 220         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 221         asn1_read_Integer(&data, &i1);
 222         asn1_start_tag(&data, ASN1_APPLICATION(4));
 223         asn1_read_OctetString(&data, &os1);
 224         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 225         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 226         asn1_read_OctetString(&data, &os2);
 227         asn1_start_tag(&data, ASN1_SET);
 228         asn1_read_OctetString(&data, &os3);
 229         asn1_end_tag(&data);
 230         asn1_end_tag(&data);
 231         asn1_end_tag(&data);
 232         asn1_end_tag(&data);
 233         asn1_end_tag(&data);
 234
 235         if (data.has_error) {
 236                 data_blob_free(&blob);
 237                 asn1_free(&data);
 238                 DEBUG(1,("Failed to parse cldap reply\n"));
 239                 return -1;
 240         }
 241
 242         p = (char *)os3.data;
 243
 244         reply->type = IVAL(p, 0); p += 4;
 245         reply->flags = IVAL(p, 0); p += 4;
 246
 247         memcpy(&reply->guid.info, p, UUID_FLAT_SIZE);
 248         p += UUID_FLAT_SIZE;
 249
 250         p += pull_netlogon_string(reply->forest, p, (const char *)os3.data);
 251         p += pull_netlogon_string(reply->domain, p, (const char *)os3.data);
 252         p += pull_netlogon_string(reply->hostname, p, (const char *)os3.data);
 253         p += pull_netlogon_string(reply->netbios_domain, p, (const char *)os3.data);
 254         p += pull_netlogon_string(reply->netbios_hostname, p, (const char *)os3.data);
 255         p += pull_netlogon_string(reply->unk, p, (const char *)os3.data);
 256
 257         if (reply->type == SAMLOGON_AD_R) {
 258                 p += pull_netlogon_string(reply->user_name, p, (const char *)os3.data);
 259         } else {
 260                 *reply->user_name = 0;
 261         }
 262
 263         p += pull_netlogon_string(reply->server_site_name, p, (const char *)os3.data);
 264         p += pull_netlogon_string(reply->client_site_name, p, (const char *)os3.data);
 265
 266         reply->version = IVAL(p, 0);
 267         reply->lmnt_token = SVAL(p, 4);
 268         reply->lm20_token = SVAL(p, 6);
 269
 270         data_blob_free(&os1);
 271         data_blob_free(&os2);
 272         data_blob_free(&os3);
 273         data_blob_free(&blob);
 274
 275         asn1_free(&data);
 276
 277         return 0;
 278 }
 279
 280 /*******************************************************************
 281   do a cldap netlogon query.  Always 389/udp
 282 *******************************************************************/
 283
 284 BOOL ads_cldap_netlogon(const char *server, const char *realm,  struct cldap_netlogon_reply *reply)
 285 {
 286         int sock;
 287         int ret;
 288
 289         sock = open_udp_socket(server, LDAP_PORT );
 290         if (sock == -1) {
 291                 DEBUG(2,("ads_cldap_netlogon: Failed to open udp socket to %s\n",
 292                          server));
 293                 return False;
 294         }
 295
 296         ret = send_cldap_netlogon(sock, realm, global_myname(), 6);
 297         if (ret != 0) {
 298                 return False;
 299         }
 300         ret = recv_cldap_netlogon(sock, reply);
 301         close(sock);
 302
 303         if (ret == -1) {
 304                 return False;
 305         }
 306
 307         return True;
 308 }