Line data    Source code

       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * checksum_helper.c
       4             :  *    Compute a checksum of any of various types using common routines
       5             :  *
       6             :  * Portions Copyright (c) 2016-2025, PostgreSQL Global Development Group
       7             :  *
       8             :  * IDENTIFICATION
       9             :  *        src/common/checksum_helper.c
      10             :  *
      11             :  *-------------------------------------------------------------------------
      12             :  */
      13             : 
      14             : #ifndef FRONTEND
      15             : #include "postgres.h"
      16             : #else
      17             : #include "postgres_fe.h"
      18             : #endif
      19             : 
      20             : #include "common/checksum_helper.h"
      21             : 
      22             : /*
      23             :  * If 'name' is a recognized checksum type, set *type to the corresponding
      24             :  * constant and return true. Otherwise, set *type to CHECKSUM_TYPE_NONE and
      25             :  * return false.
      26             :  */
      27             : bool
      28      226776 : pg_checksum_parse_type(char *name, pg_checksum_type *type)
      29             : {
      30      226776 :     pg_checksum_type result_type = CHECKSUM_TYPE_NONE;
      31      226776 :     bool        result = true;
      32             : 
      33      226776 :     if (pg_strcasecmp(name, "none") == 0)
      34           6 :         result_type = CHECKSUM_TYPE_NONE;
      35      226770 :     else if (pg_strcasecmp(name, "crc32c") == 0)
      36      209314 :         result_type = CHECKSUM_TYPE_CRC32C;
      37       17456 :     else if (pg_strcasecmp(name, "sha224") == 0)
      38        5816 :         result_type = CHECKSUM_TYPE_SHA224;
      39       11640 :     else if (pg_strcasecmp(name, "sha256") == 0)
      40        3878 :         result_type = CHECKSUM_TYPE_SHA256;
      41        7762 :     else if (pg_strcasecmp(name, "sha384") == 0)
      42        3878 :         result_type = CHECKSUM_TYPE_SHA384;
      43        3884 :     else if (pg_strcasecmp(name, "sha512") == 0)
      44        3878 :         result_type = CHECKSUM_TYPE_SHA512;
      45             :     else
      46           6 :         result = false;
      47             : 
      48      226776 :     *type = result_type;
      49      226776 :     return result;
      50             : }
      51             : 
      52             : /*
      53             :  * Get the canonical human-readable name corresponding to a checksum type.
      54             :  */
      55             : char *
      56      323102 : pg_checksum_type_name(pg_checksum_type type)
      57             : {
      58      323102 :     switch (type)
      59             :     {
      60           0 :         case CHECKSUM_TYPE_NONE:
      61           0 :             return "NONE";
      62      305670 :         case CHECKSUM_TYPE_CRC32C:
      63      305670 :             return "CRC32C";
      64        5810 :         case CHECKSUM_TYPE_SHA224:
      65        5810 :             return "SHA224";
      66        3874 :         case CHECKSUM_TYPE_SHA256:
      67        3874 :             return "SHA256";
      68        3874 :         case CHECKSUM_TYPE_SHA384:
      69        3874 :             return "SHA384";
      70        3874 :         case CHECKSUM_TYPE_SHA512:
      71        3874 :             return "SHA512";
      72             :     }
      73             : 
      74             :     Assert(false);
      75           0 :     return "???";
      76             : }
      77             : 
      78             : /*
      79             :  * Initialize a checksum context for checksums of the given type.
      80             :  * Returns 0 for a success, -1 for a failure.
      81             :  */
      82             : int
      83      460782 : pg_checksum_init(pg_checksum_context *context, pg_checksum_type type)
      84             : {
      85      460782 :     context->type = type;
      86             : 
      87      460782 :     switch (type)
      88             :     {
      89       29706 :         case CHECKSUM_TYPE_NONE:
      90             :             /* do nothing */
      91       29706 :             break;
      92      396206 :         case CHECKSUM_TYPE_CRC32C:
      93      396206 :             INIT_CRC32C(context->raw_context.c_crc32c);
      94      396206 :             break;
      95       11614 :         case CHECKSUM_TYPE_SHA224:
      96       11614 :             context->raw_context.c_sha2 = pg_cryptohash_create(PG_SHA224);
      97       11614 :             if (context->raw_context.c_sha2 == NULL)
      98           0 :                 return -1;
      99       11614 :             if (pg_cryptohash_init(context->raw_context.c_sha2) < 0)
     100             :             {
     101           0 :                 pg_cryptohash_free(context->raw_context.c_sha2);
     102           0 :                 return -1;
     103             :             }
     104       11614 :             break;
     105        7768 :         case CHECKSUM_TYPE_SHA256:
     106        7768 :             context->raw_context.c_sha2 = pg_cryptohash_create(PG_SHA256);
     107        7768 :             if (context->raw_context.c_sha2 == NULL)
     108           0 :                 return -1;
     109        7768 :             if (pg_cryptohash_init(context->raw_context.c_sha2) < 0)
     110             :             {
     111           0 :                 pg_cryptohash_free(context->raw_context.c_sha2);
     112           0 :                 return -1;
     113             :             }
     114        7768 :             break;
     115        7744 :         case CHECKSUM_TYPE_SHA384:
     116        7744 :             context->raw_context.c_sha2 = pg_cryptohash_create(PG_SHA384);
     117        7744 :             if (context->raw_context.c_sha2 == NULL)
     118           0 :                 return -1;
     119        7744 :             if (pg_cryptohash_init(context->raw_context.c_sha2) < 0)
     120             :             {
     121           0 :                 pg_cryptohash_free(context->raw_context.c_sha2);
     122           0 :                 return -1;
     123             :             }
     124        7744 :             break;
     125        7744 :         case CHECKSUM_TYPE_SHA512:
     126        7744 :             context->raw_context.c_sha2 = pg_cryptohash_create(PG_SHA512);
     127        7744 :             if (context->raw_context.c_sha2 == NULL)
     128           0 :                 return -1;
     129        7744 :             if (pg_cryptohash_init(context->raw_context.c_sha2) < 0)
     130             :             {
     131           0 :                 pg_cryptohash_free(context->raw_context.c_sha2);
     132           0 :                 return -1;
     133             :             }
     134        7744 :             break;
     135             :     }
     136             : 
     137      460782 :     return 0;
     138             : }
     139             : 
     140             : /*
     141             :  * Update a checksum context with new data.
     142             :  * Returns 0 for a success, -1 for a failure.
     143             :  */
     144             : int
     145      685734 : pg_checksum_update(pg_checksum_context *context, const uint8 *input,
     146             :                    size_t len)
     147             : {
     148      685734 :     switch (context->type)
     149             :     {
     150       26434 :         case CHECKSUM_TYPE_NONE:
     151             :             /* do nothing */
     152       26434 :             break;
     153      622416 :         case CHECKSUM_TYPE_CRC32C:
     154      622416 :             COMP_CRC32C(context->raw_context.c_crc32c, input, len);
     155      622416 :             break;
     156       36884 :         case CHECKSUM_TYPE_SHA224:
     157             :         case CHECKSUM_TYPE_SHA256:
     158             :         case CHECKSUM_TYPE_SHA384:
     159             :         case CHECKSUM_TYPE_SHA512:
     160       36884 :             if (pg_cryptohash_update(context->raw_context.c_sha2, input, len) < 0)
     161           0 :                 return -1;
     162       36884 :             break;
     163             :     }
     164             : 
     165      685734 :     return 0;
     166             : }
     167             : 
     168             : /*
     169             :  * Finalize a checksum computation and write the result to an output buffer.
     170             :  *
     171             :  * The caller must ensure that the buffer is at least PG_CHECKSUM_MAX_LENGTH
     172             :  * bytes in length. The return value is the number of bytes actually written,
     173             :  * or -1 for a failure.
     174             :  */
     175             : int
     176      431074 : pg_checksum_final(pg_checksum_context *context, uint8 *output)
     177             : {
     178      431074 :     int         retval = 0;
     179             : 
     180             :     StaticAssertDecl(sizeof(pg_crc32c) <= PG_CHECKSUM_MAX_LENGTH,
     181             :                      "CRC-32C digest too big for PG_CHECKSUM_MAX_LENGTH");
     182             :     StaticAssertDecl(PG_SHA224_DIGEST_LENGTH <= PG_CHECKSUM_MAX_LENGTH,
     183             :                      "SHA224 digest too big for PG_CHECKSUM_MAX_LENGTH");
     184             :     StaticAssertDecl(PG_SHA256_DIGEST_LENGTH <= PG_CHECKSUM_MAX_LENGTH,
     185             :                      "SHA256 digest too big for PG_CHECKSUM_MAX_LENGTH");
     186             :     StaticAssertDecl(PG_SHA384_DIGEST_LENGTH <= PG_CHECKSUM_MAX_LENGTH,
     187             :                      "SHA384 digest too big for PG_CHECKSUM_MAX_LENGTH");
     188             :     StaticAssertDecl(PG_SHA512_DIGEST_LENGTH <= PG_CHECKSUM_MAX_LENGTH,
     189             :                      "SHA512 digest too big for PG_CHECKSUM_MAX_LENGTH");
     190             : 
     191      431074 :     switch (context->type)
     192             :     {
     193           4 :         case CHECKSUM_TYPE_NONE:
     194           4 :             break;
     195      396202 :         case CHECKSUM_TYPE_CRC32C:
     196      396202 :             FIN_CRC32C(context->raw_context.c_crc32c);
     197      396202 :             retval = sizeof(pg_crc32c);
     198      396202 :             memcpy(output, &context->raw_context.c_crc32c, retval);
     199      396202 :             break;
     200       11614 :         case CHECKSUM_TYPE_SHA224:
     201       11614 :             retval = PG_SHA224_DIGEST_LENGTH;
     202       11614 :             if (pg_cryptohash_final(context->raw_context.c_sha2,
     203             :                                     output, retval) < 0)
     204           0 :                 return -1;
     205       11614 :             pg_cryptohash_free(context->raw_context.c_sha2);
     206       11614 :             break;
     207        7766 :         case CHECKSUM_TYPE_SHA256:
     208        7766 :             retval = PG_SHA256_DIGEST_LENGTH;
     209        7766 :             if (pg_cryptohash_final(context->raw_context.c_sha2,
     210             :                                     output, retval) < 0)
     211           0 :                 return -1;
     212        7766 :             pg_cryptohash_free(context->raw_context.c_sha2);
     213        7766 :             break;
     214        7744 :         case CHECKSUM_TYPE_SHA384:
     215        7744 :             retval = PG_SHA384_DIGEST_LENGTH;
     216        7744 :             if (pg_cryptohash_final(context->raw_context.c_sha2,
     217             :                                     output, retval) < 0)
     218           0 :                 return -1;
     219        7744 :             pg_cryptohash_free(context->raw_context.c_sha2);
     220        7744 :             break;
     221        7744 :         case CHECKSUM_TYPE_SHA512:
     222        7744 :             retval = PG_SHA512_DIGEST_LENGTH;
     223        7744 :             if (pg_cryptohash_final(context->raw_context.c_sha2,
     224             :                                     output, retval) < 0)
     225           0 :                 return -1;
     226        7744 :             pg_cryptohash_free(context->raw_context.c_sha2);
     227        7744 :             break;
     228             :     }
     229             : 
     230      431074 :     Assert(retval <= PG_CHECKSUM_MAX_LENGTH);
     231      431074 :     return retval;
     232             : }