rgw:cksum: implement crc64nvme and combined 32- and 64-bit CRCs

* internally compensate for at-rest byteswapped crc64 representation (e.g., before combine step)
* generalize Cksum crc api for 32bit and 64bit crcs, other cleanup
* prototype abstract cksum::Combiner workflow
* add support for forward and backward handling of composite vs full object checksums
  by marking the composites and the update flag day
* clean up checksum formatting and checksum type reporting
* add unit tests for Combiner interface
* validate and track requested checksum type (i.e., composite or full), plus
  unit test fixture for combinations of full matrix of cksum types
* doh.  GET/HEAD checksums are in headers
* add crcany license to COPYING
* return ChecksumType as header in GET/HEAD

    Found by Casey in review

* avoid fmt of char* null when no checksum header supplied

    A cksum_hdr_t(nullptr, nullptr) results in this case, and is intended,
    but its components obviously can't be presented to std::format unless
    cast to a safe pointer type.

* fail checksum mismatch with BadDigest

    When uploading an S3 object with an invalid checksum, the return code
    should be BadDigest to mirror more closely the AWS S3 implementation.
    See: https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html

    Fixes: https://tracker.ceph.com/issues/70614

    Reported by Alex Wojno <[email protected]>

* fix comparison and display of composite checksums

A string comparision bounds error and a bitmask comparison
    error are fixed.

* fix build on centos9

On gcc(?13?) we can't declare rgw::cksum::FLAG_NONE
    and also rgw::cksum::Cksum::FlAG_NONE.

    SAD!!

* include <variant> invariantly

* fix checksum type return from complete-multipart

    This one is in the XML response

* aieee, don't leak Combiners

   Use unique_ptr to polymorphic type...correctly.

Signed-off-by: Matt Benjamin <[email protected]>

Author: mattbenjamin

COPYING

