couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.0-x86_64-linux

data/ext/couchbase/cbcrypto/cbcrypto.h

@@ -1,89 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2016 Couchbase, Inc.
- *
- *   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.
- */
-#pragma once
-
-#include <gsl/gsl>
-#include <cstdint>
-#include <string>
-
-namespace couchbase::crypto
-{
-enum class Algorithm { SHA1, SHA256, SHA512 };
-
-bool
-isSupported(Algorithm algorithm);
-
-const int SHA1_DIGEST_SIZE = 20;
-const int SHA256_DIGEST_SIZE = 32;
-const int SHA512_DIGEST_SIZE = 64;
-
-/**
- * Generate a HMAC digest of the key and data by using the given
- * algorithm
- *
- * @throws std::invalid_argument - unsupported algorithm
- *         std::runtime_error - Failures generating the HMAC
- */
-std::string
-HMAC(Algorithm algorithm, std::string_view key, std::string_view data);
-
-/**
- * Generate a PBKDF2_HMAC digest of the key and data by using the given
- * algorithm
- *
- * @throws std::invalid_argument - unsupported algorithm
- *         std::runtime_error - Failures generating the HMAC
- */
-std::string
-PBKDF2_HMAC(Algorithm algorithm, const std::string& pass, std::string_view salt, unsigned int iterationCount);
-
-/**
- * Generate a digest by using the requested algorithm
- */
-std::string
-digest(Algorithm algorithm, std::string_view data);
-
-enum class Cipher { AES_256_cbc };
-
-Cipher
-to_cipher(const std::string& str);
-
-/**
- * Encrypt the specified data by using a given cipher
- *
- * @param cipher The cipher to use
- * @param key The key used for encryption
- * @param ivec The IV to use for encryption
- * @param data The Pointer to the data to encrypt
- * @return The encrypted data
- */
-std::string
-encrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data);
-
-/**
- * Decrypt the specified data by using a given cipher
- *
- * @param cipher The cipher to use
- * @param key The key used for encryption
- * @param ivec The IV to use for encryption
- * @param data The data to decrypt
- * @return The decrypted data
- */
-std::string
-decrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data);
-
-} // namespace couchbase::crypto

data/ext/couchbase/cbsasl/client.cc

@@ -1,48 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-
-#include <cbsasl/client.h>
-#include <cbsasl/plain/plain.h>
-#include <cbsasl/scram-sha/scram-sha.h>
-#include <memory>
-
-namespace couchbase::sasl
-{
-
-ClientContext::ClientContext(GetUsernameCallback user_cb, GetPasswordCallback password_cb, const std::vector<std::string>& mechanisms)
-{
-    switch (select_mechanism(mechanisms)) {
-        case Mechanism::SCRAM_SHA512:
-            backend = std::make_unique<mechanism::scram::Sha512ClientBackend>(user_cb, password_cb, *this);
-            break;
-        case Mechanism::SCRAM_SHA256:
-            backend = std::make_unique<mechanism::scram::Sha256ClientBackend>(user_cb, password_cb, *this);
-            break;
-        case Mechanism::SCRAM_SHA1:
-            backend = std::make_unique<mechanism::scram::Sha1ClientBackend>(user_cb, password_cb, *this);
-            break;
-        case Mechanism::PLAIN:
-            backend = std::make_unique<mechanism::plain::ClientBackend>(user_cb, password_cb, *this);
-    }
-
-    if (!backend) {
-        throw unknown_mechanism("cb::sasl::client::ClientContext(): Failed to create "
-                                "mechanism");
-    }
-}
-
-} // namespace couchbase::sasl

data/ext/couchbase/cbsasl/client.h

