dirmngr: Simplify truncation of long strings in debug code.
[gnupg.git] / dirmngr / ks-engine-ldap.c
1 /* ks-engine-ldap.c - talk to a LDAP keyserver
2  * Copyright (C) 2001, 2002, 2004, 2005, 2006
3  *               2007  Free Software Foundation, Inc.
4  * Copyright (C) 2015  g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <time.h>
26 #include <unistd.h>
27 #ifdef HAVE_GETOPT_H
28 # include <getopt.h>
29 #endif
30 #include <stdlib.h>
31 #include <errno.h>
32 #include <assert.h>
33
34 #ifdef _WIN32
35 # include <winsock2.h>
36 # include <winldap.h>
37 #else
38 # ifdef NEED_LBER_H
39 #  include <lber.h>
40 # endif
41 /* For OpenLDAP, to enable the API that we're using. */
42 # define LDAP_DEPRECATED 1
43 # include <ldap.h>
44 #endif
45
46 #include "dirmngr.h"
47 #include "misc.h"
48 #include "userids.h"
49 #include "ks-engine.h"
50 #include "ldap-parse-uri.h"
51
52 #ifndef HAVE_TIMEGM
53 time_t timegm(struct tm *tm);
54 #endif
55 \f
56 /* Convert an LDAP error to a GPG error.  */
57 static int
58 ldap_err_to_gpg_err (int code)
59 {
60   gpg_err_code_t ec;
61
62   switch (code)
63     {
64 #ifdef LDAP_X_CONNECTING
65     case LDAP_X_CONNECTING: ec = GPG_ERR_LDAP_X_CONNECTING; break;
66 #endif
67
68     case LDAP_REFERRAL_LIMIT_EXCEEDED: ec = GPG_ERR_LDAP_REFERRAL_LIMIT; break;
69     case LDAP_CLIENT_LOOP: ec = GPG_ERR_LDAP_CLIENT_LOOP; break;
70     case LDAP_NO_RESULTS_RETURNED: ec = GPG_ERR_LDAP_NO_RESULTS; break;
71     case LDAP_CONTROL_NOT_FOUND: ec = GPG_ERR_LDAP_CONTROL_NOT_FOUND; break;
72     case LDAP_NOT_SUPPORTED: ec = GPG_ERR_LDAP_NOT_SUPPORTED; break;
73     case LDAP_CONNECT_ERROR: ec = GPG_ERR_LDAP_CONNECT; break;
74     case LDAP_NO_MEMORY: ec = GPG_ERR_LDAP_NO_MEMORY; break;
75     case LDAP_PARAM_ERROR: ec = GPG_ERR_LDAP_PARAM; break;
76     case LDAP_USER_CANCELLED: ec = GPG_ERR_LDAP_USER_CANCELLED; break;
77     case LDAP_FILTER_ERROR: ec = GPG_ERR_LDAP_FILTER; break;
78     case LDAP_AUTH_UNKNOWN: ec = GPG_ERR_LDAP_AUTH_UNKNOWN; break;
79     case LDAP_TIMEOUT: ec = GPG_ERR_LDAP_TIMEOUT; break;
80     case LDAP_DECODING_ERROR: ec = GPG_ERR_LDAP_DECODING; break;
81     case LDAP_ENCODING_ERROR: ec = GPG_ERR_LDAP_ENCODING; break;
82     case LDAP_LOCAL_ERROR: ec = GPG_ERR_LDAP_LOCAL; break;
83     case LDAP_SERVER_DOWN: ec = GPG_ERR_LDAP_SERVER_DOWN; break;
84
85     case LDAP_SUCCESS: ec = GPG_ERR_LDAP_SUCCESS; break;
86
87     case LDAP_OPERATIONS_ERROR: ec = GPG_ERR_LDAP_OPERATIONS; break;
88     case LDAP_PROTOCOL_ERROR: ec = GPG_ERR_LDAP_PROTOCOL; break;
89     case LDAP_TIMELIMIT_EXCEEDED: ec = GPG_ERR_LDAP_TIMELIMIT; break;
90     case LDAP_SIZELIMIT_EXCEEDED: ec = GPG_ERR_LDAP_SIZELIMIT; break;
91     case LDAP_COMPARE_FALSE: ec = GPG_ERR_LDAP_COMPARE_FALSE; break;
92     case LDAP_COMPARE_TRUE: ec = GPG_ERR_LDAP_COMPARE_TRUE; break;
93     case LDAP_AUTH_METHOD_NOT_SUPPORTED: ec=GPG_ERR_LDAP_UNSUPPORTED_AUTH;break;
94     case LDAP_STRONG_AUTH_REQUIRED: ec = GPG_ERR_LDAP_STRONG_AUTH_RQRD; break;
95     case LDAP_PARTIAL_RESULTS: ec = GPG_ERR_LDAP_PARTIAL_RESULTS; break;
96     case LDAP_REFERRAL: ec = GPG_ERR_LDAP_REFERRAL; break;
97
98 #ifdef LDAP_ADMINLIMIT_EXCEEDED
99     case LDAP_ADMINLIMIT_EXCEEDED: ec = GPG_ERR_LDAP_ADMINLIMIT; break;
100 #endif
101
102 #ifdef LDAP_UNAVAILABLE_CRITICAL_EXTENSION
103     case LDAP_UNAVAILABLE_CRITICAL_EXTENSION:
104                                ec = GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN; break;
105 #endif
106
107     case LDAP_CONFIDENTIALITY_REQUIRED: ec = GPG_ERR_LDAP_CONFIDENT_RQRD; break;
108     case LDAP_SASL_BIND_IN_PROGRESS: ec = GPG_ERR_LDAP_SASL_BIND_INPROG; break;
109     case LDAP_NO_SUCH_ATTRIBUTE: ec = GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE; break;
110     case LDAP_UNDEFINED_TYPE: ec = GPG_ERR_LDAP_UNDEFINED_TYPE; break;
111     case LDAP_INAPPROPRIATE_MATCHING: ec = GPG_ERR_LDAP_BAD_MATCHING; break;
112     case LDAP_CONSTRAINT_VIOLATION: ec = GPG_ERR_LDAP_CONST_VIOLATION; break;
113
114 #ifdef LDAP_TYPE_OR_VALUE_EXISTS
115     case LDAP_TYPE_OR_VALUE_EXISTS: ec = GPG_ERR_LDAP_TYPE_VALUE_EXISTS; break;
116 #endif
117
118     case LDAP_INVALID_SYNTAX: ec = GPG_ERR_LDAP_INV_SYNTAX; break;
119     case LDAP_NO_SUCH_OBJECT: ec = GPG_ERR_LDAP_NO_SUCH_OBJ; break;
120     case LDAP_ALIAS_PROBLEM: ec = GPG_ERR_LDAP_ALIAS_PROBLEM; break;
121     case LDAP_INVALID_DN_SYNTAX: ec = GPG_ERR_LDAP_INV_DN_SYNTAX; break;
122     case LDAP_IS_LEAF: ec = GPG_ERR_LDAP_IS_LEAF; break;
123     case LDAP_ALIAS_DEREF_PROBLEM: ec = GPG_ERR_LDAP_ALIAS_DEREF; break;
124
125 #ifdef LDAP_X_PROXY_AUTHZ_FAILURE
126     case LDAP_X_PROXY_AUTHZ_FAILURE: ec = GPG_ERR_LDAP_X_PROXY_AUTH_FAIL; break;
127 #endif
128
129     case LDAP_INAPPROPRIATE_AUTH: ec = GPG_ERR_LDAP_BAD_AUTH; break;
130     case LDAP_INVALID_CREDENTIALS: ec = GPG_ERR_LDAP_INV_CREDENTIALS; break;
131
132 #ifdef LDAP_INSUFFICIENT_ACCESS
133     case LDAP_INSUFFICIENT_ACCESS: ec = GPG_ERR_LDAP_INSUFFICIENT_ACC; break;
134 #endif
135
136     case LDAP_BUSY: ec = GPG_ERR_LDAP_BUSY; break;
137     case LDAP_UNAVAILABLE: ec = GPG_ERR_LDAP_UNAVAILABLE; break;
138     case LDAP_UNWILLING_TO_PERFORM: ec = GPG_ERR_LDAP_UNWILL_TO_PERFORM; break;
139     case LDAP_LOOP_DETECT: ec = GPG_ERR_LDAP_LOOP_DETECT; break;
140     case LDAP_NAMING_VIOLATION: ec = GPG_ERR_LDAP_NAMING_VIOLATION; break;
141     case LDAP_OBJECT_CLASS_VIOLATION: ec = GPG_ERR_LDAP_OBJ_CLS_VIOLATION; break;
142     case LDAP_NOT_ALLOWED_ON_NONLEAF: ec=GPG_ERR_LDAP_NOT_ALLOW_NONLEAF;break;
143     case LDAP_NOT_ALLOWED_ON_RDN: ec = GPG_ERR_LDAP_NOT_ALLOW_ON_RDN; break;
144     case LDAP_ALREADY_EXISTS: ec = GPG_ERR_LDAP_ALREADY_EXISTS; break;
145     case LDAP_NO_OBJECT_CLASS_MODS: ec = GPG_ERR_LDAP_NO_OBJ_CLASS_MODS; break;
146     case LDAP_RESULTS_TOO_LARGE: ec = GPG_ERR_LDAP_RESULTS_TOO_LARGE; break;
147     case LDAP_AFFECTS_MULTIPLE_DSAS: ec = GPG_ERR_LDAP_AFFECTS_MULT_DSAS; break;
148
149 #ifdef LDAP_VLV_ERROR
150     case LDAP_VLV_ERROR: ec = GPG_ERR_LDAP_VLV; break;
151 #endif
152
153     case LDAP_OTHER: ec = GPG_ERR_LDAP_OTHER; break;
154
155 #ifdef LDAP_CUP_RESOURCES_EXHAUSTED
156     case LDAP_CUP_RESOURCES_EXHAUSTED: ec=GPG_ERR_LDAP_CUP_RESOURCE_LIMIT;break;
157     case LDAP_CUP_SECURITY_VIOLATION: ec=GPG_ERR_LDAP_CUP_SEC_VIOLATION; break;
158     case LDAP_CUP_INVALID_DATA: ec = GPG_ERR_LDAP_CUP_INV_DATA; break;
159     case LDAP_CUP_UNSUPPORTED_SCHEME: ec = GPG_ERR_LDAP_CUP_UNSUP_SCHEME; break;
160     case LDAP_CUP_RELOAD_REQUIRED: ec = GPG_ERR_LDAP_CUP_RELOAD; break;
161 #endif
162
163 #ifdef LDAP_CANCELLED
164     case LDAP_CANCELLED: ec = GPG_ERR_LDAP_CANCELLED; break;
165 #endif
166
167 #ifdef LDAP_NO_SUCH_OPERATION
168     case LDAP_NO_SUCH_OPERATION: ec = GPG_ERR_LDAP_NO_SUCH_OPERATION; break;
169 #endif
170
171 #ifdef LDAP_TOO_LATE
172     case LDAP_TOO_LATE: ec = GPG_ERR_LDAP_TOO_LATE; break;
173 #endif
174
175 #ifdef LDAP_CANNOT_CANCEL
176     case LDAP_CANNOT_CANCEL: ec = GPG_ERR_LDAP_CANNOT_CANCEL; break;
177 #endif
178
179 #ifdef LDAP_ASSERTION_FAILED
180     case LDAP_ASSERTION_FAILED: ec = GPG_ERR_LDAP_ASSERTION_FAILED; break;
181 #endif
182
183 #ifdef LDAP_PROXIED_AUTHORIZATION_DENIED
184     case LDAP_PROXIED_AUTHORIZATION_DENIED:
185                                       ec = GPG_ERR_LDAP_PROX_AUTH_DENIED; break;
186 #endif
187
188     default:
189 #if defined(LDAP_E_ERROR) && defined(LDAP_X_ERROR)
190       if (LDAP_E_ERROR (code))
191         ec = GPG_ERR_LDAP_E_GENERAL;
192       else if (LDAP_X_ERROR (code))
193         ec = GPG_ERR_LDAP_X_GENERAL;
194       else
195 #endif
196         ec = GPG_ERR_LDAP_GENERAL;
197       break;
198     }
199
200   return ec;
201 }
202
203 /* Retrieve an LDAP error and return it's GPG equivalent.  */
204 static int
205 ldap_to_gpg_err (LDAP *ld)
206 {
207 #if defined(HAVE_LDAP_GET_OPTION) && defined(LDAP_OPT_ERROR_NUMBER)
208   int err;
209
210   if (ldap_get_option (ld, LDAP_OPT_ERROR_NUMBER, &err) == 0)
211     return ldap_err_to_gpg_err (err);
212   else
213     return GPG_ERR_GENERAL;
214 #elif defined(HAVE_LDAP_LD_ERRNO)
215   return ldap_err_to_gpg_err (ld->ld_errno);
216 #else
217   /* We should never get here since the LDAP library should always
218      have either ldap_get_option or ld_errno, but just in case... */
219   return GPG_ERR_INTERNAL;
220 #endif
221 }
222 \f
223 static time_t
224 ldap2epochtime (const char *timestr)
225 {
226   struct tm pgptime;
227   time_t answer;
228
229   memset (&pgptime, 0, sizeof(pgptime));
230
231   /* YYYYMMDDHHmmssZ */
232
233   sscanf (timestr, "%4d%2d%2d%2d%2d%2d",
234           &pgptime.tm_year,
235           &pgptime.tm_mon,
236           &pgptime.tm_mday,
237           &pgptime.tm_hour,
238           &pgptime.tm_min,
239           &pgptime.tm_sec);
240
241   pgptime.tm_year -= 1900;
242   pgptime.tm_isdst = -1;
243   pgptime.tm_mon--;
244
245   /* mktime() takes the timezone into account, so we use timegm() */
246
247   answer = timegm (&pgptime);
248
249   return answer;
250 }
251
252 /* Caller must free the result.  */
253 static char *
254 tm2ldaptime (struct tm *tm)
255 {
256   struct tm tmp = *tm;
257   char buf[16];
258
259   /* YYYYMMDDHHmmssZ */
260
261   tmp.tm_year += 1900;
262   tmp.tm_mon ++;
263
264   snprintf (buf, sizeof buf, "%04d%02d%02d%02d%02d%02dZ",
265            tmp.tm_year,
266            tmp.tm_mon,
267            tmp.tm_mday,
268            tmp.tm_hour,
269            tmp.tm_min,
270            tmp.tm_sec);
271
272   return xstrdup (buf);
273 }
274
275 #if 0
276 /* Caller must free */
277 static char *
278 epoch2ldaptime (time_t stamp)
279 {
280   struct tm tm;
281   if (gmtime_r (&stamp, &tm))
282     return tm2ldaptime (&tm);
283   else
284     return xstrdup ("INVALID TIME");
285 }
286 #endif
287 \f
288 /* Print a help output for the schemata supported by this module. */
289 gpg_error_t
290 ks_ldap_help (ctrl_t ctrl, parsed_uri_t uri)
291 {
292   const char const data[] =
293     "Handler for LDAP URLs:\n"
294     "  ldap://host:port/[BASEDN]???[bindname=BINDNAME,password=PASSWORD]\n"
295     "\n"
296     "Note: basedn, bindname and password need to be percent escaped. In\n"
297     "particular, spaces need to be replaced with %20 and commas with %2c.\n"
298     "bindname will typically be of the form:\n"
299     "\n"
300     "  uid=user%2cou=PGP%20Users%2cdc=EXAMPLE%2cdc=ORG\n"
301     "\n"
302     "The ldaps:// and ldapi:// schemes are also supported.  If ldaps is used\n"
303     "then the server's certificate will be checked.  If it is not valid, any\n"
304     "operation will be aborted.\n"
305     "\n"
306     "Supported methods: search, get, put\n";
307   gpg_error_t err;
308
309   if (strcmp (uri->scheme, "ldap") == 0
310       || strcmp (uri->scheme, "ldaps") == 0
311       || strcmp (uri->scheme, "ldapi") == 0)
312     err = ks_print_help (ctrl, data);
313   else
314     err = 0;
315
316   return err;
317 }
318 \f
319 /* Convert a keyspec to a filter.  Return an error if the keyspec is
320    bad or is not supported.  The filter is escaped and returned in
321    *filter.  It is the caller's responsibility to free *filter.
322    *filter is only set if this function returns success (i.e., 0).  */
323 static gpg_error_t
324 keyspec_to_ldap_filter (const char *keyspec, char **filter, int only_exact)
325 {
326   /* Remove search type indicator and adjust PATTERN accordingly.
327      Note: don't include a preceding 0x when searching by keyid.  */
328
329   /* XXX: Should we include disabled / revoke options?  */
330   KEYDB_SEARCH_DESC desc;
331   char *f = NULL;
332   char *freeme = NULL;
333
334   gpg_error_t err = classify_user_id (keyspec, &desc, 1);
335   if (err)
336     return err;
337
338   switch (desc.mode)
339     {
340     case KEYDB_SEARCH_MODE_EXACT:
341       f = xasprintf ("(pgpUserID=%s)",
342                      (freeme = ldap_escape_filter (desc.u.name)));
343       break;
344
345     case KEYDB_SEARCH_MODE_SUBSTR:
346       if (! only_exact)
347         f = xasprintf ("(pgpUserID=*%s*)",
348                        (freeme = ldap_escape_filter (desc.u.name)));
349       break;
350
351     case KEYDB_SEARCH_MODE_MAIL:
352       if (! only_exact)
353         f = xasprintf ("(pgpUserID=*<%s>*)",
354                        (freeme = ldap_escape_filter (desc.u.name)));
355       break;
356
357     case KEYDB_SEARCH_MODE_MAILSUB:
358       if (! only_exact)
359         f = xasprintf ("(pgpUserID=*<*%s*>*)",
360                        (freeme = ldap_escape_filter (desc.u.name)));
361       break;
362
363     case KEYDB_SEARCH_MODE_MAILEND:
364       if (! only_exact)
365         f = xasprintf ("(pgpUserID=*<*%s>*)",
366                        (freeme = ldap_escape_filter (desc.u.name)));
367       break;
368
369     case KEYDB_SEARCH_MODE_SHORT_KID:
370       f = xasprintf ("(pgpKeyID=%08lX)", (ulong) desc.u.kid[1]);
371       break;
372     case KEYDB_SEARCH_MODE_LONG_KID:
373       f = xasprintf ("(pgpCertID=%08lX%08lX)",
374                      (ulong) desc.u.kid[0], (ulong) desc.u.kid[1]);
375       break;
376
377     case KEYDB_SEARCH_MODE_FPR16:
378     case KEYDB_SEARCH_MODE_FPR20:
379     case KEYDB_SEARCH_MODE_FPR:
380     case KEYDB_SEARCH_MODE_ISSUER:
381     case KEYDB_SEARCH_MODE_ISSUER_SN:
382     case KEYDB_SEARCH_MODE_SN:
383     case KEYDB_SEARCH_MODE_SUBJECT:
384     case KEYDB_SEARCH_MODE_KEYGRIP:
385     case KEYDB_SEARCH_MODE_WORDS:
386     case KEYDB_SEARCH_MODE_FIRST:
387     case KEYDB_SEARCH_MODE_NEXT:
388     default:
389       break;
390     }
391
392   xfree (freeme);
393
394   if (! f)
395     {
396       log_error ("Unsupported search mode.\n");
397       return gpg_error (GPG_ERR_NOT_SUPPORTED);
398     }
399
400   *filter = f;
401
402   return 0;
403 }
404
405
406 \f
407 /* Connect to an LDAP server and interrogate it.
408
409      - uri describes the server to connect to and various options
410        including whether to use TLS and the username and password (see
411        ldap_parse_uri for a description of the various fields).
412
413    This function returns:
414
415      - The ldap connection handle in *LDAP_CONNP.
416
417      - The base DN for the PGP key space by querying the
418        pgpBaseKeySpaceDN attribute (This is normally
419        'ou=PGP Keys,dc=EXAMPLE,dc=ORG').
420
421      - The attribute to lookup to find the pgp key.  This is either
422        'pgpKey' or 'pgpKeyV2'.
423
424      - Whether this is a real ldap server.  (It's unclear what this
425        exactly means.)
426
427    The values are returned in the passed variables.  If you pass NULL,
428    then the value won't be returned.  It is the caller's
429    responsibility to release *LDAP_CONNP with ldap_unbind and xfree
430    *BASEDNP and *PGPKEYATTRP.
431
432    If this function successfully interrogated the server, it returns
433    0.  If there was an LDAP error, it returns the LDAP error code.  If
434    an error occured, *basednp, etc., are undefined (and don't need to
435    be freed.)
436
437    If no LDAP error occured, you still need to check that *basednp is
438    valid.  If it is NULL, then the server does not appear to be an
439    OpenPGP Keyserver.  In this case, you also do not need to xfree
440    *pgpkeyattrp.  */
441 static int
442 ldap_connect (parsed_uri_t uri, LDAP **ldap_connp,
443               char **basednp, char **pgpkeyattrp, int *real_ldapp)
444 {
445   int err = 0;
446
447   LDAP *ldap_conn = NULL;
448
449   char *user = uri->auth;
450   struct uri_tuple_s *password_param = uri_query_lookup (uri, "password");
451   char *password = password_param ? password_param->value : NULL;
452
453   char *basedn = NULL;
454   /* Whether to look for the pgpKey or pgpKeyv2 attribute.  */
455   char *pgpkeyattr = "pgpKey";
456   int real_ldap = 0;
457
458   log_debug ("ldap_connect(%s:%d/%s????%s%s%s%s%s)\n",
459              uri->host, uri->port,
460              uri->path ?: "",
461              uri->auth ? "bindname=" : "", uri->auth ?: "",
462              uri->auth && password ? "," : "",
463              password ? "password=" : "", password ?: "");
464
465   /* If the uri specifies a secure connection and we don't support
466      TLS, then fail; don't silently revert to an insecure
467      connection.  */
468   if (uri->use_tls)
469     {
470 #ifndef HAVE_LDAP_START_TLS_S
471       log_error ("Can't use LDAP to connect to the server: no TLS support.");
472       err = GPG_ERR_LDAP_NOT_SUPPORTED;
473       goto out;
474 #endif
475     }
476
477   ldap_conn = ldap_init (uri->host, uri->port);
478   if (! ldap_conn)
479     {
480       err = gpg_err_code_from_syserror ();
481       log_error ("Failed to open connection to LDAP server (%s://%s:%d)\n",
482                  uri->scheme, uri->host, uri->port);
483       goto out;
484     }
485
486 #ifdef HAVE_LDAP_SET_OPTION
487   {
488     int ver = LDAP_VERSION3;
489
490     err = ldap_set_option (ldap_conn, LDAP_OPT_PROTOCOL_VERSION, &ver);
491     if (err != LDAP_SUCCESS)
492       {
493         log_error ("gpgkeys: unable to go to LDAP 3: %s\n",
494                    ldap_err2string (err));
495         goto out;
496       }
497   }
498 #endif
499
500   /* XXX: It would be nice to have an option to provide the server's
501      certificate.  */
502 #if 0
503 #if defined(LDAP_OPT_X_TLS_CACERTFILE) && defined(HAVE_LDAP_SET_OPTION)
504   err = ldap_set_option (NULL, LDAP_OPT_X_TLS_CACERTFILE, ca_cert_file);
505   if (err)
506     {
507       log_error ("unable to set ca-cert-file to '%s': %s\n",
508                  ca_cert_file, ldap_err2string (err));
509       goto out;
510     }
511 #endif /* LDAP_OPT_X_TLS_CACERTFILE && HAVE_LDAP_SET_OPTION */
512 #endif
513
514 #ifndef HAVE_LDAP_START_TLS_S
515   if (uri->use_tls)
516     {
517       /* XXX: We need an option to determine whether to abort if the
518          certificate is bad or not.  Right now we conservatively
519          default to checking the certificate and aborting.  */
520       int check_cert = LDAP_OPT_X_TLS_HARD; /* LDAP_OPT_X_TLS_NEVER */
521
522       err = ldap_set_option (ldap_conn,
523                              LDAP_OPT_X_TLS_REQUIRE_CERT, &check_cert);
524       if (err)
525         {
526           log_error ("Failed to set TLS option on LDAP connection.\n");
527           goto out;
528         }
529
530       err = ldap_start_tls_s (ldap_conn, NULL, NULL);
531       if (err)
532         {
533           log_error ("Failed to connect to LDAP server with TLS.\n");
534           goto out;
535         }
536     }
537 #endif
538
539   /* By default we don't bind as there is usually no need to.  */
540   if (uri->auth)
541     {
542       log_debug ("LDAP bind to %s, password %s\n",
543                  user, password ? ">not shown<" : ">none<");
544
545       err = ldap_simple_bind_s (ldap_conn, user, password);
546       if (err != LDAP_SUCCESS)
547         {
548           log_error ("Internal LDAP bind error: %s\n",
549                      ldap_err2string (err));
550           goto out;
551         }
552     }
553
554   if (uri->path && *uri->path)
555     /* User specified base DN.  */
556     {
557       basedn = xstrdup (uri->path);
558
559       /* If the user specifies a base DN, then we know the server is a
560          real LDAP server.  */
561       real_ldap = 1;
562     }
563   else
564     {
565       LDAPMessage *res = NULL;
566       /* Look for namingContexts.  */
567       char *attr[] = { "namingContexts", NULL };
568
569       err = ldap_search_s (ldap_conn, "", LDAP_SCOPE_BASE,
570                            "(objectClass=*)", attr, 0, &res);
571       if (err == LDAP_SUCCESS)
572         {
573           char **context = ldap_get_values (ldap_conn, res, "namingContexts");
574           if (context)
575             /* We found some, so try each namingContext as the search
576                base and look for pgpBaseKeySpaceDN.  Because we found
577                this, we know we're talking to a regular-ish LDAP
578                server and not an LDAP keyserver.  */
579             {
580               int i;
581               char *attr2[] =
582                 { "pgpBaseKeySpaceDN", "pgpVersion", "pgpSoftware", NULL };
583
584               real_ldap = 1;
585
586               for (i = 0; context[i] && ! basedn; i++)
587                 {
588                   char **vals;
589                   LDAPMessage *si_res;
590
591                   {
592                     char *object = xasprintf ("cn=pgpServerInfo,%s",
593                                               context[i]);
594                     err = ldap_search_s (ldap_conn, object, LDAP_SCOPE_BASE,
595                                          "(objectClass=*)", attr2, 0, &si_res);
596                     xfree (object);
597                   }
598
599                   if (err == LDAP_SUCCESS)
600                     {
601                       vals = ldap_get_values (ldap_conn, si_res,
602                                               "pgpBaseKeySpaceDN");
603                       if (vals)
604                         {
605                           basedn = xtrystrdup (vals[0]);
606                           ldap_value_free (vals);
607                         }
608
609                       vals = ldap_get_values (ldap_conn, si_res,
610                                               "pgpSoftware");
611                       if (vals)
612                         {
613                           log_debug ("Server: \t%s\n", vals[0]);
614                           ldap_value_free (vals);
615                         }
616
617                       vals = ldap_get_values (ldap_conn, si_res,
618                                               "pgpVersion");
619                       if (vals)
620                         {
621                           log_debug ("Version:\t%s\n", vals[0]);
622                           ldap_value_free (vals);
623                         }
624                     }
625
626                   /* From man ldap_search_s: "res parameter of
627                      ldap_search_ext_s() and ldap_search_s() should be
628                      freed with ldap_msgfree() regardless of return
629                      value of these functions.  */
630                   ldap_msgfree (si_res);
631                 }
632
633               ldap_value_free (context);
634             }
635         }
636       else
637         {
638           /* We don't have an answer yet, which means the server might
639              be an LDAP keyserver. */
640           char **vals;
641           LDAPMessage *si_res = NULL;
642
643           char *attr2[] = { "pgpBaseKeySpaceDN", "version", "software", NULL };
644
645           err = ldap_search_s (ldap_conn, "cn=pgpServerInfo", LDAP_SCOPE_BASE,
646                                "(objectClass=*)", attr2, 0, &si_res);
647           if (err == LDAP_SUCCESS)
648             {
649               /* For the LDAP keyserver, this is always
650                  "OU=ACTIVE,O=PGP KEYSPACE,C=US", but it might not be
651                  in the future. */
652
653               vals = ldap_get_values (ldap_conn, si_res, "baseKeySpaceDN");
654               if (vals)
655                 {
656                   basedn = xtrystrdup (vals[0]);
657                   ldap_value_free (vals);
658                 }
659
660               vals = ldap_get_values (ldap_conn, si_res, "software");
661               if (vals)
662                 {
663                   log_debug ("ldap: Server: \t%s\n", vals[0]);
664                   ldap_value_free (vals);
665                 }
666
667               vals = ldap_get_values (ldap_conn, si_res, "version");
668               if (vals)
669                 {
670                   log_debug ("ldap: Version:\t%s\n", vals[0]);
671
672                   /* If the version is high enough, use the new
673                      pgpKeyV2 attribute.  This design is iffy at best,
674                      but it matches how PGP does it.  I figure the NAI
675                      folks assumed that there would never be an LDAP
676                      keyserver vendor with a different numbering
677                      scheme. */
678                   if (atoi (vals[0]) > 1)
679                     pgpkeyattr = "pgpKeyV2";
680
681                   ldap_value_free (vals);
682                 }
683             }
684
685           ldap_msgfree (si_res);
686         }
687
688       /* From man ldap_search_s: "res parameter of ldap_search_ext_s()
689          and ldap_search_s() should be freed with ldap_msgfree()
690          regardless of return value of these functions.  */
691       ldap_msgfree (res);
692     }
693
694  out:
695   if (! err)
696     {
697       log_debug ("ldap_conn: %p\n", ldap_conn);
698       log_debug ("real_ldap: %d\n", real_ldap);
699       log_debug ("basedn: %s\n", basedn);
700       log_debug ("pgpkeyattr: %s\n", pgpkeyattr);
701     }
702
703   if (! err && real_ldapp)
704     *real_ldapp = real_ldap;
705
706   if (err)
707     xfree (basedn);
708   else
709     {
710       if (pgpkeyattrp)
711         {
712           if (basedn)
713             *pgpkeyattrp = xstrdup (pgpkeyattr);
714           else
715             *pgpkeyattrp = NULL;
716         }
717
718       if (basednp)
719         *basednp = basedn;
720       else
721         xfree (basedn);
722     }
723
724   if (err)
725     {
726       if (ldap_conn)
727         ldap_unbind (ldap_conn);
728     }
729   else
730     *ldap_connp = ldap_conn;
731
732   return err;
733 }
734
735 /* Extract keys from an LDAP reply and write them out to the output
736    stream OUTPUT in a format GnuPG can import (either the OpenPGP
737    binary format or armored format).  */
738 static void
739 extract_keys (estream_t output,
740               LDAP *ldap_conn, const char *certid, LDAPMessage *message)
741 {
742   char **vals;
743
744   es_fprintf (output, "INFO %s BEGIN\n", certid);
745   es_fprintf (output, "pub:%s:", certid);
746
747   /* Note: ldap_get_values returns a NULL terminates array of
748      strings.  */
749   vals = ldap_get_values (ldap_conn, message, "pgpkeytype");
750   if (vals && vals[0])
751     {
752       if (strcmp (vals[0], "RSA") == 0)
753         es_fprintf  (output, "1");
754       else if (strcmp (vals[0],"DSS/DH") == 0)
755         es_fprintf (output, "17");
756       ldap_value_free (vals);
757     }
758
759   es_fprintf (output, ":");
760
761   vals = ldap_get_values (ldap_conn, message, "pgpkeysize");
762   if (vals && vals[0])
763     {
764       int v = atoi (vals[0]);
765       if (v > 0)
766         es_fprintf (output, "%d", v);
767       ldap_value_free (vals);
768     }
769
770   es_fprintf (output, ":");
771
772   vals = ldap_get_values (ldap_conn, message, "pgpkeycreatetime");
773   if (vals && vals[0])
774     {
775       if (strlen (vals[0]) == 15)
776         es_fprintf (output, "%u", (unsigned int) ldap2epochtime (vals[0]));
777       ldap_value_free (vals);
778     }
779
780   es_fprintf (output, ":");
781
782   vals = ldap_get_values (ldap_conn, message, "pgpkeyexpiretime");
783   if (vals && vals[0])
784     {
785       if (strlen (vals[0]) == 15)
786         es_fprintf (output, "%u", (unsigned int) ldap2epochtime (vals[0]));
787       ldap_value_free (vals);
788     }
789
790   es_fprintf (output, ":");
791
792   vals = ldap_get_values (ldap_conn, message, "pgprevoked");
793   if (vals && vals[0])
794     {
795       if (atoi (vals[0]) == 1)
796         es_fprintf (output, "r");
797       ldap_value_free (vals);
798     }
799
800   es_fprintf (output, "\n");
801
802   vals = ldap_get_values (ldap_conn, message, "pgpuserid");
803   if (vals && vals[0])
804     {
805       int i;
806       for (i = 0; vals[i]; i++)
807         es_fprintf (output, "uid:%s\n", vals[i]);
808       ldap_value_free (vals);
809     }
810
811   es_fprintf (output, "INFO %s END\n", certid);
812 }
813
814 /* Get the key described key the KEYSPEC string from the keyserver
815    identified by URI.  On success R_FP has an open stream to read the
816    data.  */
817 gpg_error_t
818 ks_ldap_get (ctrl_t ctrl, parsed_uri_t uri, const char *keyspec,
819              estream_t *r_fp)
820 {
821   gpg_error_t err = 0;
822   int ldap_err;
823
824   char *filter = NULL;
825
826   LDAP *ldap_conn = NULL;
827
828   char *basedn = NULL;
829   char *pgpkeyattr = NULL;
830
831   estream_t fp = NULL;
832
833   LDAPMessage *message = NULL;
834
835   (void) ctrl;
836
837   /* Before connecting to the server, make sure we have a sane
838      keyspec.  If not, there is no need to establish a network
839      connection.  */
840   err = keyspec_to_ldap_filter (keyspec, &filter, 1);
841   if (err)
842     return (err);
843
844   /* Make sure we are talking to an OpenPGP LDAP server.  */
845   ldap_err = ldap_connect (uri, &ldap_conn, &basedn, &pgpkeyattr, NULL);
846   if (ldap_err || !basedn)
847     {
848       if (ldap_err)
849         err = ldap_err_to_gpg_err (ldap_err);
850       else
851         err = GPG_ERR_GENERAL;
852       goto out;
853     }
854
855   {
856     /* The ordering is significant.  Specifically, "pgpcertid" needs
857        to be the second item in the list, since everything after it
858        may be discarded we aren't in verbose mode. */
859     char *attrs[] =
860       {
861         pgpkeyattr,
862         "pgpcertid", "pgpuserid", "pgpkeyid", "pgprevoked", "pgpdisabled",
863         "pgpkeycreatetime", "modifytimestamp", "pgpkeysize", "pgpkeytype",
864         NULL
865       };
866     /* 1 if we want just attribute types; 0 if we want both attribute
867        types and values.  */
868     int attrsonly = 0;
869
870     int count;
871
872     ldap_err = ldap_search_s (ldap_conn, basedn, LDAP_SCOPE_SUBTREE,
873                               filter, attrs, attrsonly, &message);
874     if (ldap_err)
875       {
876         err = ldap_err_to_gpg_err (ldap_err);
877
878         log_error ("gpgkeys: LDAP search error: %s\n",
879                    ldap_err2string (ldap_err));
880         goto out;
881       }
882
883     count = ldap_count_entries (ldap_conn, message);
884     if (count < 1)
885       {
886         log_error ("gpgkeys: key %s not found on keyserver\n", keyspec);
887
888         if (count == -1)
889           err = ldap_to_gpg_err (ldap_conn);
890         else
891           err = gpg_error (GPG_ERR_NO_DATA);
892
893         goto out;
894       }
895
896     {
897       /* There may be more than one unique result for a given keyID,
898          so we should fetch them all (test this by fetching short key
899          id 0xDEADBEEF). */
900
901       /* The set of entries that we've seen.  */
902       strlist_t seen = NULL;
903       LDAPMessage *each;
904
905       for (each = ldap_first_entry (ldap_conn, message);
906            each;
907            each = ldap_next_entry (ldap_conn, each))
908         {
909           char **vals;
910           char **certid;
911
912           /* Use the long keyid to remove duplicates.  The LDAP
913              server returns the same keyid more than once if there
914              are multiple user IDs on the key.  Note that this does
915              NOT mean that a keyid that exists multiple times on the
916              keyserver will not be fetched.  It means that each KEY,
917              no matter how many user IDs share its keyid, will be
918              fetched only once.  If a keyid that belongs to more
919              than one key is fetched, the server quite properly
920              responds with all matching keys. -ds */
921
922           certid = ldap_get_values (ldap_conn, each, "pgpcertid");
923           if (certid && certid[0])
924             {
925               if (! strlist_find (seen, certid[0]))
926                 {
927                   /* It's not a duplicate, add it */
928
929                   add_to_strlist (&seen, certid[0]);
930
931                   if (! fp)
932                     fp = es_fopenmem(0, "rw");
933
934                   extract_keys (fp, ldap_conn, certid[0], each);
935
936                   vals = ldap_get_values (ldap_conn, each, pgpkeyattr);
937                   if (! vals)
938                     {
939                       err = ldap_to_gpg_err (ldap_conn);
940                       log_error("gpgkeys: unable to retrieve key %s "
941                                 "from keyserver\n", certid[0]);
942                       goto out;
943                     }
944                   else
945                     {
946                       /* We should strip the new lines.  */
947                       es_fprintf (fp, "KEY 0x%s BEGIN\n", certid[0]);
948                       es_fputs (vals[0], fp);
949                       es_fprintf (fp, "\nKEY 0x%s END\n", certid[0]);
950
951                       ldap_value_free (vals);
952                     }
953                 }
954             }
955
956           ldap_value_free (certid);
957         }
958
959       free_strlist (seen);
960
961       if (! fp)
962         err = gpg_error (GPG_ERR_NO_DATA);
963     }
964   }
965
966  out:
967   if (message)
968     ldap_msgfree (message);
969
970   if (err)
971     {
972       if (fp)
973         es_fclose (fp);
974     }
975   else
976     {
977       if (fp)
978         es_fseek (fp, 0, SEEK_SET);
979
980       *r_fp = fp;
981     }
982
983   xfree (pgpkeyattr);
984   xfree (basedn);
985
986   if (ldap_conn)
987     ldap_unbind (ldap_conn);
988
989   xfree (filter);
990
991   return err;
992 }
993
994 /* Search the keyserver identified by URI for keys matching PATTERN.
995    On success R_FP has an open stream to read the data.  */
996 gpg_error_t
997 ks_ldap_search (ctrl_t ctrl, parsed_uri_t uri, const char *pattern,
998                 estream_t *r_fp)
999 {
1000   gpg_error_t err;
1001   int ldap_err;
1002
1003   char *filter = NULL;
1004
1005   LDAP *ldap_conn = NULL;
1006
1007   char *basedn = NULL;
1008
1009   estream_t fp = NULL;
1010
1011   (void) ctrl;
1012
1013   /* Before connecting to the server, make sure we have a sane
1014      keyspec.  If not, there is no need to establish a network
1015      connection.  */
1016   err = keyspec_to_ldap_filter (pattern, &filter, 0);
1017   if (err)
1018     {
1019       log_error ("Bad search pattern: '%s'\n", pattern);
1020       return (err);
1021     }
1022
1023   /* Make sure we are talking to an OpenPGP LDAP server.  */
1024   ldap_err = ldap_connect (uri, &ldap_conn, &basedn, NULL, NULL);
1025   if (ldap_err || !basedn)
1026     {
1027       if (ldap_err)
1028         err = ldap_err_to_gpg_err (ldap_err);
1029       else
1030         err = GPG_ERR_GENERAL;
1031       goto out;
1032     }
1033
1034   /* Even if we have no results, we want to return a stream.  */
1035   fp = es_fopenmem(0, "rw");
1036   if (!fp)
1037     {
1038       err = gpg_error_from_syserror ();
1039       goto out;
1040     }
1041
1042   {
1043     char **vals;
1044     LDAPMessage *res, *each;
1045     int count = 0;
1046     strlist_t dupelist = NULL;
1047
1048     /* The maximum size of the search, including the optional stuff
1049        and the trailing \0 */
1050     char *attrs[] =
1051       {
1052         "pgpcertid", "pgpuserid", "pgprevoked", "pgpdisabled",
1053         "pgpkeycreatetime", "pgpkeyexpiretime", "modifytimestamp",
1054         "pgpkeysize", "pgpkeytype", NULL
1055       };
1056
1057     log_debug ("SEARCH '%s' => '%s' BEGIN\n", pattern, filter);
1058
1059     ldap_err = ldap_search_s (ldap_conn, basedn,
1060                               LDAP_SCOPE_SUBTREE, filter, attrs, 0, &res);
1061
1062     xfree (filter);
1063     filter = NULL;
1064
1065     if (ldap_err != LDAP_SUCCESS && ldap_err != LDAP_SIZELIMIT_EXCEEDED)
1066       {
1067         err = ldap_err_to_gpg_err (ldap_err);
1068
1069         log_error ("SEARCH %s FAILED %d\n", pattern, err);
1070         log_error ("gpgkeys: LDAP search error: %s\n",
1071                    ldap_err2string (err));
1072         goto out;
1073     }
1074
1075     /* The LDAP server doesn't return a real count of unique keys, so we
1076        can't use ldap_count_entries here. */
1077     for (each = ldap_first_entry (ldap_conn, res);
1078          each;
1079          each = ldap_next_entry (ldap_conn, each))
1080       {
1081         char **certid = ldap_get_values (ldap_conn, each, "pgpcertid");
1082         if (certid && certid[0] && ! strlist_find (dupelist, certid[0]))
1083           {
1084             add_to_strlist (&dupelist, certid[0]);
1085             count++;
1086           }
1087       }
1088
1089     if (ldap_err == LDAP_SIZELIMIT_EXCEEDED)
1090       {
1091         if (count == 1)
1092           log_error ("gpgkeys: search results exceeded server limit."
1093                      "  First 1 result shown.\n");
1094         else
1095           log_error ("gpgkeys: search results exceeded server limit."
1096                      "  First %d results shown.\n", count);
1097       }
1098
1099     free_strlist (dupelist);
1100     dupelist = NULL;
1101
1102     if (count < 1)
1103       es_fputs ("info:1:0\n", fp);
1104     else
1105       {
1106         es_fprintf (fp, "info:1:%d\n", count);
1107
1108         for (each = ldap_first_entry (ldap_conn, res);
1109              each;
1110              each = ldap_next_entry (ldap_conn, each))
1111           {
1112             char **certid;
1113             LDAPMessage *uids;
1114
1115             certid = ldap_get_values (ldap_conn, each, "pgpcertid");
1116             if (! certid || ! certid[0])
1117               continue;
1118
1119             /* Have we seen this certid before? */
1120             if (! strlist_find (dupelist, certid[0]))
1121               {
1122                 add_to_strlist (&dupelist, certid[0]);
1123
1124                 es_fprintf (fp, "pub:%s:",certid[0]);
1125
1126                 vals = ldap_get_values (ldap_conn, each, "pgpkeytype");
1127                 if (vals)
1128                   {
1129                     /* The LDAP server doesn't exactly handle this
1130                        well. */
1131                     if (strcasecmp (vals[0], "RSA") == 0)
1132                       es_fputs ("1", fp);
1133                     else if (strcasecmp (vals[0], "DSS/DH") == 0)
1134                       es_fputs ("17", fp);
1135                     ldap_value_free (vals);
1136                   }
1137
1138                 es_fputc (':', fp);
1139
1140                 vals = ldap_get_values (ldap_conn, each, "pgpkeysize");
1141                 if (vals)
1142                   {
1143                     /* Not sure why, but some keys are listed with a
1144                        key size of 0.  Treat that like an unknown. */
1145                     if (atoi (vals[0]) > 0)
1146                       es_fprintf (fp, "%d", atoi (vals[0]));
1147                     ldap_value_free (vals);
1148                   }
1149
1150                 es_fputc (':', fp);
1151
1152                 /* YYYYMMDDHHmmssZ */
1153
1154                 vals = ldap_get_values (ldap_conn, each, "pgpkeycreatetime");
1155                 if(vals && strlen (vals[0]) == 15)
1156                   {
1157                     es_fprintf (fp, "%u",
1158                                 (unsigned int) ldap2epochtime(vals[0]));
1159                     ldap_value_free (vals);
1160                   }
1161
1162                 es_fputc (':', fp);
1163
1164                 vals = ldap_get_values (ldap_conn, each, "pgpkeyexpiretime");
1165                 if (vals && strlen (vals[0]) == 15)
1166                   {
1167                     es_fprintf (fp, "%u",
1168                                 (unsigned int) ldap2epochtime (vals[0]));
1169                     ldap_value_free (vals);
1170                   }
1171
1172                 es_fputc (':', fp);
1173
1174                 vals = ldap_get_values (ldap_conn, each, "pgprevoked");
1175                 if (vals)
1176                   {
1177                     if (atoi (vals[0]) == 1)
1178                       es_fprintf (fp, "r");
1179                     ldap_value_free (vals);
1180                   }
1181
1182                 vals = ldap_get_values (ldap_conn, each, "pgpdisabled");
1183                 if (vals)
1184                   {
1185                     if (atoi (vals[0]) ==1)
1186                       es_fprintf (fp, "d");
1187                     ldap_value_free (vals);
1188                   }
1189
1190 #if 0
1191                 /* This is not yet specified in the keyserver
1192                    protocol, but may be someday. */
1193                 es_fputc (':', fp);
1194
1195                 vals = ldap_get_values (ldap_conn, each, "modifytimestamp");
1196                 if(vals && strlen (vals[0]) == 15)
1197                   {
1198                     es_fprintf (fp, "%u",
1199                                 (unsigned int) ldap2epochtime (vals[0]));
1200                     ldap_value_free (vals);
1201                   }
1202 #endif
1203
1204                 es_fprintf (fp, "\n");
1205
1206                 /* Now print all the uids that have this certid */
1207                 for (uids = ldap_first_entry (ldap_conn, res);
1208                      uids;
1209                      uids = ldap_next_entry (ldap_conn, uids))
1210                   {
1211                     vals = ldap_get_values (ldap_conn, uids, "pgpcertid");
1212                     if (! vals)
1213                       continue;
1214
1215                     if (strcasecmp (certid[0], vals[0]) == 0)
1216                       {
1217                         char **uidvals;
1218
1219                         es_fprintf (fp, "uid:");
1220
1221                         uidvals = ldap_get_values (ldap_conn,
1222                                                    uids, "pgpuserid");
1223                         if (uidvals)
1224                           {
1225                             /* Need to escape any colons */
1226                             char *quoted = percent_escape (uidvals[0], NULL);
1227                             es_fputs (quoted, fp);
1228                             xfree (quoted);
1229                             ldap_value_free (uidvals);
1230                           }
1231
1232                         es_fprintf (fp, "\n");
1233                       }
1234
1235                     ldap_value_free(vals);
1236                   }
1237               }
1238
1239               ldap_value_free (certid);
1240           }
1241       }
1242
1243     ldap_msgfree (res);
1244     free_strlist (dupelist);
1245   }
1246
1247   log_debug ("SEARCH %s END\n", pattern);
1248
1249  out:
1250   if (err)
1251     {
1252       if (fp)
1253         es_fclose (fp);
1254     }
1255   else
1256     {
1257       /* Return the read stream.  */
1258       if (fp)
1259         es_fseek (fp, 0, SEEK_SET);
1260
1261       *r_fp = fp;
1262     }
1263
1264   xfree (basedn);
1265
1266   if (ldap_conn)
1267     ldap_unbind (ldap_conn);
1268
1269   xfree (filter);
1270
1271   return err;
1272 }
1273
1274
1275 \f
1276 /* A modlist describes a set of changes to an LDAP entry.  (An entry
1277    consists of 1 or more attributes.  Attributes are <name, value>
1278    pairs.  Note: an attribute may be multi-valued in which case
1279    multiple values are associated with a single name.)
1280
1281    A modlist is a NULL terminated array of struct LDAPMod's.
1282
1283    Thus, if we have:
1284
1285      LDAPMod **modlist;
1286
1287    Then:
1288
1289      modlist[i]
1290
1291    Is the ith modification.
1292
1293    Each LDAPMod describes a change to a single attribute.  Further,
1294    there is one modification for each attribute that we want to
1295    change.  The attribute's new value is stored in LDAPMod.mod_values.
1296    If the attribute is multi-valued, we still only use a single
1297    LDAPMod structure: mod_values is a NULL-terminated array of
1298    strings.  To delete an attribute from an entry, we set mod_values
1299    to NULL.
1300
1301    Thus, if:
1302
1303      modlist[i]->mod_values == NULL
1304
1305    then we remove the attribute.
1306
1307    (Using LDAP_MOD_DELETE doesn't work here as we don't know if the
1308    attribute in question exists or not.)
1309
1310    Note: this function does NOT copy or free ATTR.  It does copy
1311    VALUE.  */
1312 static void
1313 modlist_add (LDAPMod ***modlistp, char *attr, const char *value)
1314 {
1315   LDAPMod **modlist = *modlistp;
1316
1317   LDAPMod **m;
1318   int nummods = 0;
1319
1320   /* Search modlist for the attribute we're playing with.  If modlist
1321      is NULL, then the list is empty.  Recall: modlist is a NULL
1322      terminated array.  */
1323   for (m = modlist; m && *m; m++, nummods ++)
1324     {
1325       /* The attribute is already on the list.  */
1326       char **ptr;
1327       int numvalues = 0;
1328
1329       if (strcasecmp ((*m)->mod_type, attr) != 0)
1330         continue;
1331
1332       /* We have this attribute already, so when the REPLACE happens,
1333          the server attributes will be replaced anyway. */
1334       if (! value)
1335         return;
1336
1337       /* Attributes can be multi-valued.  See if the value is already
1338          present.  mod_values is a NULL terminated array of pointers.
1339          Note: mod_values can be NULL.  */
1340       for (ptr = (*m)->mod_values; ptr && *ptr; ptr++)
1341         {
1342           if (strcmp (*ptr, value) == 0)
1343             /* Duplicate value, we're done.  */
1344             return;
1345           numvalues ++;
1346         }
1347
1348       /* Append the value.  */
1349       ptr = xrealloc ((*m)->mod_values, sizeof (char *) * (numvalues + 2));
1350
1351       (*m)->mod_values = ptr;
1352       ptr[numvalues] = xstrdup (value);
1353
1354       ptr[numvalues + 1] = NULL;
1355
1356       return;
1357     }
1358
1359   /* We didn't find the attr, so make one and add it to the end */
1360
1361   /* Like attribute values, the list of attributes is NULL terminated
1362      array of pointers.  */
1363   modlist = xrealloc (modlist, sizeof (LDAPMod *) * (nummods + 2));
1364
1365   *modlistp = modlist;
1366   modlist[nummods] = xmalloc (sizeof (LDAPMod));
1367
1368   modlist[nummods]->mod_op = LDAP_MOD_REPLACE;
1369   modlist[nummods]->mod_type = attr;
1370   if (value)
1371     {
1372       modlist[nummods]->mod_values = xmalloc (sizeof(char *) * 2);
1373
1374       modlist[nummods]->mod_values[0] = xstrdup (value);
1375       modlist[nummods]->mod_values[1] = NULL;
1376     }
1377   else
1378     modlist[nummods]->mod_values = NULL;
1379
1380   modlist[nummods + 1] = NULL;
1381
1382   return;
1383 }
1384
1385 /* Look up the value of an attribute in the specified modlist.  If the
1386    attribute is not on the mod list, returns NULL.  The result is a
1387    NULL-terminated array of strings.  Don't change it.  */
1388 static char **
1389 modlist_lookup (LDAPMod **modlist, const char *attr)
1390 {
1391   LDAPMod **m;
1392   for (m = modlist; m && *m; m++)
1393     {
1394       if (strcasecmp ((*m)->mod_type, attr) != 0)
1395         continue;
1396
1397       return (*m)->mod_values;
1398     }
1399
1400   return NULL;
1401 }
1402
1403 /* Dump a modlist to a file.  This is useful for debugging.  */
1404 static estream_t modlist_dump (LDAPMod **modlist, estream_t output)
1405   GNUPG_GCC_A_USED;
1406
1407 static estream_t
1408 modlist_dump (LDAPMod **modlist, estream_t output)
1409 {
1410   LDAPMod **m;
1411
1412   int opened = 0;
1413
1414   if (! output)
1415     {
1416       output = es_fopenmem (0, "rw");
1417       if (!output)
1418         return NULL;
1419       opened = 1;
1420     }
1421
1422   for (m = modlist; m && *m; m++)
1423     {
1424       es_fprintf (output, "  %s:", (*m)->mod_type);
1425
1426       if (! (*m)->mod_values)
1427         es_fprintf(output, " delete.\n");
1428       else
1429         {
1430           char **ptr;
1431           int i;
1432
1433           int multi = 0;
1434           if ((*m)->mod_values[0] && (*m)->mod_values[1])
1435             /* Have at least 2.  */
1436             multi = 1;
1437
1438           if (multi)
1439             es_fprintf (output, "\n");
1440
1441           for ((ptr = (*m)->mod_values), (i = 1); ptr && *ptr; ptr++, i ++)
1442             {
1443               /* Assuming terminals are about 80 characters wide,
1444                  display at most most about 10 lines of debugging
1445                  output.  If we do trim the buffer, append '...' to
1446                  the end.  */
1447               const int max_len = 10 * 70;
1448               size_t value_len = strlen (*ptr);
1449               int elide = value_len > max_len;
1450
1451               if (multi)
1452                 es_fprintf (output, "    %d. ", i);
1453               es_fprintf (output, "`%.*s", max_len, *ptr);
1454               if (elide)
1455                 es_fprintf (output, "...' (%zd bytes elided)",
1456                             value_len - max_len);
1457               else
1458                 es_fprintf (output, "'");
1459               es_fprintf (output, "\n");
1460             }
1461         }
1462     }
1463
1464   if (opened)
1465     es_fseek (output, 0, SEEK_SET);
1466
1467   return output;
1468 }
1469
1470 /* Free all of the memory allocated by the mod list.  This assumes
1471    that the attribute names don't have to be freed, but the attributes
1472    values do.  (Which is what modlist_add does.)  */
1473 static void
1474 modlist_free (LDAPMod **modlist)
1475 {
1476   LDAPMod **ml;
1477
1478   if (! modlist)
1479     return;
1480
1481   /* Unwind and free the whole modlist structure */
1482
1483   /* The modlist is a NULL terminated array of pointers.  */
1484   for (ml = modlist; *ml; ml++)
1485     {
1486       LDAPMod *mod = *ml;
1487       char **ptr;
1488
1489       /* The list of values is a NULL termianted array of pointers.
1490          If the list is NULL, there are no values.  */
1491
1492       if (mod->mod_values)
1493         {
1494           for (ptr = mod->mod_values; *ptr; ptr++)
1495             xfree (*ptr);
1496
1497           xfree (mod->mod_values);
1498         }
1499
1500       xfree (mod);
1501     }
1502   xfree (modlist);
1503 }
1504
1505 /* Append two onto the end of one.  Two is not freed, but its pointers
1506    are now part of one.  Make sure you don't free them both!
1507
1508    As long as you don't add anything to ONE, TWO is still valid.
1509    After that all bets are off.  */
1510 static void
1511 modlists_join (LDAPMod ***one, LDAPMod **two)
1512 {
1513   int i, one_count = 0, two_count = 0;
1514   LDAPMod **grow;
1515
1516   if (!*two)
1517     /* two is empty.  Nothing to do.  */
1518     return;
1519
1520   if (!*one)
1521     /* one is empty.  Just set it equal to *two.  */
1522     {
1523       *one = two;
1524       return;
1525     }
1526
1527   for (grow = *one; *grow; grow++)
1528     one_count ++;
1529
1530   for (grow = two; *grow; grow++)
1531     two_count ++;
1532
1533   grow = xrealloc (*one, sizeof(LDAPMod *) * (one_count + two_count + 1));
1534
1535   for (i = 0; i < two_count; i++)
1536     grow[one_count + i] = two[i];
1537
1538   grow[one_count + i] = NULL;
1539
1540   *one = grow;
1541 }
1542
1543 /* Given a string, unescape C escapes.  In particular, \xXX.  This
1544    modifies the string in place.  */
1545 static void
1546 uncescape (char *str)
1547 {
1548   size_t r = 0;
1549   size_t w = 0;
1550
1551   char *first = strchr (str, '\\');
1552   if (! first)
1553     /* No backslashes => no escaping.  We're done.  */
1554     return;
1555
1556   /* Start at the first '\\'.  */
1557   r = w = (uintptr_t) first - (uintptr_t) str;
1558
1559   while (str[r])
1560     {
1561       /* XXX: What to do about bad escapes?
1562          XXX: hextobyte already checks the string thus the hexdigitp
1563          could be removed. */
1564       if (str[r] == '\\' && str[r + 1] == 'x'
1565           && str[r+2] && str[r+3]
1566           && hexdigitp (str + r + 2)
1567           && hexdigitp (str + r + 3))
1568         {
1569           int x = hextobyte (&str[r + 2]);
1570           assert (0 <= x && x <= 0xff);
1571
1572           str[w] = x;
1573
1574           /* We consumed 4 characters and wrote 1.  */
1575           r += 4;
1576           w ++;
1577         }
1578       else
1579         str[w ++] = str[r ++];
1580     }
1581
1582   str[w] = '\0';
1583 }
1584
1585 /* Given one line from an info block (`gpg --list-{keys,sigs}
1586    --with-colons KEYID'), pull it apart and fill in the modlist with
1587    the relevant (for the LDAP schema) attributes.  */
1588 static void
1589 extract_attributes (LDAPMod ***modlist, char *line)
1590 {
1591   int field_count;
1592   char **fields;
1593
1594   char *keyid;
1595
1596   int is_pub, is_sub, is_uid, is_sig;
1597
1598   /* Remove trailing whitespace */
1599   trim_trailing_spaces (line);
1600
1601   fields = strsplit (line, ':', '\0', &field_count);
1602   if (field_count == 1)
1603     /* We only have a single field.  There is definately nothing to
1604        do.  */
1605     goto out;
1606
1607   if (field_count < 7)
1608     goto out;
1609
1610   is_pub = strcasecmp ("pub", fields[0]) == 0;
1611   is_sub = strcasecmp ("sub", fields[0]) == 0;
1612   is_uid = strcasecmp ("uid", fields[0]) == 0;
1613   is_sig = strcasecmp ("sig", fields[0]) == 0;
1614
1615   if (!is_pub && !is_sub && !is_uid && !is_sig)
1616     /* Not a relevant line.  */
1617     goto out;
1618
1619   keyid = fields[4];
1620
1621   if (is_uid && strlen (keyid) == 0)
1622     /* The uid record type can have an empty keyid.  */
1623     ;
1624   else if (strlen (keyid) == 16
1625            && strspn (keyid, "0123456789aAbBcCdDeEfF") == 16)
1626     /* Otherwise, we expect exactly 16 hex characters.  */
1627     ;
1628   else
1629     {
1630       log_error ("malformed record!\n");
1631       goto out;
1632     }
1633
1634   if (is_pub)
1635     {
1636       int disabled = 0;
1637       int revoked = 0;
1638       char *flags;
1639       for (flags = fields[1]; *flags; flags ++)
1640         switch (*flags)
1641           {
1642           case 'r':
1643           case 'R':
1644             revoked = 1;
1645             break;
1646
1647           case 'd':
1648           case 'D':
1649             disabled = 1;
1650             break;
1651           }
1652
1653       /* Note: we always create the pgpDisabled and pgpRevoked
1654         attributes, regardless of whether the key is disabled/revoked
1655         or not.  This is because a very common search is like
1656         "(&(pgpUserID=*isabella*)(pgpDisabled=0))"  */
1657
1658       if (is_pub)
1659         {
1660           modlist_add (modlist,"pgpDisabled", disabled ? "1" : "0");
1661           modlist_add (modlist,"pgpRevoked", revoked ? "1" : "0");
1662         }
1663     }
1664
1665   if (is_pub || is_sub)
1666     {
1667       char *size = fields[2];
1668       int val = atoi (size);
1669       size = NULL;
1670
1671       if (val > 0)
1672         {
1673           /* We zero pad this on the left to make PGP happy. */
1674           char padded[6];
1675           if (val < 99999 && val > 0)
1676             {
1677               snprintf (padded, sizeof padded, "%05u", val);
1678               size = padded;
1679             }
1680         }
1681
1682       if (size)
1683         {
1684           if (is_pub || is_sub)
1685             modlist_add (modlist, "pgpKeySize", size);
1686         }
1687     }
1688
1689   if (is_pub)
1690     {
1691       char *algo = fields[3];
1692       int val = atoi (algo);
1693       switch (val)
1694         {
1695         case 1:
1696           algo = "RSA";
1697           break;
1698
1699         case 17:
1700           algo = "DSS/DH";
1701           break;
1702
1703         default:
1704           algo = NULL;
1705           break;
1706         }
1707
1708       if (algo)
1709         {
1710           if (is_pub)
1711             modlist_add (modlist, "pgpKeyType", algo);
1712         }
1713     }
1714
1715   if (is_pub || is_sub || is_sig)
1716     {
1717       if (is_pub)
1718         {
1719           modlist_add (modlist, "pgpCertID", keyid);
1720           modlist_add (modlist, "pgpKeyID", &keyid[8]);
1721         }
1722
1723       if (is_sub)
1724         modlist_add (modlist, "pgpSubKeyID", keyid);
1725
1726       if (is_sig)
1727         modlist_add (modlist, "pgpSignerID", keyid);
1728     }
1729
1730   if (is_pub)
1731     {
1732       char *create_time = fields[5];
1733
1734       if (strlen (create_time) == 0)
1735         create_time = NULL;
1736       else
1737         {
1738           char *create_time_orig = create_time;
1739           struct tm tm;
1740           time_t t;
1741           char *end;
1742
1743           memset (&tm, 0, sizeof (tm));
1744
1745           /* parse_timestamp handles both seconds fromt he epoch and
1746              ISO 8601 format.  We also need to handle YYYY-MM-DD
1747              format (as generated by gpg1 --with-colons --list-key).
1748              Check that first and then if it fails, then try
1749              parse_timestamp.  */
1750
1751           if (strptime (create_time, "%Y-%m-%d", &tm))
1752             create_time = tm2ldaptime (&tm);
1753           else if ((t = parse_timestamp (create_time, &end)) != (time_t) -1
1754                    && *end == '\0')
1755             {
1756               if (! gmtime_r (&t, &tm))
1757                 create_time = NULL;
1758               else
1759                 create_time = tm2ldaptime (&tm);
1760             }
1761           else
1762             create_time = NULL;
1763
1764           if (! create_time)
1765             /* Failed to parse string.  */
1766             log_error ("Failed to parse creation time ('%s')",
1767                        create_time_orig);
1768         }
1769
1770       if (create_time)
1771         {
1772           modlist_add (modlist, "pgpKeyCreateTime", create_time);
1773           xfree (create_time);
1774         }
1775     }
1776
1777   if (is_pub)
1778     {
1779       char *expire_time = fields[6];
1780
1781       if (strlen (expire_time) == 0)
1782         expire_time = NULL;
1783       else
1784         {
1785           char *expire_time_orig = expire_time;
1786           struct tm tm;
1787           time_t t;
1788           char *end;
1789
1790           memset (&tm, 0, sizeof (tm));
1791
1792           /* parse_timestamp handles both seconds fromt he epoch and
1793              ISO 8601 format.  We also need to handle YYYY-MM-DD
1794              format (as generated by gpg1 --with-colons --list-key).
1795              Check that first and then if it fails, then try
1796              parse_timestamp.  */
1797
1798           if (strptime (expire_time, "%Y-%m-%d", &tm))
1799             expire_time = tm2ldaptime (&tm);
1800           else if ((t = parse_timestamp (expire_time, &end)) != (time_t) -1
1801                    && *end == '\0')
1802             {
1803               if (! gmtime_r (&t, &tm))
1804                 expire_time = NULL;
1805               else
1806                 expire_time = tm2ldaptime (&tm);
1807             }
1808           else
1809             expire_time = NULL;
1810
1811           if (! expire_time)
1812             /* Failed to parse string.  */
1813             log_error ("Failed to parse creation time ('%s')",
1814                        expire_time_orig);
1815         }
1816
1817       if (expire_time)
1818         {
1819           modlist_add (modlist, "pgpKeyExpireTime", expire_time);
1820           xfree (expire_time);
1821         }
1822     }
1823
1824   if ((is_uid || is_pub) && field_count >= 10)
1825     {
1826       char *uid = fields[9];
1827
1828       if (is_pub && strlen (uid) == 0)
1829         /* When using gpg --list-keys, the uid is included.  When
1830            passed via gpg, it is not.  It is important to process it
1831            when it is present, because gpg 1 won't print a UID record
1832            if there is only one key.  */
1833         ;
1834       else
1835         {
1836           uncescape (uid);
1837           modlist_add (modlist, "pgpUserID", uid);
1838         }
1839     }
1840
1841  out:
1842   free (fields);
1843 }
1844
1845 /* Send the key in {KEY,KEYLEN} with the metadata {INFO,INFOLEN} to
1846    the keyserver identified by URI.  See server.c:cmd_ks_put for the
1847    format of the data and metadata.  */
1848 gpg_error_t
1849 ks_ldap_put (ctrl_t ctrl, parsed_uri_t uri,
1850              void *data, size_t datalen,
1851              void *info, size_t infolen)
1852 {
1853   gpg_error_t err = 0;
1854   int ldap_err;
1855
1856   LDAP *ldap_conn = NULL;
1857   char *basedn = NULL;
1858   char *pgpkeyattr = NULL;
1859   int real_ldap;
1860
1861   LDAPMod **modlist = NULL;
1862   LDAPMod **addlist = NULL;
1863
1864   char *data_armored = NULL;
1865
1866   /* The last byte of the info block.  */
1867   const char *infoend = (const char *) info + infolen - 1;
1868
1869   /* Enable this code to dump the modlist to /tmp/modlist.txt.  */
1870 #if 0
1871 # warning Disable debug code before checking in.
1872   const int dump_modlist = 1;
1873 #else
1874   const int dump_modlist = 0;
1875 #endif
1876   estream_t dump = NULL;
1877
1878   /* Elide a warning.  */
1879   (void) ctrl;
1880
1881   ldap_err = ldap_connect (uri, &ldap_conn, &basedn, &pgpkeyattr, &real_ldap);
1882   if (ldap_err || !basedn)
1883     {
1884       if (ldap_err)
1885         err = ldap_err_to_gpg_err (ldap_err);
1886       else
1887         err = GPG_ERR_GENERAL;
1888       goto out;
1889     }
1890
1891   if (! real_ldap)
1892     /* We appear to have an OpenPGP Keyserver, which can unpack the key
1893        on its own (not just a dumb LDAP server).  */
1894     {
1895       LDAPMod mod, *attrs[2];
1896       char *key[] = { data, NULL };
1897       char *dn;
1898
1899       memset (&mod, 0, sizeof (mod));
1900       mod.mod_op = LDAP_MOD_ADD;
1901       mod.mod_type = pgpkeyattr;
1902       mod.mod_values = key;
1903       attrs[0] = &mod;
1904       attrs[1] = NULL;
1905
1906       dn = xasprintf ("pgpCertid=virtual,%s", basedn);
1907       ldap_err = ldap_add_s (ldap_conn, dn, attrs);
1908       xfree (dn);
1909
1910       if (ldap_err != LDAP_SUCCESS)
1911         {
1912           err = ldap_err_to_gpg_err (err);
1913           goto out;
1914         }
1915
1916       goto out;
1917     }
1918
1919   modlist = xmalloc (sizeof (LDAPMod *));
1920   *modlist = NULL;
1921
1922   if (dump_modlist)
1923     {
1924       dump = es_fopen("/tmp/modlist.txt", "w");
1925       if (! dump)
1926         log_error ("Failed to open /tmp/modlist.txt: %s\n",
1927                    strerror (errno));
1928
1929       if (dump)
1930         {
1931           es_fprintf(dump, "data (%zd bytes)\n", datalen);
1932           es_fprintf(dump, "info (%zd bytes): '\n", infolen);
1933           es_fwrite(info, infolen, 1, dump);
1934           es_fprintf(dump, "'\n");
1935         }
1936     }
1937
1938   /* Start by nulling out all attributes.  We try and do a modify
1939      operation first, so this ensures that we don't leave old
1940      attributes lying around. */
1941   modlist_add (&modlist, "pgpDisabled", NULL);
1942   modlist_add (&modlist, "pgpKeyID", NULL);
1943   modlist_add (&modlist, "pgpKeyType", NULL);
1944   modlist_add (&modlist, "pgpUserID", NULL);
1945   modlist_add (&modlist, "pgpKeyCreateTime", NULL);
1946   modlist_add (&modlist, "pgpSignerID", NULL);
1947   modlist_add (&modlist, "pgpRevoked", NULL);
1948   modlist_add (&modlist, "pgpSubKeyID", NULL);
1949   modlist_add (&modlist, "pgpKeySize", NULL);
1950   modlist_add (&modlist, "pgpKeyExpireTime", NULL);
1951   modlist_add (&modlist, "pgpCertID", NULL);
1952
1953   /* Assemble the INFO stuff into LDAP attributes */
1954
1955   while (infolen > 0)
1956     {
1957       char *temp = NULL;
1958
1959       char *newline = memchr (info, '\n', infolen);
1960       if (! newline)
1961         /* The last line is not \n terminated!  Make a copy so we can
1962            add a NUL terminator.  */
1963         {
1964           temp = alloca (infolen + 1);
1965           memcpy (temp, info, infolen);
1966           info = temp;
1967           newline = (char *) info + infolen;
1968         }
1969
1970       *newline = '\0';
1971
1972       extract_attributes (&modlist, info);
1973
1974       infolen = infolen - ((uintptr_t) newline - (uintptr_t) info + 1);
1975       info = newline + 1;
1976
1977       /* Sanity check.  */
1978       if (! temp)
1979         assert ((char *) info + infolen - 1 == infoend);
1980       else
1981         assert (infolen == -1);
1982     }
1983
1984   modlist_add (&addlist, "objectClass", "pgpKeyInfo");
1985
1986   err = armor_data (&data_armored, data, datalen);
1987   if (err)
1988     goto out;
1989
1990   modlist_add (&addlist, pgpkeyattr, data_armored);
1991
1992   /* Now append addlist onto modlist.  */
1993   modlists_join (&modlist, addlist);
1994
1995   if (dump)
1996     {
1997       estream_t input = modlist_dump (modlist, NULL);
1998       if (input)
1999         {
2000           copy_stream (input, dump);
2001           es_fclose (input);
2002         }
2003     }
2004
2005   /* Going on the assumption that modify operations are more frequent
2006      than adds, we try a modify first.  If it's not there, we just
2007      turn around and send an add command for the same key.  Otherwise,
2008      the modify brings the server copy into compliance with our copy.
2009      Note that unlike the LDAP keyserver (and really, any other
2010      keyserver) this does NOT merge signatures, but replaces the whole
2011      key.  This should make some people very happy. */
2012   {
2013     char **certid;
2014     char *dn;
2015
2016     certid = modlist_lookup (modlist, "pgpCertID");
2017     if (/* We should have a value.  */
2018         ! certid
2019         /* Exactly one.  */
2020         || !(certid[0] && !certid[1]))
2021       {
2022         log_error ("Bad certid.\n");
2023         err = GPG_ERR_GENERAL;
2024         goto out;
2025       }
2026
2027     dn = xasprintf ("pgpCertID=%s,%s", certid[0], basedn);
2028
2029     err = ldap_modify_s (ldap_conn, dn, modlist);
2030     if (err == LDAP_NO_SUCH_OBJECT)
2031       err = ldap_add_s (ldap_conn, dn, addlist);
2032
2033     xfree (dn);
2034
2035     if (err != LDAP_SUCCESS)
2036       {
2037         log_error ("gpgkeys: error adding key to keyserver: %s\n",
2038                    ldap_err2string (err));
2039         err = ldap_err_to_gpg_err (err);
2040       }
2041   }
2042
2043  out:
2044   if (dump)
2045     es_fclose (dump);
2046
2047   if (ldap_conn)
2048     ldap_unbind (ldap_conn);
2049
2050   xfree (basedn);
2051   xfree (pgpkeyattr);
2052
2053   modlist_free (modlist);
2054   xfree (addlist);
2055
2056   xfree (data_armored);
2057
2058   return err;
2059 }