Scrypt.hpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac
 
    This file is part of Leosac.
 
    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Leosac is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Affero General Public License for more details.
 
    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include <cstdlib>
extern "C" {
#include <libscrypt.h>
}
 
#include <boost/algorithm/hex.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <vector>
 
struct ScryptParam
{
    bool operator==(const ScryptParam &o) const;
 
    uint64_t N;
    uint32_t r;
    uint32_t p;
    uint32_t len;
};
 
struct ScryptResult
{
    bool operator==(const ScryptResult &o) const;
    bool operator!=(const ScryptResult &o) const;
 
    ScryptParam p;
 
    std::vector<uint8_t> salt;
 
    std::vector<uint8_t> hash;
};
 
template <typename SerializedType>
class ScryptResultSerializer
{
  public:
    virtual SerializedType Serialize(const ScryptResult &in) const   = 0;
    virtual ScryptResult UnSerialize(const SerializedType &in) const = 0;
 
    static std::string Hex(const std::vector<uint8_t> &in)
    {
        std::string res;
        boost::algorithm::hex(in.begin(), in.end(), back_inserter(res));
        return res;
    }
 
    static std::vector<uint8_t> UnHex(const std::string &in)
    {
        std::vector<uint8_t> res;
        boost::algorithm::unhex(in.begin(), in.end(), back_inserter(res));
        return res;
    }
 
    static std::vector<uint8_t> ToByteVector(const std::string &in)
    {
        return std::vector<uint8_t>(in.begin(), in.end());
    }
};
 
class StringScryptResultSerializer : public ScryptResultSerializer<std::string>
{
  public:
    virtual std::string Serialize(const ScryptResult &in) const override
    {
        std::stringstream ss;
        ss << in.p.N << ":";
        ss << in.p.r << ":";
        ss << in.p.p << ":";
        ss << Hex(in.salt) << ":";
        ss << Hex(in.hash);
 
        return ss.str();
    }
 
    virtual ScryptResult UnSerialize(const std::string &in) const override
    {
        ScryptResult result;
        std::vector<std::string> bla;
        boost::algorithm::split(bla, in, boost::algorithm::is_any_of(":"));
 
        if (bla.size() != 5)
            throw std::runtime_error("Cannot unserialize.");
 
        result.p.N   = std::stoi(bla[0]);
        result.p.r   = std::stoi(bla[1]);
        result.p.p   = std::stoi(bla[2]);
        result.salt  = UnHex(bla[3]);
        result.hash  = UnHex(bla[4]);
        result.p.len = result.hash.size();
 
        return result;
    }
};
 
class Scrypt
{
  public:
    static ScryptResult Hash(const std::vector<uint8_t> &in,
                             const std::vector<uint8_t> &salt,
                             const ScryptParam &param = default_);
 
    static ScryptResult Hash(const std::vector<uint8_t> &in,
                             const ScryptParam &param = default_);
 
    static bool Verify(const std::vector<uint8_t> &in, const ScryptResult &expected);
 
  private:
    static ScryptParam default_;
};