bcrypt.hpp

Go to the documentation of this file.

//---------------------------------------------------------------------------//
// Copyright (c) 2018-2020 Mikhail Komarov <nemo@nil.foundation>
//
// MIT License
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//---------------------------------------------------------------------------//
 
#ifndef CRYPTO3_PASSHASH_BCRYPT_HPP
#define CRYPTO3_PASSHASH_BCRYPT_HPP
 
#include <nil/crypto3/passhash/detail/bcrypt/bcrypt_functions.hpp>
 
#include <nil/crypto3/utilities/types.hpp>
 
#include <string>
 
namespace nil {
    namespace crypto3 {
        namespace block {
            class blowfish;
        }
        namespace passhash {
            template<typename BlockCipher = block::blowfish>
            class bcrypt {
                typedef detail::bcrypt_functions<BlockCipher> policy_type;
 
            public:
                typedef typename policy_type::cipher_type cipher_type;
 
                static void generate(const std::string &pass, const std::vector<uint8_t> &salt, uint16_t work_factor) {
                    // Include the trailing NULL byte, so we need c_str() not data()
                    blowfish.eks_key_schedule(cast_char_ptr_to_uint8(pass.c_str()), pass.length() + 1, salt.data(),
                                              work_factor);
 
                    std::vector<uint8_t> ctext(BCRYPT_MAGIC, BCRYPT_MAGIC + 8 * 3);
 
                    for (size_t i = 0; i != 64; ++i) {
                        blowfish.encrypt_n(ctext.data(), ctext.data(), 3);
                    }
 
                    std::string salt_b64 = bcrypt_base64_encode(salt.data(), salt.size());
 
                    std::string work_factor_str = std::to_string(work_factor);
                    if (work_factor_str.length() == 1) {
                        work_factor_str = "0" + work_factor_str;
                    }
 
                    return "$2a$" + work_factor_str + "$" + salt_b64.substr(0, 22)
                           + bcrypt_base64_encode(ctext.data(), ctext.size() - 1);
                }
 
                static bool check(const std::string &pass, const std::string &hash) const {
                    if (hash.size() != 60 || hash[0] != '$' || hash[1] != '2' || hash[2] != 'a' || hash[3] != '$'
                        || hash[6] != '$') {
                        return false;
                    }
 
                    const uint16_t workfactor = to_uint16(hash.substr(4, 2));
 
                    const std::vector<uint8_t> salt = bcrypt_base64_decode(hash.substr(7, 22));
                    if (salt.size() != 16) {
                        return false;
                    }
 
                    const std::string compare = generate(pass, salt, workfactor);
 
                    return same_mem(hash.data(), compare.data(), compare.size());
                }
            };
        }    // namespace passhash
 
        template<typename UniformRandomGenerator>
        std::string generate_bcrypt(const std::string &password, UniformRandomGenerator &rng,
                                    uint16_t work_factor = 10) {
            return make_bcrypt(password, unlock(rng.random_vec(16)), work_factor);
        }
 
        bool check_bcrypt(const std::string &password, const std::string &hash);
    }    // namespace crypto3
}    // namespace nil
 
#endif