auth.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
#pragma once
 
#include <sshpp/config.hpp>
 
#include <sshpp/auth_types.hpp>
#include <sshpp/detail/session_core.hpp>
#include <sshpp/export.hpp>
#include <sshpp/key.hpp>
#include <sshpp/result.hpp>
#include <sshpp/types.hpp>
 
#include <memory>
#include <string_view>
#include <vector>
#include <filesystem>
 
namespace sshpp {
 
class SSHPP_API Authenticator {
public:
    virtual ~Authenticator() = default;
    virtual std::string_view name() const noexcept = 0;
    virtual Result<AuthStatus> attempt(detail::SessionCore&) const noexcept = 0;
};
 
namespace auth {
 
class SSHPP_API None final : public Authenticator {
public:
    std::string_view name() const noexcept override { return "none"; }
    Result<AuthStatus> attempt(detail::SessionCore&) const noexcept override;
};
 
class SSHPP_API Password final : public Authenticator {
public:
    explicit Password(SecureString password) : password_(std::move(password)) {}
 
    std::string_view name() const noexcept override { return "password"; }
    Result<AuthStatus> attempt(detail::SessionCore&) const noexcept override;
 
private:
    SecureString password_;
};
 
class SSHPP_API PublicKeyAuto final : public Authenticator {
public:
    PublicKeyAuto() = default;
    explicit PublicKeyAuto(SecureString passphrase) : passphrase_(std::move(passphrase)) {}
 
    std::string_view name() const noexcept override { return "publickey_auto"; }
    Result<AuthStatus> attempt(detail::SessionCore&) const noexcept override;
 
private:
    SecureString passphrase_;
};
 
class SSHPP_API PublicKey final : public Authenticator {
public:
    explicit PublicKey(Key private_key) : key_(std::move(private_key)) {}
 
    static Result<PublicKey> from_file(const std::filesystem::path& p, PassphraseCallback cb = {});
 
    std::string_view name() const noexcept override { return "publickey"; }
    Result<AuthStatus> attempt(detail::SessionCore&) const noexcept override;
 
private:
    Key key_;
};
 
class SSHPP_API Agent final : public Authenticator {
public:
    std::string_view name() const noexcept override { return "agent"; }
    Result<AuthStatus> attempt(detail::SessionCore&) const noexcept override;
};
 
class SSHPP_API KeyboardInteractive final : public Authenticator {
public:
    struct Prompt { std::string text; bool echo; };
    struct Challenge {
        std::string name, instruction;
        std::vector<Prompt> prompts;
    };
    using Handler = std::function<Result<std::vector<SecureString>>(const Challenge&)>;
 
    explicit KeyboardInteractive(Handler h) : handler_(std::move(h)) {}
 
    static KeyboardInteractive with_password(SecureString password);
#if SSHPP_WITH_CONSOLE
    static Handler console_handler();
#endif
 
    std::string_view name() const noexcept override { return "keyboard-interactive"; }
    Result<AuthStatus> attempt(detail::SessionCore&) const noexcept override;
 
private:
    Handler handler_;
};
 
class SSHPP_API Chain final : public Authenticator {
public:
    Chain& add(std::shared_ptr<Authenticator> a) { chain_.push_back(std::move(a)); return *this; }
 
    template <class A, class... Args>
    Chain& emplace(Args&&... args) {
        return add(std::make_shared<A>(std::forward<Args>(args)...));
    }
 
#if SSHPP_WITH_CONSOLE
    static Chain interactive_default(PassphraseCallback passphrase_cb, PasswordCallback password_cb);
#endif
 
    std::string_view name() const noexcept override { return "chain"; }
    Result<AuthStatus> attempt(detail::SessionCore&) const noexcept override;
 
private:
    std::vector<std::shared_ptr<Authenticator>> chain_;
};
 
#if SSHPP_WITH_CONSOLE
SSHPP_API Result<SecureString> console_password_prompt(std::string_view prompt = "Password: ");
SSHPP_API PassphraseCallback console_passphrase_prompt();
SSHPP_API PasswordCallback console_password_callback();
#endif
 
} // namespace auth
} // namespace sshpp
 
#if SSHPP_HEADER_ONLY
#include <sshpp/detail/auth.ipp>
#endif