@@ -1,127 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-
-#pragma once
-
-#include <cbsasl/context.h>
-#include <cbsasl/error.h>
-
-#include <functional>
-#include <memory>
-#include <utility>
-
-namespace couchbase::sasl
-{
-
-class ClientContext;
-
-/**
- * Callback function used for the SASL client to get the username to
- * authenticate as.
- */
-using GetUsernameCallback = std::function<std::string()>;
-/**
- * Callback function used for the SASL client to get the password to
- * authenticate with.
- */
-using GetPasswordCallback = std::function<std::string()>;
-
-/**
- * The base class for the various authentication mechanisms.
- *
- * This class is internal to the CBSASL library, but public in order
- * to allow unit tests to access it.
- */
-class MechanismBackend
-{
-  public:
-    explicit MechanismBackend(GetUsernameCallback user_cb, GetPasswordCallback password_cb, ClientContext& ctx)
-      : usernameCallback(std::move(user_cb))
-      , passwordCallback(std::move(password_cb))
-      , context(ctx)
-    {
-    }
-    virtual ~MechanismBackend() = default;
-    virtual std::pair<error, std::string_view> start() = 0;
-    virtual std::pair<error, std::string_view> step(std::string_view input) = 0;
-    virtual std::string_view get_name() const = 0;
-
-  protected:
-    const GetUsernameCallback usernameCallback;
-    const GetPasswordCallback passwordCallback;
-    ClientContext& context;
-};
-
-/**
- * ClientContext provides the client side API for SASL
- */
-class ClientContext : public Context
-{
-  public:
-    /**
-     * Create a new instance of the ClientContext
-     *
-     * @param user_cb The callback method to fetch the username to
-     *                use in the authentication
-     * @param password_cb The callback method to fetch the password to
-     *                use in the authentication
-     * @param mechanisms The list of available mechanisms provided by
-     *                   the server. The client will pick the most
-     *                   secure method available
-     * @throws couchbase::sasl::no_such_mechanism if none of the mechanisms
-     *                   specified in the list of available mechanisms
-     *                   is supported
-     */
-    ClientContext(GetUsernameCallback user_cb, GetPasswordCallback password_cb, const std::vector<std::string>& mechanisms);
-
-    /**
-     * Get the name of the mechanism in use by this backend.
-     *
-     * @return The name of the chosen authentication method
-     */
-    [[nodiscard]] std::string_view get_name() const
-    {
-        return backend->get_name();
-    }
-
-    /**
-     * Start the authentication
-     *
-     * @return The challenge to send to the server
-     */
-    std::pair<error, std::string_view> start()
-    {
-        return backend->start();
-    }
-
-    /**
-     * Process the response received from the server and generate
-     * another challenge to send to the server.
-     *
-     * @param input The response from the server
-     * @return The challenge to send to the server
-     */
-    std::pair<error, std::string_view> step(std::string_view input)
-    {
-        return backend->step(input);
-    }
-
-  protected:
-    std::unique_ptr<MechanismBackend> backend;
-};
-
-} // namespace couchbase::sasl

data/ext/couchbase/cbsasl/context.cc

@@ -1,33 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-
-#include <cbsasl/context.h>
-#include <platform/uuid.h>
-
-namespace couchbase::sasl
-{
-
-std::string
-Context::get_uuid()
-{
-    if (uuid.empty()) {
-        uuid = uuid::to_string(uuid::random());
-    }
-
-    return uuid;
-}
-} // namespace couchbase::sasl

data/ext/couchbase/cbsasl/context.h

@@ -1,52 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-
-#pragma once
-
-#include <string>
-
-namespace couchbase::sasl
-{
-
-/**
- * An abstract context class to allow a common base class for the
- * client and server context.
- */
-class Context
-{
-  public:
-    virtual ~Context() = default;
-
-    /**
-     * Get the UUID used for errors by this connection. If none
-     * is created a new one is generated.
-     */
-    std::string get_uuid();
-
-    /**
-     * Do this context contain a UUID?
-     */
-    [[nodiscard]] bool contains_uuid() const
-    {
-        return !uuid.empty();
-    }
-
-  protected:
-    std::string uuid;
-};
-
-} // namespace couchbase::sasl

data/ext/couchbase/cbsasl/error.h

@@ -1,72 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-
-#pragma once
-
-#include <spdlog/spdlog.h>
-
-namespace couchbase::sasl
-{
-
-/**
- * The error values used in CBSASL
- */
-enum class error { OK, CONTINUE, FAIL, BAD_PARAM, NO_MEM, NO_MECH, NO_USER, PASSWORD_ERROR, NO_RBAC_PROFILE, AUTH_PROVIDER_DIED };
-
-} // namespace couchbase::sasl
-
-template<>
-struct fmt::formatter<couchbase::sasl::error> : formatter<string_view> {
-    template<typename FormatContext>
-    auto format(couchbase::sasl::error err, FormatContext& ctx)
-    {
-        string_view name = "unknown";
-        switch (err) {
-            case couchbase::sasl::error::OK:
-                name = "ok";
-                break;
-            case couchbase::sasl::error::CONTINUE:
-                name = "continue";
-                break;
-            case couchbase::sasl::error::FAIL:
-                name = "fail";
-                break;
-            case couchbase::sasl::error::BAD_PARAM:
-                name = "bad_param";
-                break;
-            case couchbase::sasl::error::NO_MEM:
-                name = "no_mem";
-                break;
-            case couchbase::sasl::error::NO_MECH:
-                name = "no_mech";
-                break;
-            case couchbase::sasl::error::NO_USER:
-                name = "no_user";
-                break;
-            case couchbase::sasl::error::PASSWORD_ERROR:
-                name = "password_error";
-                break;
-            case couchbase::sasl::error::NO_RBAC_PROFILE:
-                name = "no_rbac_profile";
-                break;
-            case couchbase::sasl::error::AUTH_PROVIDER_DIED:
-                name = "auth_provider_died";
-                break;
-        }
-        return formatter<string_view>::format(name, ctx);
-    }
-};

