pedersen.cpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Nishat], commit: 8c1bc925461f1ed6f3f53824646c6e971b8c6af6 }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#include "./pedersen.hpp"
#include "../pedersen_commitment/pedersen.hpp"
 
namespace bb::crypto {
 
template <typename Curve>
std::vector<typename Curve::BaseField> pedersen_hash_base<Curve>::convert_buffer(const std::vector<uint8_t>& input)
{
    const size_t num_bytes = input.size();
    const size_t bytes_per_element = 31;
    size_t num_elements = static_cast<size_t>(num_bytes % bytes_per_element != 0) + (num_bytes / bytes_per_element);
 
    const auto slice = [](const std::vector<uint8_t>& data, const size_t start, const size_t slice_size) {
        uint256_t result(0);
        for (size_t i = 0; i < slice_size; ++i) {
            result = (result << uint256_t(8));
            result += uint256_t(data[i + start]);
        }
        return Fq(result);
    };
 
    std::vector<Fq> elements;
    for (size_t i = 0; i < num_elements - 1; ++i) {
        size_t bytes_to_slice = bytes_per_element;
        Fq element = slice(input, i * bytes_per_element, bytes_to_slice);
        elements.emplace_back(element);
    }
    size_t bytes_to_slice = num_bytes - ((num_elements - 1) * bytes_per_element);
    Fq element = slice(input, (num_elements - 1) * bytes_per_element, bytes_to_slice);
    elements.emplace_back(element);
    return elements;
}
 
template <typename Curve>
typename Curve::BaseField pedersen_hash_base<Curve>::hash(const std::vector<Fq>& inputs, const GeneratorContext context)
{
    if (inputs.empty()) {
        throw_or_abort("pedersen hash: empty input");
    }
 
    Element result = length_generator * Fr(inputs.size());
    return (result + pedersen_commitment_base<Curve>::commit_native(inputs, context)).normalize().x;
}
 
template <typename Curve>
typename Curve::BaseField pedersen_hash_base<Curve>::hash_buffer(const std::vector<uint8_t>& input,
                                                                 const GeneratorContext context)
{
    if (input.empty()) {
        throw_or_abort("pedersen hash_buffer: empty input");
    }
 
    std::vector<Fq> converted = convert_buffer(input);
 
    if (converted.size() < 2) {
        return hash(converted, context);
    }
    auto result = hash({ converted[0], converted[1] }, context);
    for (size_t i = 2; i < converted.size(); ++i) {
        result = hash({ result, converted[i] }, context);
    }
    return result;
}
 
template class pedersen_hash_base<curve::Grumpkin>;
} // namespace bb::crypto