Re implement keyvault keys (#2705)
* updated-create-key with no protocol client
This commit is contained in:
Victor Vazquez
GitHub
parent
697f45a454
commit
83295c69ed
@ -9,13 +9,16 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <azure/core/context.hpp>
|
||||
#include <azure/core/io/body_stream.hpp>
|
||||
#include <azure/core/response.hpp>
|
||||
|
||||
#include "azure/keyvault/keys/cryptography/cryptography_client_models.hpp"
|
||||
#include "azure/keyvault/keys/cryptography/cryptography_client_options.hpp"
|
||||
|
||||
#include <azure/core/context.hpp>
|
||||
#include <azure/core/credentials/credentials.hpp>
|
||||
#include <azure/core/http/http.hpp>
|
||||
#include <azure/core/internal/http/pipeline.hpp>
|
||||
#include <azure/core/io/body_stream.hpp>
|
||||
#include <azure/core/response.hpp>
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
@ -33,9 +36,21 @@ namespace Azure { namespace Security { namespace KeyVault {
|
||||
*
|
||||
*/
|
||||
class CryptographyClient final {
|
||||
private:
|
||||
std::shared_ptr<Azure::Security::KeyVault::_detail::KeyVaultProtocolClient> m_pipeline;
|
||||
protected:
|
||||
Azure::Core::Url m_keyId;
|
||||
std::string m_apiVersion;
|
||||
std::shared_ptr<Azure::Core::Http::_internal::HttpPipeline> m_pipeline;
|
||||
|
||||
private:
|
||||
Azure::Core::Http::Request CreateRequest(
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
std::vector<std::string> const& path = {},
|
||||
Azure::Core::IO::BodyStream* content = nullptr) const;
|
||||
|
||||
std::unique_ptr<Azure::Core::Http::RawResponse> SendCryptoRequest(
|
||||
std::vector<std::string> const& path,
|
||||
std::string const& payload,
|
||||
Azure::Core::Context const& context) const;
|
||||
|
||||
public:
|
||||
/**
|
||||
|
||||
@ -12,6 +12,13 @@
|
||||
#include "azure/keyvault/keys/key_client_models.hpp"
|
||||
#include "azure/keyvault/keys/key_client_options.hpp"
|
||||
|
||||
#include <azure/core/context.hpp>
|
||||
#include <azure/core/credentials/credentials.hpp>
|
||||
#include <azure/core/http/http.hpp>
|
||||
#include <azure/core/internal/http/pipeline.hpp>
|
||||
#include <azure/core/io/body_stream.hpp>
|
||||
#include <azure/core/response.hpp>
|
||||
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
|
||||
@ -33,7 +40,9 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys {
|
||||
{
|
||||
protected:
|
||||
// Using a shared pipeline for a client to share it with LRO (like delete key)
|
||||
std::shared_ptr<Azure::Security::KeyVault::_detail::KeyVaultProtocolClient> m_pipeline;
|
||||
Azure::Core::Url m_vaultUrl;
|
||||
std::string m_apiVersion;
|
||||
std::shared_ptr<Azure::Core::Http::_internal::HttpPipeline> m_pipeline;
|
||||
|
||||
public:
|
||||
/**
|
||||
@ -59,7 +68,7 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys {
|
||||
*
|
||||
* @param keyClient An existing key vault key client.
|
||||
*/
|
||||
explicit KeyClient(KeyClient const& keyClient) : m_pipeline(keyClient.m_pipeline) {}
|
||||
explicit KeyClient(KeyClient const& keyClient) = default;
|
||||
|
||||
/**
|
||||
* @brief Gets the public part of a stored key.
|
||||
@ -377,5 +386,19 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys {
|
||||
Azure::Response<KeyVaultKey> ImportKey(
|
||||
ImportKeyOptions const& importKeyOptions,
|
||||
Azure::Core::Context const& context = Azure::Core::Context()) const;
|
||||
|
||||
private:
|
||||
std::unique_ptr<Azure::Core::Http::RawResponse> SendRequest(
|
||||
Azure::Core::Http::Request& request,
|
||||
Azure::Core::Context const& context) const;
|
||||
|
||||
Azure::Core::Http::Request CreateRequest(
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
std::vector<std::string> const& path = {},
|
||||
Azure::Core::IO::BodyStream* content = nullptr) const;
|
||||
|
||||
Azure::Core::Http::Request ContinuationTokenRequest(
|
||||
std::vector<std::string> const& path,
|
||||
const Azure::Nullable<std::string>& NextPageToken) const;
|
||||
};
|
||||
}}}} // namespace Azure::Security::KeyVault::Keys
|
||||
|
||||
@ -1,8 +1,6 @@
|
||||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include <azure/core/azure_assert.hpp>
|
||||
#include <azure/core/credentials/credentials.hpp>
|
||||
#include <azure/core/cryptography/hash.hpp>
|
||||
#include <azure/core/exception.hpp>
|
||||
#include <azure/core/http/http.hpp>
|
||||
@ -24,10 +22,12 @@
|
||||
#include <vector>
|
||||
|
||||
using namespace Azure::Security::KeyVault::Keys::Cryptography;
|
||||
using namespace Azure::Security::KeyVault::Keys::_detail;
|
||||
using namespace Azure::Security::KeyVault::Keys::Cryptography::_detail;
|
||||
using namespace Azure::Core::Http;
|
||||
using namespace Azure::Core::Http::Policies;
|
||||
using namespace Azure::Core::Http::Policies::_internal;
|
||||
using namespace Azure::Core::Http::_internal;
|
||||
|
||||
namespace {
|
||||
// 1Mb at a time
|
||||
@ -58,6 +58,34 @@ inline std::vector<uint8_t> CreateDigest(
|
||||
}
|
||||
} // namespace
|
||||
|
||||
Request CryptographyClient::CreateRequest(
|
||||
HttpMethod method,
|
||||
std::vector<std::string> const& path,
|
||||
Azure::Core::IO::BodyStream* content) const
|
||||
{
|
||||
return Azure::Security::KeyVault::_detail::KeyVaultKeysCommonRequest::CreateRequest(
|
||||
m_keyId, m_apiVersion, method, path, content);
|
||||
}
|
||||
|
||||
std::unique_ptr<Azure::Core::Http::RawResponse> CryptographyClient::SendCryptoRequest(
|
||||
std::vector<std::string> const& path,
|
||||
std::string const& payload,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
// Payload for the request
|
||||
Azure::Core::IO::MemoryBodyStream payloadStream(
|
||||
reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
|
||||
|
||||
// Request and settings
|
||||
auto request = CreateRequest(HttpMethod::Post, path, &payloadStream);
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
request.SetHeader(HttpShared::Accept, HttpShared::ApplicationJson);
|
||||
|
||||
// Send, parse and validate respone
|
||||
return Azure::Security::KeyVault::_detail::KeyVaultKeysCommonRequest::SendRequest(
|
||||
*m_pipeline, request, context);
|
||||
}
|
||||
|
||||
CryptographyClient::~CryptographyClient() = default;
|
||||
|
||||
CryptographyClient::CryptographyClient(
|
||||
@ -65,58 +93,47 @@ CryptographyClient::CryptographyClient(
|
||||
std::shared_ptr<Core::Credentials::TokenCredential const> credential,
|
||||
CryptographyClientOptions const& options)
|
||||
{
|
||||
auto apiVersion = options.Version.ToString();
|
||||
m_keyId = Azure::Core::Url(keyId);
|
||||
m_apiVersion = options.Version.ToString();
|
||||
std::vector<std::unique_ptr<HttpPolicy>> perRetrypolicies;
|
||||
{
|
||||
Azure::Core::Credentials::TokenRequestContext const tokenContext
|
||||
= {{"https://vault.azure.net/.default"}};
|
||||
Azure::Core::Credentials::TokenRequestContext const tokenContext = {{TokenContextValue}};
|
||||
|
||||
perRetrypolicies.emplace_back(
|
||||
std::make_unique<BearerTokenAuthenticationPolicy>(credential, tokenContext));
|
||||
}
|
||||
std::vector<std::unique_ptr<HttpPolicy>> perCallpolicies;
|
||||
|
||||
m_pipeline = std::make_shared<Azure::Security::KeyVault::_detail::KeyVaultProtocolClient>(
|
||||
m_keyId,
|
||||
apiVersion,
|
||||
Azure::Core::Http::_internal::HttpPipeline(
|
||||
options, "KeyVault", apiVersion, std::move(perRetrypolicies), {}));
|
||||
m_pipeline = std::make_shared<Azure::Core::Http::_internal::HttpPipeline>(
|
||||
options,
|
||||
"KeyVault",
|
||||
options.Version.ToString(),
|
||||
std::move(perRetrypolicies),
|
||||
std::move(perCallpolicies));
|
||||
}
|
||||
|
||||
Azure::Response<EncryptResult> CryptographyClient::Encrypt(
|
||||
EncryptParameters const& parameters,
|
||||
Azure::Core::Context const& context)
|
||||
{
|
||||
return m_pipeline->SendRequest<EncryptResult>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
[¶meters]() {
|
||||
return EncryptParametersSerializer::EncryptParametersSerialize(parameters);
|
||||
},
|
||||
[¶meters](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
auto result = EncryptResultSerializer::EncryptResultDeserialize(rawResponse);
|
||||
result.Algorithm = parameters.Algorithm;
|
||||
return result;
|
||||
},
|
||||
{"encrypt"});
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendCryptoRequest(
|
||||
{EncryptValue}, EncryptParametersSerializer::EncryptParametersSerialize(parameters), context);
|
||||
auto value = EncryptResultSerializer::EncryptResultDeserialize(*rawResponse);
|
||||
value.Algorithm = parameters.Algorithm;
|
||||
return Azure::Response<EncryptResult>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<DecryptResult> CryptographyClient::Decrypt(
|
||||
DecryptParameters const& parameters,
|
||||
Azure::Core::Context const& context)
|
||||
{
|
||||
return m_pipeline->SendRequest<DecryptResult>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
[¶meters]() {
|
||||
return DecryptParametersSerializer::DecryptParametersSerialize(parameters);
|
||||
},
|
||||
[¶meters](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
auto result = DecryptResultSerializer::DecryptResultDeserialize(rawResponse);
|
||||
result.Algorithm = parameters.Algorithm;
|
||||
return result;
|
||||
},
|
||||
{"decrypt"});
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendCryptoRequest(
|
||||
{DecryptValue}, DecryptParametersSerializer::DecryptParametersSerialize(parameters), context);
|
||||
auto value = DecryptResultSerializer::DecryptResultDeserialize(*rawResponse);
|
||||
value.Algorithm = parameters.Algorithm;
|
||||
return Azure::Response<DecryptResult>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<WrapResult> CryptographyClient::WrapKey(
|
||||
@ -124,19 +141,15 @@ Azure::Response<WrapResult> CryptographyClient::WrapKey(
|
||||
std::vector<uint8_t> const& key,
|
||||
Azure::Core::Context const& context)
|
||||
{
|
||||
return m_pipeline->SendRequest<WrapResult>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
[&algorithm, &key]() {
|
||||
return KeyWrapParametersSerializer::KeyWrapParametersSerialize(
|
||||
KeyWrapParameters(algorithm.ToString(), key));
|
||||
},
|
||||
[&algorithm](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
auto result = WrapResultSerializer::WrapResultDeserialize(rawResponse);
|
||||
result.Algorithm = algorithm;
|
||||
return result;
|
||||
},
|
||||
{"wrapKey"});
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendCryptoRequest(
|
||||
{WrapKeyValue},
|
||||
KeyWrapParametersSerializer::KeyWrapParametersSerialize(
|
||||
KeyWrapParameters(algorithm.ToString(), key)),
|
||||
context);
|
||||
auto value = WrapResultSerializer::WrapResultDeserialize(*rawResponse);
|
||||
value.Algorithm = algorithm;
|
||||
return Azure::Response<WrapResult>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<UnwrapResult> CryptographyClient::UnwrapKey(
|
||||
@ -144,19 +157,15 @@ Azure::Response<UnwrapResult> CryptographyClient::UnwrapKey(
|
||||
std::vector<uint8_t> const& encryptedKey,
|
||||
Azure::Core::Context const& context)
|
||||
{
|
||||
return m_pipeline->SendRequest<UnwrapResult>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
[&algorithm, &encryptedKey]() {
|
||||
return KeyWrapParametersSerializer::KeyWrapParametersSerialize(
|
||||
KeyWrapParameters(algorithm.ToString(), encryptedKey));
|
||||
},
|
||||
[&algorithm](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
auto result = UnwrapResultSerializer::UnwrapResultDeserialize(rawResponse);
|
||||
result.Algorithm = algorithm;
|
||||
return result;
|
||||
},
|
||||
{"unwrapKey"});
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendCryptoRequest(
|
||||
{UnwrapKeyValue},
|
||||
KeyWrapParametersSerializer::KeyWrapParametersSerialize(
|
||||
KeyWrapParameters(algorithm.ToString(), encryptedKey)),
|
||||
context);
|
||||
auto value = UnwrapResultSerializer::UnwrapResultDeserialize(*rawResponse);
|
||||
value.Algorithm = algorithm;
|
||||
return Azure::Response<UnwrapResult>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<SignResult> CryptographyClient::Sign(
|
||||
@ -164,19 +173,15 @@ Azure::Response<SignResult> CryptographyClient::Sign(
|
||||
std::vector<uint8_t> const& digest,
|
||||
Azure::Core::Context const& context)
|
||||
{
|
||||
return m_pipeline->SendRequest<SignResult>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
[&algorithm, &digest]() {
|
||||
return KeySignParametersSerializer::KeySignParametersSerialize(
|
||||
KeySignParameters(algorithm.ToString(), digest));
|
||||
},
|
||||
[&algorithm](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
auto result = SignResultSerializer::SignResultDeserialize(rawResponse);
|
||||
result.Algorithm = algorithm;
|
||||
return result;
|
||||
},
|
||||
{"sign"});
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendCryptoRequest(
|
||||
{SignValue},
|
||||
KeySignParametersSerializer::KeySignParametersSerialize(
|
||||
KeySignParameters(algorithm.ToString(), digest)),
|
||||
context);
|
||||
auto value = SignResultSerializer::SignResultDeserialize(*rawResponse);
|
||||
value.Algorithm = algorithm;
|
||||
return Azure::Response<SignResult>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<SignResult> CryptographyClient::SignData(
|
||||
@ -201,22 +206,16 @@ Azure::Response<VerifyResult> CryptographyClient::Verify(
|
||||
std::vector<uint8_t> const& signature,
|
||||
Azure::Core::Context const& context)
|
||||
{
|
||||
return m_pipeline->SendRequest<VerifyResult>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
[&algorithm, &digest, &signature]() {
|
||||
return KeyVerifyParametersSerializer::KeyVerifyParametersSerialize(
|
||||
KeyVerifyParameters(algorithm.ToString(), digest, signature));
|
||||
},
|
||||
[&algorithm, this](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
auto result = VerifyResultSerializer::VerifyResultDeserialize(rawResponse);
|
||||
result.Algorithm = algorithm;
|
||||
// Verify result won't return the KeyId, the client SDK will add it based on the client
|
||||
// KeyId.
|
||||
result.KeyId = this->m_keyId.GetAbsoluteUrl();
|
||||
return result;
|
||||
},
|
||||
{"verify"});
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendCryptoRequest(
|
||||
{VerifyValue},
|
||||
KeyVerifyParametersSerializer::KeyVerifyParametersSerialize(
|
||||
KeyVerifyParameters(algorithm.ToString(), digest, signature)),
|
||||
context);
|
||||
auto value = VerifyResultSerializer::VerifyResultDeserialize(*rawResponse);
|
||||
value.Algorithm = algorithm;
|
||||
value.KeyId = this->m_keyId.GetAbsoluteUrl();
|
||||
return Azure::Response<VerifyResult>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<VerifyResult> CryptographyClient::VerifyData(
|
||||
|
||||
@ -18,60 +18,78 @@
|
||||
#include <vector>
|
||||
|
||||
using namespace Azure::Security::KeyVault::Keys;
|
||||
using namespace Azure::Security::KeyVault::Keys::_detail;
|
||||
using namespace Azure::Core::Http;
|
||||
using namespace Azure::Core::Http::Policies;
|
||||
using namespace Azure::Core::Http::Policies::_internal;
|
||||
using namespace Azure::Core::Http::_internal;
|
||||
|
||||
namespace {
|
||||
constexpr static const char KeyVaultServicePackageName[] = "keyvault-keys";
|
||||
constexpr static const char CreateValue[] = "create";
|
||||
} // namespace
|
||||
|
||||
struct RequestWithContinuationToken final
|
||||
std::unique_ptr<RawResponse> KeyClient::SendRequest(
|
||||
Azure::Core::Http::Request& request,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
std::vector<std::string> Path;
|
||||
std::unique_ptr<std::map<std::string, std::string>> Query;
|
||||
};
|
||||
return Azure::Security::KeyVault::_detail::KeyVaultKeysCommonRequest::SendRequest(
|
||||
*m_pipeline, request, context);
|
||||
}
|
||||
|
||||
static inline RequestWithContinuationToken BuildRequestFromContinuationToken(
|
||||
const Azure::Nullable<std::string>& NextPageToken,
|
||||
std::vector<std::string> defaultPath)
|
||||
Request KeyClient::CreateRequest(
|
||||
HttpMethod method,
|
||||
std::vector<std::string> const& path,
|
||||
Azure::Core::IO::BodyStream* content) const
|
||||
{
|
||||
return Azure::Security::KeyVault::_detail::KeyVaultKeysCommonRequest::CreateRequest(
|
||||
m_vaultUrl, m_apiVersion, method, path, content);
|
||||
}
|
||||
|
||||
Request KeyClient::ContinuationTokenRequest(
|
||||
std::vector<std::string> const& path,
|
||||
const Azure::Nullable<std::string>& NextPageToken) const
|
||||
{
|
||||
RequestWithContinuationToken request;
|
||||
request.Path = std::move(defaultPath);
|
||||
if (NextPageToken)
|
||||
{
|
||||
// Using a continuation token requires to send the request to the continuation token URL instead
|
||||
// of the default URL which is used only for the first page.
|
||||
Azure::Core::Url nextPageUrl(NextPageToken.Value());
|
||||
request.Query
|
||||
= std::make_unique<std::map<std::string, std::string>>(nextPageUrl.GetQueryParameters());
|
||||
request.Path.clear();
|
||||
request.Path.emplace_back(nextPageUrl.GetPath());
|
||||
return Request(HttpMethod::Get, nextPageUrl);
|
||||
}
|
||||
return request;
|
||||
return CreateRequest(HttpMethod::Get, path);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
KeyClient::KeyClient(
|
||||
std::string const& vaultUrl,
|
||||
std::shared_ptr<Core::Credentials::TokenCredential const> credential,
|
||||
KeyClientOptions options)
|
||||
: m_vaultUrl(vaultUrl), m_apiVersion(options.Version.ToString())
|
||||
{
|
||||
auto apiVersion = options.Version.ToString();
|
||||
|
||||
std::vector<std::unique_ptr<HttpPolicy>> perRetrypoliciesOld;
|
||||
{
|
||||
Azure::Core::Credentials::TokenRequestContext const tokenContext = {{TokenContextValue}};
|
||||
|
||||
perRetrypoliciesOld.emplace_back(
|
||||
std::make_unique<BearerTokenAuthenticationPolicy>(credential, tokenContext));
|
||||
}
|
||||
std::vector<std::unique_ptr<HttpPolicy>> perRetrypolicies;
|
||||
{
|
||||
Azure::Core::Credentials::TokenRequestContext const tokenContext
|
||||
= {{"https://vault.azure.net/.default"}};
|
||||
Azure::Core::Credentials::TokenRequestContext const tokenContext = {{TokenContextValue}};
|
||||
|
||||
perRetrypolicies.emplace_back(
|
||||
std::make_unique<BearerTokenAuthenticationPolicy>(credential, tokenContext));
|
||||
}
|
||||
std::vector<std::unique_ptr<HttpPolicy>> perCallpolicies;
|
||||
|
||||
m_pipeline = std::make_shared<Azure::Security::KeyVault::_detail::KeyVaultProtocolClient>(
|
||||
Azure::Core::Url(vaultUrl),
|
||||
apiVersion,
|
||||
Azure::Core::Http::_internal::HttpPipeline(
|
||||
options, KeyVaultServicePackageName, apiVersion, std::move(perRetrypolicies), {}));
|
||||
m_pipeline = std::make_shared<Azure::Core::Http::_internal::HttpPipeline>(
|
||||
options,
|
||||
KeyVaultServicePackageName,
|
||||
m_apiVersion,
|
||||
std::move(perRetrypolicies),
|
||||
std::move(perCallpolicies));
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::GetKey(
|
||||
@ -79,13 +97,13 @@ Azure::Response<KeyVaultKey> KeyClient::GetKey(
|
||||
GetKeyOptions const& options,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Get,
|
||||
[&name](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, name, options.Version});
|
||||
// Request with no payload
|
||||
auto request = CreateRequest(HttpMethod::Get, {_detail::KeysPath, name, options.Version});
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, *rawResponse);
|
||||
return Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::CreateKey(
|
||||
@ -94,81 +112,99 @@ Azure::Response<KeyVaultKey> KeyClient::CreateKey(
|
||||
CreateKeyOptions const& options,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
_detail::KeyRequestParameters(keyType, options),
|
||||
[&name](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, name, "create"});
|
||||
// Payload for the request
|
||||
_detail::KeyRequestParameters const params(keyType, options);
|
||||
auto payload = params.Serialize();
|
||||
Azure::Core::IO::MemoryBodyStream payloadStream(
|
||||
reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
|
||||
|
||||
// Request and settings
|
||||
auto request
|
||||
= CreateRequest(HttpMethod::Post, {_detail::KeysPath, name, CreateValue}, &payloadStream);
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, *rawResponse);
|
||||
return Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::CreateEcKey(
|
||||
CreateEcKeyOptions const& ecKeyOptions,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
// Payload for the request
|
||||
std::string const& keyName = ecKeyOptions.GetName();
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
_detail::KeyRequestParameters(ecKeyOptions),
|
||||
[&keyName](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, keyName, "create"});
|
||||
auto payload = _detail::KeyRequestParameters(ecKeyOptions).Serialize();
|
||||
Azure::Core::IO::MemoryBodyStream payloadStream(
|
||||
reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
|
||||
|
||||
// Request and settings
|
||||
auto request
|
||||
= CreateRequest(HttpMethod::Post, {_detail::KeysPath, keyName, CreateValue}, &payloadStream);
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, *rawResponse);
|
||||
return Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::CreateRsaKey(
|
||||
CreateRsaKeyOptions const& rsaKeyOptions,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
// Payload for the request
|
||||
std::string const& keyName = rsaKeyOptions.GetName();
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
_detail::KeyRequestParameters(rsaKeyOptions),
|
||||
[&keyName](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, keyName, "create"});
|
||||
auto payload = _detail::KeyRequestParameters(rsaKeyOptions).Serialize();
|
||||
Azure::Core::IO::MemoryBodyStream payloadStream(
|
||||
reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
|
||||
|
||||
// Request and settings
|
||||
auto request
|
||||
= CreateRequest(HttpMethod::Post, {_detail::KeysPath, keyName, CreateValue}, &payloadStream);
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, *rawResponse);
|
||||
return Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::CreateOctKey(
|
||||
CreateOctKeyOptions const& octKeyOptions,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
// Payload for the request.
|
||||
std::string const& keyName = octKeyOptions.GetName();
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
_detail::KeyRequestParameters(octKeyOptions),
|
||||
[&keyName](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, keyName, "create"});
|
||||
auto payload = _detail::KeyRequestParameters(octKeyOptions).Serialize();
|
||||
Azure::Core::IO::MemoryBodyStream payloadStream(
|
||||
reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
|
||||
|
||||
// Request and settings
|
||||
auto request
|
||||
= CreateRequest(HttpMethod::Post, {_detail::KeysPath, keyName, CreateValue}, &payloadStream);
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, *rawResponse);
|
||||
return Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
KeyPropertiesPagedResponse KeyClient::GetPropertiesOfKeys(
|
||||
GetPropertiesOfKeysOptions const& options,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
auto const request
|
||||
= BuildRequestFromContinuationToken(options.NextPageToken, {_detail::KeysPath});
|
||||
auto response = m_pipeline->SendRequest<KeyPropertiesPagedResponse>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Get,
|
||||
[](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyPropertiesPagedResultSerializer::KeyPropertiesPagedResultDeserialize(
|
||||
rawResponse);
|
||||
},
|
||||
request.Path,
|
||||
request.Query);
|
||||
// Request and settings
|
||||
auto request = ContinuationTokenRequest({_detail::KeysPath}, options.NextPageToken);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyPropertiesPagedResultSerializer::KeyPropertiesPagedResultDeserialize(
|
||||
*rawResponse);
|
||||
return KeyPropertiesPagedResponse(
|
||||
std::move(response.Value),
|
||||
std::move(response.RawResponse),
|
||||
std::make_unique<KeyClient>(*this));
|
||||
std::move(value), std::move(rawResponse), std::make_unique<KeyClient>(*this));
|
||||
}
|
||||
|
||||
KeyPropertiesPagedResponse KeyClient::GetPropertiesOfKeyVersions(
|
||||
@ -176,99 +212,87 @@ KeyPropertiesPagedResponse KeyClient::GetPropertiesOfKeyVersions(
|
||||
GetPropertiesOfKeyVersionsOptions const& options,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
auto const request = BuildRequestFromContinuationToken(
|
||||
options.NextPageToken, {_detail::KeysPath, name, "versions"});
|
||||
auto response = m_pipeline->SendRequest<KeyPropertiesPagedResponse>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Get,
|
||||
[](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyPropertiesPagedResultSerializer::KeyPropertiesPagedResultDeserialize(
|
||||
rawResponse);
|
||||
},
|
||||
request.Path,
|
||||
request.Query);
|
||||
// Request and settings
|
||||
auto request
|
||||
= ContinuationTokenRequest({_detail::KeysPath, name, "versions"}, options.NextPageToken);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyPropertiesPagedResultSerializer::KeyPropertiesPagedResultDeserialize(
|
||||
*rawResponse);
|
||||
return KeyPropertiesPagedResponse(
|
||||
std::move(response.Value),
|
||||
std::move(response.RawResponse),
|
||||
std::make_unique<KeyClient>(*this),
|
||||
name);
|
||||
std::move(value), std::move(rawResponse), std::make_unique<KeyClient>(*this));
|
||||
}
|
||||
|
||||
Azure::Security::KeyVault::Keys::DeleteKeyOperation KeyClient::StartDeleteKey(
|
||||
std::string const& name,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
// Request with no payload
|
||||
auto request = CreateRequest(HttpMethod::Delete, {_detail::KeysPath, name});
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::DeletedKeySerializer::DeletedKeyDeserialize(name, *rawResponse);
|
||||
auto responseT = Azure::Response<DeletedKey>(std::move(value), std::move(rawResponse));
|
||||
return Azure::Security::KeyVault::Keys::DeleteKeyOperation(
|
||||
std::make_shared<KeyClient>(*this),
|
||||
m_pipeline->SendRequest<Azure::Security::KeyVault::Keys::DeletedKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Delete,
|
||||
[&name](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::DeletedKeySerializer::DeletedKeyDeserialize(name, rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, name}));
|
||||
std::make_shared<KeyClient>(*this), std::move(responseT));
|
||||
}
|
||||
|
||||
Azure::Security::KeyVault::Keys::RecoverDeletedKeyOperation KeyClient::StartRecoverDeletedKey(
|
||||
std::string const& name,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
// Request with no payload
|
||||
auto request = CreateRequest(HttpMethod::Post, {_detail::DeletedKeysPath, name, "recover"});
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, *rawResponse);
|
||||
auto responseT = Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
return Azure::Security::KeyVault::Keys::RecoverDeletedKeyOperation(
|
||||
std::make_shared<KeyClient>(*this),
|
||||
m_pipeline->SendRequest<Azure::Security::KeyVault::Keys::KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
[&name](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, rawResponse);
|
||||
},
|
||||
{_detail::DeletedKeysPath, name, "recover"}));
|
||||
std::make_shared<KeyClient>(*this), std::move(responseT));
|
||||
}
|
||||
|
||||
Azure::Response<DeletedKey> KeyClient::GetDeletedKey(
|
||||
std::string const& name,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
return m_pipeline->SendRequest<DeletedKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Get,
|
||||
[&name](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::DeletedKeySerializer::DeletedKeyDeserialize(name, rawResponse);
|
||||
},
|
||||
{_detail::DeletedKeysPath, name});
|
||||
// Request with no payload
|
||||
auto request = CreateRequest(HttpMethod::Get, {_detail::DeletedKeysPath, name});
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::DeletedKeySerializer::DeletedKeyDeserialize(name, *rawResponse);
|
||||
return Azure::Response<DeletedKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
DeletedKeyPagedResponse KeyClient::GetDeletedKeys(
|
||||
GetDeletedKeysOptions const& options,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
auto const request
|
||||
= BuildRequestFromContinuationToken(options.NextPageToken, {_detail::DeletedKeysPath});
|
||||
auto response = m_pipeline->SendRequest<DeletedKeyPagedResponse>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Get,
|
||||
[](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyPropertiesPagedResultSerializer::DeletedKeyPagedResultDeserialize(
|
||||
rawResponse);
|
||||
},
|
||||
request.Path,
|
||||
request.Query);
|
||||
// Request and settings
|
||||
auto request = ContinuationTokenRequest({_detail::DeletedKeysPath}, options.NextPageToken);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value
|
||||
= _detail::KeyPropertiesPagedResultSerializer::DeletedKeyPagedResultDeserialize(*rawResponse);
|
||||
return DeletedKeyPagedResponse(
|
||||
std::move(response.Value),
|
||||
std::move(response.RawResponse),
|
||||
std::make_unique<KeyClient>(*this));
|
||||
std::move(value), std::move(rawResponse), std::make_unique<KeyClient>(*this));
|
||||
}
|
||||
|
||||
Azure::Response<PurgedKey> KeyClient::PurgeDeletedKey(
|
||||
std::string const& name,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
return m_pipeline->SendRequest<PurgedKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Delete,
|
||||
[](Azure::Core::Http::RawResponse const&) { return PurgedKey(); },
|
||||
{_detail::DeletedKeysPath, name});
|
||||
// Request with no payload
|
||||
auto request = CreateRequest(HttpMethod::Delete, {_detail::DeletedKeysPath, name});
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = PurgedKey();
|
||||
return Azure::Response<PurgedKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::UpdateKeyProperties(
|
||||
@ -276,49 +300,58 @@ Azure::Response<KeyVaultKey> KeyClient::UpdateKeyProperties(
|
||||
Azure::Nullable<std::vector<KeyOperation>> const& keyOperations,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Patch,
|
||||
_detail::KeyRequestParameters(properties, keyOperations),
|
||||
[&properties](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(properties.Name, rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, properties.Name, properties.Version});
|
||||
// Payload for the request
|
||||
_detail::KeyRequestParameters const params(properties, keyOperations);
|
||||
auto payload = params.Serialize();
|
||||
Azure::Core::IO::MemoryBodyStream payloadStream(
|
||||
reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
|
||||
|
||||
// Request and settings
|
||||
auto request = CreateRequest(
|
||||
HttpMethod::Patch, {_detail::KeysPath, properties.Name, properties.Version}, &payloadStream);
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value
|
||||
= _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(properties.Name, *rawResponse);
|
||||
return Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<Azure::Security::KeyVault::Keys::BackupKeyResult> KeyClient::BackupKey(
|
||||
Azure::Response<BackupKeyResult> KeyClient::BackupKey(
|
||||
std::string const& name,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
// Use the internal model KeyBackup to parse from Json
|
||||
auto response = m_pipeline->SendRequest<_detail::KeyBackup>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
[](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyBackup::Deserialize(rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, name, "backup"});
|
||||
// Request with no payload
|
||||
auto request = CreateRequest(HttpMethod::Post, {_detail::KeysPath, name, "backup"});
|
||||
|
||||
// Convert the internal KeyBackup model to a raw vector<uint8_t>.
|
||||
return Azure::Response<Azure::Security::KeyVault::Keys::BackupKeyResult>(
|
||||
Azure::Security::KeyVault::Keys::BackupKeyResult{response.Value.Value},
|
||||
std::move(response.RawResponse));
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
// the internal backupKey model provides the Deserialize implementation
|
||||
auto internalValue = _detail::KeyBackup::Deserialize(*rawResponse);
|
||||
auto value = BackupKeyResult{internalValue.Value};
|
||||
return Azure::Response<BackupKeyResult>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::RestoreKeyBackup(
|
||||
std::vector<uint8_t> const& backup,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
// Payload for the request
|
||||
_detail::KeyBackup backupModel;
|
||||
backupModel.Value = backup;
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Post,
|
||||
backupModel,
|
||||
[](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, "restore"});
|
||||
auto payload = backupModel.Serialize();
|
||||
Azure::Core::IO::MemoryBodyStream payloadStream(
|
||||
reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
|
||||
|
||||
// Request and settings
|
||||
auto request = CreateRequest(HttpMethod::Post, {_detail::KeysPath, "restore"}, &payloadStream);
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(*rawResponse);
|
||||
return Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::ImportKey(
|
||||
@ -327,31 +360,26 @@ Azure::Response<KeyVaultKey> KeyClient::ImportKey(
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
ImportKeyOptions const importKeyOptions(name, keyMaterial);
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Put,
|
||||
[&importKeyOptions]() {
|
||||
return _detail::ImportKeyOptionsSerializer::ImportKeyOptionsSerialize(importKeyOptions);
|
||||
},
|
||||
[&name](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, name});
|
||||
return ImportKey(importKeyOptions, context);
|
||||
}
|
||||
|
||||
Azure::Response<KeyVaultKey> KeyClient::ImportKey(
|
||||
ImportKeyOptions const& importKeyOptions,
|
||||
Azure::Core::Context const& context) const
|
||||
{
|
||||
return m_pipeline->SendRequest<KeyVaultKey>(
|
||||
context,
|
||||
Azure::Core::Http::HttpMethod::Put,
|
||||
[&importKeyOptions]() {
|
||||
return _detail::ImportKeyOptionsSerializer::ImportKeyOptionsSerialize(importKeyOptions);
|
||||
},
|
||||
[&importKeyOptions](Azure::Core::Http::RawResponse const& rawResponse) {
|
||||
return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(
|
||||
importKeyOptions.Name(), rawResponse);
|
||||
},
|
||||
{_detail::KeysPath, importKeyOptions.Name()});
|
||||
// Payload for the request
|
||||
auto payload = _detail::ImportKeyOptionsSerializer::ImportKeyOptionsSerialize(importKeyOptions);
|
||||
Azure::Core::IO::MemoryBodyStream payloadStream(
|
||||
reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
|
||||
|
||||
// Request and settings
|
||||
auto request = CreateRequest(
|
||||
HttpMethod::Put, {_detail::KeysPath, importKeyOptions.Name()}, &payloadStream);
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
|
||||
// Send and parse respone
|
||||
auto rawResponse = SendRequest(request, context);
|
||||
auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(
|
||||
importKeyOptions.Name(), *rawResponse);
|
||||
return Azure::Response<KeyVaultKey>(std::move(value), std::move(rawResponse));
|
||||
}
|
||||
|
||||
@ -2,21 +2,24 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include "azure/keyvault/keys/key_client_models.hpp"
|
||||
#include "private/key_constants.hpp"
|
||||
|
||||
using namespace Azure::Security::KeyVault::Keys::_detail;
|
||||
|
||||
namespace Azure { namespace Security { namespace KeyVault { namespace Keys {
|
||||
|
||||
const KeyOperation KeyOperation::Encrypt("encrypt");
|
||||
const KeyOperation KeyOperation::Encrypt(EncryptValue);
|
||||
|
||||
const KeyOperation KeyOperation::Decrypt("decrypt");
|
||||
const KeyOperation KeyOperation::Decrypt(DecryptValue);
|
||||
|
||||
const KeyOperation KeyOperation::Sign("sign");
|
||||
const KeyOperation KeyOperation::Sign(SignValue);
|
||||
|
||||
const KeyOperation KeyOperation::Verify("verify");
|
||||
const KeyOperation KeyOperation::Verify(VerifyValue);
|
||||
|
||||
const KeyOperation KeyOperation::WrapKey("wrapKey");
|
||||
const KeyOperation KeyOperation::WrapKey(WrapKeyValue);
|
||||
|
||||
const KeyOperation KeyOperation::UnwrapKey("unwrapKey");
|
||||
const KeyOperation KeyOperation::UnwrapKey(UnwrapKeyValue);
|
||||
|
||||
const KeyOperation KeyOperation::Import("import");
|
||||
const KeyOperation KeyOperation::Import(ImportValue);
|
||||
|
||||
}}}} // namespace Azure::Security::KeyVault::Keys
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include "private/keyvault_protocol.hpp"
|
||||
#include "private/key_constants.hpp"
|
||||
#include "private/keyvault_constants.hpp"
|
||||
|
||||
#include <azure/core/exception.hpp>
|
||||
@ -9,43 +10,14 @@
|
||||
|
||||
using namespace Azure::Security::KeyVault;
|
||||
using namespace Azure::Core::Http::_internal;
|
||||
using namespace Azure::Security::KeyVault::Keys::_detail;
|
||||
|
||||
Azure::Core::Http::Request _detail::KeyVaultProtocolClient::CreateRequest(
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
Azure::Core::IO::BodyStream* content,
|
||||
std::vector<std::string> const& path) const
|
||||
std::unique_ptr<Azure::Core::Http::RawResponse> _detail::KeyVaultKeysCommonRequest::SendRequest(
|
||||
Azure::Core::Http::_internal::HttpPipeline const& pipeline,
|
||||
Azure::Core::Http::Request& request,
|
||||
Azure::Core::Context const& context)
|
||||
{
|
||||
Azure::Core::Http::Request request = content == nullptr
|
||||
? Azure::Core::Http::Request(method, m_vaultUrl)
|
||||
: Azure::Core::Http::Request(method, m_vaultUrl, content);
|
||||
|
||||
request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson);
|
||||
request.SetHeader(HttpShared::Accept, HttpShared::ApplicationJson);
|
||||
|
||||
request.GetUrl().AppendQueryParameter(_detail::ApiVersion, m_apiVersion);
|
||||
|
||||
for (std::string const& p : path)
|
||||
{
|
||||
if (!p.empty())
|
||||
{
|
||||
request.GetUrl().AppendPath(p);
|
||||
}
|
||||
}
|
||||
return request;
|
||||
}
|
||||
|
||||
Azure::Core::Http::Request _detail::KeyVaultProtocolClient::CreateRequest(
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
std::vector<std::string> const& path) const
|
||||
{
|
||||
return CreateRequest(method, nullptr, path);
|
||||
}
|
||||
|
||||
std::unique_ptr<Azure::Core::Http::RawResponse> _detail::KeyVaultProtocolClient::SendRequest(
|
||||
Azure::Core::Context const& context,
|
||||
Azure::Core::Http::Request& request) const
|
||||
{
|
||||
auto response = m_pipeline.Send(request, context);
|
||||
auto response = pipeline.Send(request, context);
|
||||
auto responseCode = response->GetStatusCode();
|
||||
switch (responseCode)
|
||||
{
|
||||
@ -61,3 +33,25 @@ std::unique_ptr<Azure::Core::Http::RawResponse> _detail::KeyVaultProtocolClient:
|
||||
}
|
||||
return response;
|
||||
}
|
||||
|
||||
Azure::Core::Http::Request _detail::KeyVaultKeysCommonRequest::CreateRequest(
|
||||
Azure::Core::Url url,
|
||||
std::string const& apiVersion,
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
std::vector<std::string> const& path,
|
||||
Azure::Core::IO::BodyStream* content)
|
||||
{
|
||||
using namespace Azure::Core::Http;
|
||||
Request request = content == nullptr ? Request(method, url) : Request(method, url, content);
|
||||
|
||||
request.GetUrl().AppendQueryParameter(ApiVersionValue, apiVersion);
|
||||
|
||||
for (std::string const& p : path)
|
||||
{
|
||||
if (!p.empty())
|
||||
{
|
||||
request.GetUrl().AppendPath(p);
|
||||
}
|
||||
}
|
||||
return request;
|
||||
}
|
||||
|
||||
@ -115,5 +115,16 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys { nam
|
||||
constexpr static const char IvValue[] = "iv";
|
||||
constexpr static const char AdditionalAuthenticatedValue[] = "aad";
|
||||
constexpr static const char AuthenticationTagValue[] = "tag";
|
||||
constexpr static const char EncryptValue[] = "encrypt";
|
||||
constexpr static const char DecryptValue[] = "decrypt";
|
||||
constexpr static const char WrapKeyValue[] = "wrapKey";
|
||||
constexpr static const char UnwrapKeyValue[] = "unwrapKey";
|
||||
constexpr static const char SignValue[] = "sign";
|
||||
constexpr static const char VerifyValue[] = "verify";
|
||||
constexpr static const char ImportValue[] = "import";
|
||||
|
||||
/***************** Service *********/
|
||||
constexpr static const char ApiVersionValue[] = "api-version";
|
||||
constexpr static const char TokenContextValue[] = "https://vault.azure.net/.default";
|
||||
|
||||
}}}}} // namespace Azure::Security::KeyVault::Keys::_detail
|
||||
|
||||
@ -16,175 +16,25 @@
|
||||
#include <azure/core/internal/json/json_serializable.hpp>
|
||||
#include <azure/core/response.hpp>
|
||||
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace Azure { namespace Security { namespace KeyVault { namespace _detail {
|
||||
|
||||
/**
|
||||
* @brief The Protocol layer used by Key Vault clients.
|
||||
*
|
||||
*/
|
||||
class KeyVaultProtocolClient final {
|
||||
Azure::Core::Url m_vaultUrl;
|
||||
Azure::Core::Http::_internal::HttpPipeline m_pipeline;
|
||||
std::string m_apiVersion;
|
||||
|
||||
/**
|
||||
* @brief Create a Request to be sent.
|
||||
*
|
||||
* @param method Represent an HTTP method.
|
||||
* @param path The path for the HTTP request.
|
||||
* @return A constructed request.
|
||||
*/
|
||||
Azure::Core::Http::Request CreateRequest(
|
||||
struct KeyVaultKeysCommonRequest final
|
||||
{
|
||||
static Azure::Core::Http::Request CreateRequest(
|
||||
Azure::Core::Url url,
|
||||
std::string const& apiVersion,
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
std::vector<std::string> const& path) const;
|
||||
|
||||
/**
|
||||
* @brief Create a Key Vault request with payload.
|
||||
*
|
||||
* @param method The HTTP method.
|
||||
* @param content The HTTP payload.
|
||||
* @param path The HTTP request path.
|
||||
* @return A constructed request.
|
||||
*/
|
||||
Azure::Core::Http::Request CreateRequest(
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
Azure::Core::IO::BodyStream* content,
|
||||
std::vector<std::string> const& path) const;
|
||||
|
||||
/**
|
||||
* @brief Start the HTTP transfer based on the \p request.
|
||||
*
|
||||
* @param context The context for per-operation options or cancellation.
|
||||
* @param request The HTTP request to be sent.
|
||||
* @return The raw response from the network.
|
||||
*/
|
||||
std::unique_ptr<Azure::Core::Http::RawResponse> SendRequest(
|
||||
Azure::Core::Context const& context,
|
||||
Azure::Core::Http::Request& request) const;
|
||||
|
||||
public:
|
||||
/**
|
||||
* @brief Construct a new Key Vault Protocol Client.
|
||||
*
|
||||
* @param vaultUrl The URL address for the Key Vault.
|
||||
* @param apiVersion The service API version.
|
||||
* @param pipeline The HTTP pipeline for sending requests with.
|
||||
*/
|
||||
explicit KeyVaultProtocolClient(
|
||||
Azure::Core::Url vaultUrl,
|
||||
std::string apiVersion,
|
||||
Azure::Core::Http::_internal::HttpPipeline&& pipeline)
|
||||
: m_vaultUrl(std::move(vaultUrl)), m_pipeline(pipeline), m_apiVersion(std::move(apiVersion))
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Create and send the HTTP request. Uses the \p factoryFn function to create
|
||||
* the response type.
|
||||
*
|
||||
* @param context The context for per-operation options or cancellation.
|
||||
* @param method The method for the request.
|
||||
* @param factoryFn The function to deserialize and produce T from the raw response.
|
||||
* @param path A path for the request represented as a vector of strings.
|
||||
* @param query Optional query parameters for constructing the request.
|
||||
* @return The object produced by the \p factoryFn and the raw response from the network.
|
||||
*/
|
||||
template <class T>
|
||||
Azure::Response<T> SendRequest(
|
||||
Azure::Core::Context const& context,
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
std::function<T(Azure::Core::Http::RawResponse const& rawResponse)> factoryFn,
|
||||
std::vector<std::string> const& path,
|
||||
std::unique_ptr<std::map<std::string, std::string>> const& query = nullptr)
|
||||
{
|
||||
auto request = CreateRequest(method, path);
|
||||
if (query != nullptr)
|
||||
{
|
||||
for (auto const& queryParameter : *query)
|
||||
{
|
||||
request.GetUrl().AppendQueryParameter(queryParameter.first, queryParameter.second);
|
||||
}
|
||||
}
|
||||
auto response = SendRequest(context, request);
|
||||
// Saving the value in a local is required before passing it in to Response<T> to avoid
|
||||
// compiler optimizations re-ordering the `factoryFn` function call and the RawResponse move.
|
||||
T value = factoryFn(*response);
|
||||
return Azure::Response<T>(std::move(value), std::move(response));
|
||||
}
|
||||
Azure::Core::IO::BodyStream* content);
|
||||
|
||||
/**
|
||||
* @brief Create and send the HTTP request with payload content. Uses the \p factoryFn function
|
||||
* to create the response type.
|
||||
*
|
||||
* @param context The context for per-operation options or cancellation.
|
||||
* @param method The method for the request.
|
||||
* @param content The HTTP payload.
|
||||
* @param factoryFn The function to deserialize and produce T from the raw response.
|
||||
* @param path A path for the request represented as a vector of strings.
|
||||
* @return The object produced by the \p factoryFn and the raw response from the network.
|
||||
*/
|
||||
template <class T>
|
||||
Azure::Response<T> SendRequest(
|
||||
Azure::Core::Context const& context,
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
Azure::Core::Json::_internal::JsonSerializable const& content,
|
||||
std::function<T(Azure::Core::Http::RawResponse const& rawResponse)> factoryFn,
|
||||
std::vector<std::string> const& path)
|
||||
{
|
||||
auto serialContent = content.Serialize();
|
||||
auto streamContent = Azure::Core::IO::MemoryBodyStream(
|
||||
reinterpret_cast<const uint8_t*>(serialContent.data()), serialContent.size());
|
||||
|
||||
auto request = CreateRequest(method, &streamContent, path);
|
||||
auto response = SendRequest(context, request);
|
||||
// Saving the value in a local is required before passing it in to Response<T> to avoid
|
||||
// compiler optimizations re-ordering the `factoryFn` function call and the RawResponse move.
|
||||
T value = factoryFn(*response);
|
||||
return Azure::Response<T>(value, std::move(response));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
Azure::Response<T> SendRequest(
|
||||
Azure::Core::Context const& context,
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
std::function<std::string()> serializeContentFn,
|
||||
std::function<T(Azure::Core::Http::RawResponse const& rawResponse)> factoryFn,
|
||||
std::vector<std::string> const& path)
|
||||
{
|
||||
auto serialContent = serializeContentFn();
|
||||
auto streamContent = Azure::Core::IO::MemoryBodyStream(
|
||||
reinterpret_cast<const uint8_t*>(serialContent.data()), serialContent.size());
|
||||
|
||||
auto request = CreateRequest(method, &streamContent, path);
|
||||
auto response = SendRequest(context, request);
|
||||
// Saving the value in a local is required before passing it in to Response<T> to avoid
|
||||
// compiler optimizations re-ordering the `factoryFn` function call and the RawResponse move.
|
||||
T value = factoryFn(*response);
|
||||
return Azure::Response<T>(value, std::move(response));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Create a key vault request and send it using the Azure Core pipeline directly to avoid
|
||||
* checking the respone code.
|
||||
*
|
||||
* @param context A context for cancellation.
|
||||
* @param method The HTTP method for the request.
|
||||
* @param path The path for the request.
|
||||
* @return A unique ptr to an HTTP raw response.
|
||||
*/
|
||||
std::unique_ptr<Azure::Core::Http::RawResponse> Send(
|
||||
Azure::Core::Context const& context,
|
||||
Azure::Core::Http::HttpMethod method,
|
||||
std::vector<std::string> const& path)
|
||||
{
|
||||
auto request = CreateRequest(method, path);
|
||||
// Use the core pipeline directly to avoid checking the response code.
|
||||
return m_pipeline.Send(request, context);
|
||||
}
|
||||
static std::unique_ptr<Azure::Core::Http::RawResponse> SendRequest(
|
||||
Azure::Core::Http::_internal::HttpPipeline const& pipeline,
|
||||
Azure::Core::Http::Request& request,
|
||||
Azure::Core::Context const& context);
|
||||
};
|
||||
|
||||
}}}} // namespace Azure::Security::KeyVault::_detail
|
||||
|
||||
@ -18,7 +18,6 @@ add_executable (
|
||||
macro_guard.cpp
|
||||
mocked_transport_adapter_test.hpp
|
||||
mocked_client_test.cpp
|
||||
protocol_test.cpp
|
||||
)
|
||||
|
||||
if (MSVC)
|
||||
|
||||
@ -102,12 +102,10 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys { nam
|
||||
KeyClientOptions const& options = KeyClientOptions())
|
||||
: KeyClient(vaultUrl, nullptr, options)
|
||||
{
|
||||
auto apiVersion = options.Version.ToString();
|
||||
|
||||
m_pipeline = std::make_unique<Azure::Security::KeyVault::_detail::KeyVaultProtocolClient>(
|
||||
Azure::Core::Url(vaultUrl),
|
||||
apiVersion,
|
||||
Azure::Core::Http::_internal::HttpPipeline(options, "test", "version", {}, {}));
|
||||
std::vector<std::unique_ptr<Azure::Core::Http::Policies::HttpPolicy>> perCallpolicies;
|
||||
std::vector<std::unique_ptr<Azure::Core::Http::Policies::HttpPolicy>> perRetrypolicies;
|
||||
m_pipeline = std::make_unique<Azure::Core::Http::_internal::HttpPipeline>(
|
||||
options, "test", "version", std::move(perRetrypolicies), std::move(perCallpolicies));
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -1,26 +0,0 @@
|
||||
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <azure/core/http/http.hpp>
|
||||
#include <azure/core/http/policies/policy.hpp>
|
||||
#include <azure/core/internal/client_options.hpp>
|
||||
|
||||
#include "./../../src/private/keyvault_protocol.hpp"
|
||||
|
||||
#include <memory>
|
||||
|
||||
using namespace Azure::Security::KeyVault::_detail;
|
||||
|
||||
TEST(KeyVaultProtocolClient, initPipeline)
|
||||
{
|
||||
std::vector<std::unique_ptr<Azure::Core::Http::Policies::HttpPolicy>> policies;
|
||||
policies.emplace_back(
|
||||
std::make_unique<Azure::Core::Http::Policies::_internal::TransportPolicy>());
|
||||
Azure::Core::Url url("urlTest");
|
||||
Azure::Core::_internal::ClientOptions options;
|
||||
Azure::Core::Http::_internal::HttpPipeline pipeline(
|
||||
options, "service-name", "service-version", std::move(policies), {});
|
||||
EXPECT_NO_THROW(KeyVaultProtocolClient p(url, "version", std::move(pipeline)));
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user