root/lib/common/digest.c

/* */

DEFINITIONS

1. dump_xml_for_digest
2. calculate_xml_digest_v1
3. calculate_xml_digest_v2
4. calculate_on_disk_digest
5. calculate_operation_digest
6. calculate_xml_versioned_digest
7. pcmk__verify_digest
8. pcmk__xa_filterable
9. crm_md5sum

   1 /*
   2  * Copyright 2015-2022 the Pacemaker project contributors
   3  *
   4  * The version control history for this file may have further details.
   5  *
   6  * This source code is licensed under the GNU Lesser General Public License
   7  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
   8  */
   9 
  10 #include <crm_internal.h>
  11 
  12 #include <stdio.h>
  13 #include <unistd.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16 #include <md5.h>
  17 
  18 #include <crm/crm.h>
  19 #include <crm/msg_xml.h>
  20 #include <crm/common/xml.h>
  21 #include "crmcommon_private.h"
  22 
  23 #define BEST_EFFORT_STATUS 0
  24 
  25 /*!
  26  * \internal
  27  * \brief Dump XML in a format used with v1 digests
  28  *
  29  * \param[in] xml  Root of XML to dump
  30  *
  31  * \return Newly allocated buffer containing dumped XML
  32  */
  33 static GString *
  34 dump_xml_for_digest(xmlNodePtr xml)
     /*  */
  35 {
  36     GString *buffer = g_string_sized_new(1024);
  37 
  38     /* for compatibility with the old result which is used for v1 digests */
  39     g_string_append_c(buffer, ' ');
  40     pcmk__xml2text(xml, 0, buffer, 0);
  41     g_string_append_c(buffer, '\n');
  42 
  43     return buffer;
  44 }
  45 
  46 /*!
  47  * \brief Calculate and return v1 digest of XML tree
  48  *
  49  * \param[in] input Root of XML to digest
  50  * \param[in] sort Whether to sort the XML before calculating digest
  51  * \param[in] ignored Not used
  52  *
  53  * \return Newly allocated string containing digest
  54  * \note Example return value: "c048eae664dba840e1d2060f00299e9d"
  55  */
  56 static char *
  57 calculate_xml_digest_v1(xmlNode *input, gboolean sort, gboolean ignored)
     /*  */
  58 {
  59     char *digest = NULL;
  60     GString *buffer = NULL;
  61     xmlNode *copy = NULL;
  62 
  63     if (sort) {
  64         crm_trace("Sorting xml...");
  65         copy = sorted_xml(input, NULL, TRUE);
  66         crm_trace("Done");
  67         input = copy;
  68     }
  69 
  70     buffer = dump_xml_for_digest(input);
  71     CRM_CHECK(buffer->len > 0, free_xml(copy);
  72               g_string_free(buffer, TRUE);
  73               return NULL);
  74 
  75     digest = crm_md5sum((const char *) buffer->str);
  76     crm_log_xml_trace(input, "digest:source");
  77 
  78     g_string_free(buffer, TRUE);
  79     free_xml(copy);
  80     return digest;
  81 }
  82 
  83 /*!
  84  * \brief Calculate and return v2 digest of XML tree
  85  *
  86  * \param[in] source Root of XML to digest
  87  * \param[in] do_filter Whether to filter certain XML attributes
  88  *
  89  * \return Newly allocated string containing digest
  90  */
  91 static char *
  92 calculate_xml_digest_v2(xmlNode *source, gboolean do_filter)
     /*  */
  93 {
  94     char *digest = NULL;
  95     GString *buffer = g_string_sized_new(1024);
  96 
  97     static struct qb_log_callsite *digest_cs = NULL;
  98 
  99     crm_trace("Begin digest %s", do_filter?"filtered":"");
 100     pcmk__xml2text(source, (do_filter? xml_log_option_filtered : 0), buffer, 0);
 101 
 102     CRM_ASSERT(buffer != NULL);
 103     digest = crm_md5sum((const char *) buffer->str);
 104 
 105     if (digest_cs == NULL) {
 106         digest_cs = qb_log_callsite_get(__func__, __FILE__, "cib-digest", LOG_TRACE, __LINE__,
 107                                         crm_trace_nonlog);
 108     }
 109     if (digest_cs && digest_cs->targets) {
 110         char *trace_file = crm_strdup_printf("%s/digest-%s",
 111                                              pcmk__get_tmpdir(), digest);
 112 
 113         crm_trace("Saving %s.%s.%s to %s",
 114                   crm_element_value(source, XML_ATTR_GENERATION_ADMIN),
 115                   crm_element_value(source, XML_ATTR_GENERATION),
 116                   crm_element_value(source, XML_ATTR_NUMUPDATES), trace_file);
 117         save_xml_to_file(source, "digest input", trace_file);
 118         free(trace_file);
 119     }
 120 
 121     g_string_free(buffer, TRUE);
 122     crm_trace("End digest");
 123     return digest;
 124 }
 125 
 126 /*!
 127  * \brief Calculate and return digest of XML tree, suitable for storing on disk
 128  *
 129  * \param[in] input Root of XML to digest
 130  *
 131  * \return Newly allocated string containing digest
 132  */
 133 char *
 134 calculate_on_disk_digest(xmlNode *input)
     /*  */
 135 {
 136     /* Always use the v1 format for on-disk digests
 137      * a) it's a compatibility nightmare
 138      * b) we only use this once at startup, all other
 139      *    invocations are in a separate child process
 140      */
 141     return calculate_xml_digest_v1(input, FALSE, FALSE);
 142 }
 143 
 144 /*!
 145  * \brief Calculate and return digest of XML operation
 146  *
 147  * \param[in] input    Root of XML to digest
 148  * \param[in] version  Unused
 149  *
 150  * \return Newly allocated string containing digest
 151  */
 152 char *
 153 calculate_operation_digest(xmlNode *input, const char *version)
     /*  */
 154 {
 155     /* We still need the sorting for operation digests */
 156     return calculate_xml_digest_v1(input, TRUE, FALSE);
 157 }
 158 
 159 /*!
 160  * \brief Calculate and return digest of XML tree
 161  *
 162  * \param[in] input      Root of XML to digest
 163  * \param[in] sort       Whether to sort XML before calculating digest
 164  * \param[in] do_filter  Whether to filter certain XML attributes
 165  * \param[in] version    CRM feature set version (used to select v1/v2 digest)
 166  *
 167  * \return Newly allocated string containing digest
 168  */
 169 char *
 170 calculate_xml_versioned_digest(xmlNode *input, gboolean sort,
     /*  */
 171                                gboolean do_filter, const char *version)
 172 {
 173     /*
 174      * @COMPAT digests (on-disk or in diffs/patchsets) created <1.1.4;
 175      * removing this affects even full-restart upgrades from old versions
 176      *
 177      * The sorting associated with v1 digest creation accounted for 23% of
 178      * the CIB manager's CPU usage on the server. v2 drops this.
 179      *
 180      * The filtering accounts for an additional 2.5% and we may want to
 181      * remove it in future.
 182      *
 183      * v2 also uses the xmlBuffer contents directly to avoid additional copying
 184      */
 185     if (version == NULL || compare_version("3.0.5", version) > 0) {
 186         crm_trace("Using v1 digest algorithm for %s",
 187                   pcmk__s(version, "unknown feature set"));
 188         return calculate_xml_digest_v1(input, sort, do_filter);
 189     }
 190     crm_trace("Using v2 digest algorithm for %s",
 191               pcmk__s(version, "unknown feature set"));
 192     return calculate_xml_digest_v2(input, do_filter);
 193 }
 194 
 195 /*!
 196  * \internal
 197  * \brief Check whether calculated digest of given XML matches expected digest
 198  *
 199  * \param[in] input     Root of XML tree to digest
 200  * \param[in] expected  Expected digest in on-disk format
 201  *
 202  * \return true if digests match, false on mismatch or error
 203  */
 204 bool
 205 pcmk__verify_digest(xmlNode *input, const char *expected)
     /*  */
 206 {
 207     char *calculated = NULL;
 208     bool passed;
 209 
 210     if (input != NULL) {
 211         calculated = calculate_on_disk_digest(input);
 212         if (calculated == NULL) {
 213             crm_perror(LOG_ERR, "Could not calculate digest for comparison");
 214             return false;
 215         }
 216     }
 217     passed = pcmk__str_eq(expected, calculated, pcmk__str_casei);
 218     if (passed) {
 219         crm_trace("Digest comparison passed: %s", calculated);
 220     } else {
 221         crm_err("Digest comparison failed: expected %s, calculated %s",
 222                 expected, calculated);
 223     }
 224     free(calculated);
 225     return passed;
 226 }
 227 
 228 /*!
 229  * \internal
 230  * \brief Check whether an XML attribute should be excluded from CIB digests
 231  *
 232  * \param[in] name  XML attribute name
 233  *
 234  * \return true if XML attribute should be excluded from CIB digest calculation
 235  */
 236 bool
 237 pcmk__xa_filterable(const char *name)
     /*  */
 238 {
 239     static const char *filter[] = {
 240         XML_ATTR_ORIGIN,
 241         XML_CIB_ATTR_WRITTEN,
 242         XML_ATTR_UPDATE_ORIG,
 243         XML_ATTR_UPDATE_CLIENT,
 244         XML_ATTR_UPDATE_USER,
 245     };
 246 
 247     for (int i = 0; i < PCMK__NELEM(filter); i++) {
 248         if (strcmp(name, filter[i]) == 0) {
 249             return true;
 250         }
 251     }
 252     return false;
 253 }
 254 
 255 char *
 256 crm_md5sum(const char *buffer)
     /*  */
 257 {
 258     int lpc = 0, len = 0;
 259     char *digest = NULL;
 260     unsigned char raw_digest[MD5_DIGEST_SIZE];
 261 
 262     if (buffer == NULL) {
 263         buffer = "";
 264     }
 265     len = strlen(buffer);
 266 
 267     crm_trace("Beginning digest of %d bytes", len);
 268     digest = malloc(2 * MD5_DIGEST_SIZE + 1);
 269     if (digest) {
 270         md5_buffer(buffer, len, raw_digest);
 271         for (lpc = 0; lpc < MD5_DIGEST_SIZE; lpc++) {
 272             sprintf(digest + (2 * lpc), "%02x", raw_digest[lpc]);
 273         }
 274         digest[(2 * MD5_DIGEST_SIZE)] = 0;
 275         crm_trace("Digest %s.", digest);
 276 
 277     } else {
 278         crm_err("Could not create digest");
 279     }
 280     return digest;
 281 }

/* */