/* * Copyright 2021 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef DISTRIBUTED_POINT_FUNCTIONS_DPF_DISTRIBUTED_POINT_FUNCTION_H_ #define DISTRIBUTED_POINT_FUNCTIONS_DPF_DISTRIBUTED_POINT_FUNCTION_H_ #include <algorithm> #include <array> #include <cstddef> #include <cstdint> #include <limits> #include <memory> #include <string> #include <tuple> #include <type_traits> #include <utility> #include <vector> #include "absl/container/btree_map.h" #include "absl/container/flat_hash_map.h" #include "absl/container/inlined_vector.h" #include "absl/log/absl_check.h" #include "absl/meta/type_traits.h" #include "absl/numeric/int128.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/strings/string_view.h" #include "absl/types/span.h" #include "dpf/aes_128_fixed_key_hash.h" #include "dpf/distributed_point_function.pb.h" #include "dpf/internal/evaluate_prg_hwy.h" #include "dpf/internal/maybe_deref_span.h" #include "dpf/internal/proto_validator.h" #include "dpf/internal/value_type_helpers.h" #include "google/protobuf/repeated_ptr_field.h" #include "hwy/aligned_allocator.h" namespace distributed_point_functions { // Type trait for all supported types. Used to provide meaningful error messages // in std::enable_if template guards. is_supported_type; is_supported_type_v; // Converts a given Value to the template parameter T. // // Returns INVALID_ARGUMENT if the conversion fails. template <typename T, typename = absl::enable_if_t<is_supported_type_v<T>>> absl::StatusOr<T> FromValue(const Value& value) { … } // ToValue Converts the argument to a Value. template <typename T, typename = absl::enable_if_t<is_supported_type_v<T>>> Value ToValue(const T& input) { … } // ToValueType<T> Returns a `ValueType` message describing T. template <typename T, typename = absl::enable_if_t<is_supported_type_v<T>>> ValueType ToValueType() { … } // Implements key generation and evaluation of distributed point functions. // A distributed point function (DPF) is parameterized by an index `alpha` and a // value `beta`. The key generation procedure produces two keys `k_a`, `k_b`. // Evaluating each key on any point `x` in the DPF domain results in an additive // secret share of `beta`, if `x == alpha`, and a share of 0 otherwise. This // class also supports *incremental* DPFs that can additionally be evaluated on // prefixes of points, resulting in different values `beta_i`for each prefix of // `alpha`. class DistributedPointFunction { … }; //========================// // Implementation Details // //========================// template <typename T> absl::Status DistributedPointFunction::RegisterValueTypeImpl( absl::flat_hash_map<std::string, ValueCorrectionFunction>& value_correction_functions) { … } template <typename T0, typename... Tn, typename /*= absl::enable_if_t<...>*/> absl::StatusOr<std::pair<DpfKey, DpfKey>> DistributedPointFunction::GenerateKeysIncremental(absl::uint128 alpha, T0&& beta_0, Tn&&... beta_n) { … } template <typename T> absl::StatusOr<std::vector<T>> DistributedPointFunction::EvaluateUntil( int hierarchy_level, absl::Span<const absl::uint128> prefixes, EvaluationContext& ctx) const { … } template <typename T> absl::StatusOr<std::array<T, dpf_internal::ElementsPerBlock<T>()>> DistributedPointFunction::GetValueCorrectionAsArray(const DpfKey& key, int hierarchy_level) const { … } template <typename T> absl::StatusOr<std::vector<T>> DistributedPointFunction::EvaluateAtImpl( const DpfKey& key, int hierarchy_level, absl::Span<const absl::uint128> evaluation_points, EvaluationContext* ctx) const { … } template <typename T, typename Fn> absl::Status DistributedPointFunction::EvaluateAndApply( dpf_internal::MaybeDerefSpan<const DpfKey> keys, absl::Span<const absl::uint128> evaluation_points, Fn op, int evaluation_points_rightshift) const { … } } // namespace distributed_point_functions #endif // DISTRIBUTED_POINT_FUNCTIONS_DPF_DISTRIBUTED_POINT_FUNCTION_H_
Codebase Browser
chromium