data/ext/couchbase/cbsasl/mechanism.cc

@@ -1,48 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-
-#include <cbsasl/mechanism.h>
-
-#include <algorithm>
-#include <iterator>
-#include <vector>
-
-namespace couchbase
-{
-namespace sasl
-{
-
-Mechanism
-select_mechanism(const std::vector<std::string>& available_mechanisms)
-{
-    // Search what we've got backends for
-    const std::vector<std::pair<std::string, Mechanism>> mechs = { { std::string{ "SCRAM-SHA512" }, Mechanism::SCRAM_SHA512 },
-                                                                   { std::string{ "SCRAM-SHA256" }, Mechanism::SCRAM_SHA256 },
-                                                                   { std::string{ "SCRAM-SHA1" }, Mechanism::SCRAM_SHA1 },
-                                                                   { std::string{ "PLAIN" }, Mechanism::PLAIN } };
-
-    for (const auto& mechanism : mechs) {
-        if (std::find(available_mechanisms.begin(), available_mechanisms.end(), mechanism.first) != available_mechanisms.end()) {
-            return mechanism.second;
-        }
-    }
-
-    throw unknown_mechanism("unknown mechanism"); // TODO: avoid this exception
-}
-
-} // namespace sasl
-} // namespace couchbase

data/ext/couchbase/cbsasl/mechanism.h

@@ -1,55 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-
-#pragma once
-
-#include <cbsasl/error.h>
-
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-namespace couchbase::sasl
-{
-
-enum class Mechanism { SCRAM_SHA512, SCRAM_SHA256, SCRAM_SHA1, PLAIN };
-
-class unknown_mechanism : public std::invalid_argument
-{
-  public:
-    explicit unknown_mechanism(const std::string& msg)
-      : std::invalid_argument(msg)
-    {
-    }
-};
-
-/**
- * Select a mechanism from one of the listed of mechanisms. This
- * method will pick the "most secure" mechanism.
- *
- * @param available_mechanisms the list of mechanisms to choose from
- * @return the mechanism to use
- * @throws unknown_mechanism if no supported mechanism is listed in the
- *                           available mechanisms
- */
-Mechanism
-select_mechanism(const std::vector<std::string>& available_mechanisms);
-
-} // namespace couchbase::sasl
-
-std::string
-to_string(couchbase::sasl::Mechanism mechanism);

data/ext/couchbase/cbsasl/plain/plain.cc

@@ -1,36 +0,0 @@
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-
-#include <cbsasl/plain/plain.h>
-
-namespace couchbase::sasl::mechanism::plain
-{
-
-std::pair<error, std::string_view>
-ClientBackend::start()
-{
-    auto usernm = usernameCallback();
-    auto passwd = passwordCallback();
-
-    buffer.push_back(0);
-    std::copy(usernm.begin(), usernm.end(), std::back_inserter(buffer));
-    buffer.push_back(0);
-    std::copy(passwd.begin(), passwd.end(), std::back_inserter(buffer));
-
-    return std::make_pair<error, std::string_view>(error::OK, { buffer.data(), buffer.size() });
-}
-
-} // namespace couchbase::sasl::mechanism::plain

data/ext/couchbase/cbsasl/plain/plain.h

@@ -1,53 +0,0 @@
-/*
- *     Copyright 2018 Couchbase, Inc.
- *
- *   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.
- */
-#pragma once
-
-#include <cbsasl/client.h>
-#include <vector>
-
-namespace couchbase::sasl::mechanism::plain
-{
-
-class ClientBackend : public MechanismBackend
-{
-  public:
-    ClientBackend(GetUsernameCallback user_cb, GetPasswordCallback password_cb, ClientContext& ctx)
-      : MechanismBackend(std::move(user_cb), std::move(password_cb), ctx)
-    {
-    }
-
-    [[nodiscard]] std::string_view get_name() const override
-    {
-        return "PLAIN";
-    }
-
-    std::pair<error, std::string_view> start() override;
-
-    std::pair<error, std::string_view> step(std::string_view) override
-    {
-        throw std::logic_error("cb::sasl::mechanism::plain::ClientBackend::step(): Plain auth "
-                               "should not call step");
-    }
-
-  private:
-    /**
-     * Where to store the encoded string:
-     * "\0username\0password"
-     */
-    std::vector<char> buffer;
-};
-
-} // namespace couchbase::sasl::mechanism::plain