doc: fix formatting error
[gnupg.git] / g10 / trust.c
1 /* trust.c - High level trust functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2012 Free Software Foundation, Inc.
4  * Copyright (C) 2014 Werner Koch
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 <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "gpg.h"
28 #include "keydb.h"
29 #include "../common/util.h"
30 #include "options.h"
31 #include "packet.h"
32 #include "main.h"
33 #include "../common/i18n.h"
34 #include "trustdb.h"
35 #include "../common/host2net.h"
36
37
38 /* Return true if key is disabled.  Note that this is usually used via
39    the pk_is_disabled macro.  */
40 int
41 cache_disabled_value (ctrl_t ctrl, PKT_public_key *pk)
42 {
43 #ifdef NO_TRUST_MODELS
44   (void)pk;
45   return 0;
46 #else
47   return tdb_cache_disabled_value (ctrl, pk);
48 #endif
49 }
50
51
52 void
53 register_trusted_keyid (u32 *keyid)
54 {
55 #ifdef NO_TRUST_MODELS
56   (void)keyid;
57 #else
58   tdb_register_trusted_keyid (keyid);
59 #endif
60 }
61
62
63 void
64 register_trusted_key (const char *string)
65 {
66 #ifdef NO_TRUST_MODELS
67   (void)string;
68 #else
69
70   /* Some users have conf files with entries like
71    *   trusted-key 0x1234567812345678    # foo
72    * That is obviously wrong.  Before fixing bug#1206 trailing garbage
73    * on a key specification if was ignored.  We detect the above use case
74    * here and  cut off the junk-looking-like-a comment.  */
75   if (strchr (string, '#'))
76     {
77       char *buf;
78
79       buf = xtrystrdup (string);
80       if (buf)
81         {
82           *strchr (buf, '#') = 0;
83           tdb_register_trusted_key (buf);
84           xfree (buf);
85           return;
86         }
87     }
88
89   tdb_register_trusted_key (string);
90 #endif
91 }
92
93
94 \f
95 /*
96  * This function returns a letter for a trust value.  Trust flags
97  * are ignored.
98  */
99 static int
100 trust_letter (unsigned int value)
101 {
102   switch( (value & TRUST_MASK) )
103     {
104     case TRUST_UNKNOWN:   return '-';
105     case TRUST_EXPIRED:   return 'e';
106     case TRUST_UNDEFINED: return 'q';
107     case TRUST_NEVER:     return 'n';
108     case TRUST_MARGINAL:  return 'm';
109     case TRUST_FULLY:     return 'f';
110     case TRUST_ULTIMATE:  return 'u';
111     default:              return '?';
112     }
113 }
114
115
116 /* The strings here are similar to those in
117    pkclist.c:do_edit_ownertrust() */
118 const char *
119 trust_value_to_string (unsigned int value)
120 {
121   switch ((value & TRUST_MASK))
122     {
123     case TRUST_UNKNOWN:   return _("unknown");
124     case TRUST_EXPIRED:   return _("expired");
125     case TRUST_UNDEFINED: return _("undefined");
126     case TRUST_NEVER:     return _("never");
127     case TRUST_MARGINAL:  return _("marginal");
128     case TRUST_FULLY:     return _("full");
129     case TRUST_ULTIMATE:  return _("ultimate");
130     default:              return "err";
131     }
132 }
133
134
135 int
136 string_to_trust_value (const char *str)
137 {
138   if (!ascii_strcasecmp (str, "undefined"))
139     return TRUST_UNDEFINED;
140   else if (!ascii_strcasecmp (str, "never"))
141     return TRUST_NEVER;
142   else if (!ascii_strcasecmp (str, "marginal"))
143     return TRUST_MARGINAL;
144   else if (!ascii_strcasecmp (str, "full"))
145     return TRUST_FULLY;
146   else if (!ascii_strcasecmp(str, "ultimate"))
147     return TRUST_ULTIMATE;
148   else
149     return -1;
150 }
151
152
153 const char *
154 uid_trust_string_fixed (ctrl_t ctrl, PKT_public_key *key, PKT_user_id *uid)
155 {
156   if (!key && !uid)
157     {
158       /* TRANSLATORS: these strings are similar to those in
159          trust_value_to_string(), but are a fixed length.  This is needed to
160          make attractive information listings where columns line up
161          properly.  The value "10" should be the length of the strings you
162          choose to translate to.  This is the length in printable columns.
163          It gets passed to atoi() so everything after the number is
164          essentially a comment and need not be translated.  Either key and
165          uid are both NULL, or neither are NULL. */
166       return _("10 translator see trust.c:uid_trust_string_fixed");
167     }
168   else if(uid->flags.revoked || (key && key->flags.revoked))
169     return                         _("[ revoked]");
170   else if(uid->flags.expired)
171     return                         _("[ expired]");
172   else if(key)
173     {
174       switch (get_validity (ctrl, NULL, key, uid, NULL, 0) & TRUST_MASK)
175         {
176         case TRUST_UNKNOWN:   return _("[ unknown]");
177         case TRUST_EXPIRED:   return _("[ expired]");
178         case TRUST_UNDEFINED: return _("[  undef ]");
179         case TRUST_NEVER:     return _("[  never ]");
180         case TRUST_MARGINAL:  return _("[marginal]");
181         case TRUST_FULLY:     return _("[  full  ]");
182         case TRUST_ULTIMATE:  return _("[ultimate]");
183         }
184     }
185
186   return "err";
187 }
188
189
190 \f
191 /*
192  * Return the assigned ownertrust value for the given public key.
193  * The key should be the primary key.
194  */
195 unsigned int
196 get_ownertrust (ctrl_t ctrl, PKT_public_key *pk)
197 {
198 #ifdef NO_TRUST_MODELS
199   (void)pk;
200   return TRUST_UNKNOWN;
201 #else
202   return tdb_get_ownertrust (ctrl, pk, 0);
203 #endif
204 }
205
206
207 /*
208  * Same as get_ownertrust but this takes the minimum ownertrust value
209  * into account, and will bump up the value as needed.  NO_CREATE
210  * inhibits creation of a trustdb it that does not yet exists.
211  */
212 static int
213 get_ownertrust_with_min (ctrl_t ctrl, PKT_public_key *pk, int no_create)
214 {
215 #ifdef NO_TRUST_MODELS
216   (void)pk;
217   return TRUST_UNKNOWN;
218 #else
219   unsigned int otrust, otrust_min;
220
221   /* Shortcut instead of doing the same twice in the two tdb_get
222    * functions: If the caller asked not to create a trustdb we call
223    * init_trustdb directly and allow it to fail with an error code for
224    * a non-existing trustdb.  */
225   if (no_create && init_trustdb (ctrl, 1))
226     return TRUST_UNKNOWN;
227
228   otrust = (tdb_get_ownertrust (ctrl, pk, no_create) & TRUST_MASK);
229   otrust_min = tdb_get_min_ownertrust (ctrl, pk, no_create);
230   if (otrust < otrust_min)
231     {
232       /* If the trust that the user has set is less than the trust
233          that was calculated from a trust signature chain, use the
234          higher of the two.  We do this here and not in
235          get_ownertrust since the underlying ownertrust should not
236          really be set - just the appearance of the ownertrust. */
237
238       otrust = otrust_min;
239     }
240
241   return otrust;
242 #endif
243 }
244
245
246 /*
247  * Same as get_ownertrust but return a trust letter instead of an
248  * value.  This takes the minimum ownertrust value into account.  If
249  * NO_CREATE is set, no efforts for creating a trustdb will be taken.
250  */
251 int
252 get_ownertrust_info (ctrl_t ctrl, PKT_public_key *pk, int no_create)
253 {
254   return trust_letter (get_ownertrust_with_min (ctrl, pk, no_create));
255 }
256
257
258 /*
259  * Same as get_ownertrust but return a trust string instead of an
260  * value.  This takes the minimum ownertrust value into account.  If
261  * NO_CREATE is set, no efforts for creating a trustdb will be taken.
262  */
263 const char *
264 get_ownertrust_string (ctrl_t ctrl, PKT_public_key *pk, int no_create)
265 {
266   return trust_value_to_string (get_ownertrust_with_min (ctrl, pk, no_create));
267 }
268
269
270 /*
271  * Set the trust value of the given public key to the new value.
272  * The key should be a primary one.
273  */
274 void
275 update_ownertrust (ctrl_t ctrl, PKT_public_key *pk, unsigned int new_trust)
276 {
277 #ifdef NO_TRUST_MODELS
278   (void)pk;
279   (void)new_trust;
280 #else
281   tdb_update_ownertrust (ctrl, pk, new_trust);
282 #endif
283 }
284
285
286 int
287 clear_ownertrusts (ctrl_t ctrl, PKT_public_key *pk)
288 {
289 #ifdef NO_TRUST_MODELS
290   (void)pk;
291   return 0;
292 #else
293   return tdb_clear_ownertrusts (ctrl, pk);
294 #endif
295 }
296
297
298 void
299 revalidation_mark (ctrl_t ctrl)
300 {
301 #ifndef NO_TRUST_MODELS
302   tdb_revalidation_mark (ctrl);
303 #endif
304 }
305
306
307 void
308 check_trustdb_stale (ctrl_t ctrl)
309 {
310 #ifndef NO_TRUST_MODELS
311   tdb_check_trustdb_stale (ctrl);
312 #else
313   (void)ctrl;
314 #endif
315 }
316
317
318 void
319 check_or_update_trustdb (ctrl_t ctrl)
320 {
321 #ifndef NO_TRUST_MODELS
322   tdb_check_or_update (ctrl);
323 #else
324   (void)ctrl;
325 #endif
326 }
327
328
329 /*
330  * Return the validity information for KB/PK (at least one must be
331  * non-NULL).  If the namehash is not NULL, the validity of the
332  * corresponding user ID is returned, otherwise, a reasonable value
333  * for the entire key is returned.
334  */
335 unsigned int
336 get_validity (ctrl_t ctrl, kbnode_t kb, PKT_public_key *pk, PKT_user_id *uid,
337               PKT_signature *sig, int may_ask)
338 {
339   int rc;
340   unsigned int validity;
341   u32 kid[2];
342   PKT_public_key *main_pk;
343
344   if (kb && pk)
345     log_assert (keyid_cmp (pk_main_keyid (pk),
346                            pk_main_keyid (kb->pkt->pkt.public_key)) == 0);
347
348   if (! pk)
349     {
350       log_assert (kb);
351       pk = kb->pkt->pkt.public_key;
352     }
353
354   if (uid)
355     namehash_from_uid (uid);
356
357   keyid_from_pk (pk, kid);
358   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
359     {
360       /* This is a subkey - get the mainkey. */
361       if (kb)
362         main_pk = kb->pkt->pkt.public_key;
363       else
364         {
365           main_pk = xmalloc_clear (sizeof *main_pk);
366           rc = get_pubkey (ctrl, main_pk, pk->main_keyid);
367           if (rc)
368             {
369               char *tempkeystr = xstrdup (keystr (pk->main_keyid));
370               log_error ("error getting main key %s of subkey %s: %s\n",
371                          tempkeystr, keystr (kid), gpg_strerror (rc));
372               xfree (tempkeystr);
373               validity = TRUST_UNKNOWN;
374               goto leave;
375             }
376         }
377     }
378   else
379     main_pk = pk;
380
381 #ifdef NO_TRUST_MODELS
382   validity = TRUST_UNKNOWN;
383 #else
384   validity = tdb_get_validity_core (ctrl, kb, pk, uid, main_pk, sig, may_ask);
385 #endif
386
387  leave:
388   /* Set some flags direct from the key */
389   if (main_pk->flags.revoked)
390     validity |= TRUST_FLAG_REVOKED;
391   if (main_pk != pk && pk->flags.revoked)
392     validity |= TRUST_FLAG_SUB_REVOKED;
393   /* Note: expiration is a trust value and not a flag - don't know why
394    * I initially designed it that way.  */
395   if (main_pk->has_expired || pk->has_expired)
396     validity = ((validity & (~TRUST_MASK | TRUST_FLAG_PENDING_CHECK))
397                 | TRUST_EXPIRED);
398
399   if (main_pk != pk && !kb)
400     free_public_key (main_pk);
401   return validity;
402 }
403
404
405 int
406 get_validity_info (ctrl_t ctrl, kbnode_t kb, PKT_public_key *pk,
407                    PKT_user_id *uid)
408 {
409   int trustlevel;
410
411   if (kb && pk)
412     log_assert (keyid_cmp (pk_main_keyid (pk),
413                            pk_main_keyid (kb->pkt->pkt.public_key)) == 0);
414
415   if (! pk && kb)
416     pk = kb->pkt->pkt.public_key;
417   if (!pk)
418     return '?';  /* Just in case a NULL PK is passed.  */
419
420   trustlevel = get_validity (ctrl, kb, pk, uid, NULL, 0);
421   if ((trustlevel & TRUST_FLAG_REVOKED))
422     return 'r';
423   return trust_letter (trustlevel);
424 }
425
426
427 const char *
428 get_validity_string (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid)
429 {
430   int trustlevel;
431
432   if (!pk)
433     return "err";  /* Just in case a NULL PK is passed.  */
434
435   trustlevel = get_validity (ctrl, NULL, pk, uid, NULL, 0);
436   if ((trustlevel & TRUST_FLAG_REVOKED))
437     return _("revoked");
438   return trust_value_to_string (trustlevel);
439 }