@@ -224,3 +224,26 @@ License: GNU Affero General Public License, Version 3
 Files: src/common/*s390x*
 Copyright: 2024 IBM <[email protected]>
 License: Apache License, version 2.0
+
+Files: src/rgw/madler/*
+License:
+  Copyright (C) 2014-2025 Mark Adler
+
+  This software is provided 'as-is', without any express or implied warranty.
+  In no event will the authors be held liable for any damages arising from the
+  use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not claim
+     that you wrote the original software. If you use this software in a
+     product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Mark Adler
+  [email protected]

src/rgw/CMakeLists.txt

@@ -57,6 +57,9 @@ set(librgw_common_srcs
   services/svc_zone.cc
   services/svc_zone_utils.cc
   spdk/crc64.c
+  madler/crc64nvme.c
+  madler/crc32iso_hdlc.c
+  madler/crc32iscsi.c
   rgw_account.cc
   rgw_acl.cc
   rgw_acl_s3.cc
@@ -71,6 +74,7 @@ set(librgw_common_srcs
   rgw_bucket.cc
   rgw_bucket_layout.cc
   rgw_cache.cc
+  rgw_cksum.cc
   rgw_cksum_pipe.cc
   rgw_common.cc
   rgw_compression.cc

src/rgw/driver/rados/rgw_sal_rados.cc

@@ -3841,6 +3841,7 @@ int RadosMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y,
     multipart_upload_info upload_info;
     upload_info.dest_placement = dest_placement;
     upload_info.cksum_type = cksum_type;
+    upload_info.cksum_flags = cksum_flags;
 
     if (obj_legal_hold) {
       upload_info.obj_legal_hold_exist = true;
@@ -4256,6 +4257,7 @@ int RadosMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield
     return -EIO;
   }
   cksum_type = upload_info.cksum_type;
+  cksum_flags = upload_info.cksum_flags;
   placement = upload_info.dest_placement;
   upload_information = upload_info;
   *rule = &placement;

src/rgw/rgw_cksum.cc

@@ -0,0 +1,157 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab ft=cpp
+
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright contributors to the Ceph project
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation.  See file COPYING.
+ *
+ */
+
+#include "rgw_cksum.h"
+#include "rgw_cksum_digest.h"
+#include <cstdint>
+#include <memory>
+#include "rgw_crc_digest.h"
+
+extern "C" {
+#include "madler/crc64nvme.h"
+#include "madler/crc32iso_hdlc.h"
+#include "madler/crc32iscsi.h"
+#include "spdk/crc64.h"
+} // extern "C"
+
+namespace rgw::cksum {
+
+  std::optional<Cksum>
+  combine_crc_cksum(const Cksum& ck1, const Cksum& ck2, uintmax_t len1)
+  {
+    std::optional<rgw::cksum::Cksum> ck3;
+    if ((ck1.type != ck2.type) ||
+	!ck1.crc()) {
+      goto out;
+    }
+
+    switch(ck1.type) {
+    case cksum::Type::crc64nvme:
+      {
+	/* due to AWS (and other) convention, the at-rest
+	 * digest is byteswapped (on LE?);  restore the
+	 * defined byte order before combining */
+	auto cck1 =
+	  rgw::digest::byteswap(std::get<uint64_t>(*ck1.get_crc()));
+	auto cck2 =
+	  rgw::digest::byteswap(std::get<uint64_t>(*ck2.get_crc()));
+	/* madler crcany */
+	auto cck3 = crc64nvme_comb(cck1, cck2, len1);
+	/* and byteswap */
+	cck3 = rgw::digest::byteswap(cck3);
+	/* convert to a Cksum, no ascii armor */
+	ck3 = Cksum(ck1.type, (char*) &cck3, Cksum::CtorStyle::raw);
+      }
+      break;
+    case cksum::Type::crc32:
+    case cksum::Type::crc32c:
+      {
+	uint32_t cck3;
+	auto cck1 =
+	  rgw::digest::byteswap(std::get<uint32_t>(*ck1.get_crc()));
+	auto cck2 =
+	  rgw::digest::byteswap(std::get<uint32_t>(*ck2.get_crc()));
+	/* madler crcany */
+	switch (ck1.type) {
+	case cksum::Type::crc32:
+	  cck3 =  crc32iso_hdlc_comb(cck1, cck2, len1);
+	  break;
+	case cksum::Type::crc32c:
+	  cck3 =  crc32iscsi_comb(cck1, cck2, len1);
+	  break;
+	default:
+	  break;
+	}
+        /* and byteswap */
+	cck3 = rgw::digest::byteswap(cck3);
+	/* convert to a Cksum, no ascii armor */
+	ck3 = Cksum(ck1.type, (char*) &cck3, Cksum::CtorStyle::raw);
+      }
+      break;
+    default:
+      break;
+    };
+
+  out:
+    return ck3;
+  }
+
+  /* the checksum of the final object is a checksum (of the same type,
+   * presumably) of the concatenated checksum bytes of the parts, plus
+   * "-<num-parts>.  See
+   * https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums
+   */
+  class DigestCombiner : public Combiner
+  {
+    DigestVariant dv;
+    Digest* digest{nullptr};
+
+  public:
+    DigestCombiner(cksum::Type t)
+      : Combiner(t),
+	dv(digest_factory(t)),
+	digest(get_digest(dv))
+    {}
+    virtual void append(const Cksum& cksum, uint64_t ignored) {
+      auto ckr = cksum.raw();
+      digest->Update((unsigned char *)ckr.data(), ckr.length());
+    }
+    virtual Cksum final() {
+      auto cksum = finalize_digest(digest, get_type());
+      cksum.flags |= Cksum::COMPOSITE_MASK;
+      return cksum;
+    }
+  }; /* Digest */
+
+  /* the checksum of the final object is an "ordinary" (full object) checksum,
+   * synthesized from the CRCs of the component checksums
+   */
+  class CRCCombiner : public Combiner
+  {
+    Cksum cksum;
+    bool once{false};
+  public:
+    CRCCombiner(cksum::Type t)
+      : Combiner(t)
+    {}
+    virtual void append(const Cksum& rhs, uint64_t part_size) {
+      if (! once) {
+	// save the first part checksum
+	cksum = rhs;
+	once = true;
+      } else {
+	// combine the next partial checksum into cksum
+	cksum = *combine_crc_cksum(cksum, rhs, part_size);
+      }
+    }
+    virtual Cksum final() {
+      cksum.flags |= Cksum::FULL_OBJECT_MASK;
+      return cksum;
+    }
+  }; /* CRCCombine */
+
+  std::unique_ptr<Combiner> CombinerFactory(cksum::Type t, uint16_t flags)
+  {
+    switch(t) {
+    case cksum::Type::crc32:
+    case cksum::Type::crc32c:
+    case cksum::Type::crc64nvme:
+      return std::unique_ptr<Combiner>(new CRCCombiner(t));
+    default:
+      return std::unique_ptr<Combiner>(new DigestCombiner(t));
+    };
+  }
+
+} // namespace rgw::cksum