/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> AddAsync(this IKeys operations, CreateKeyRequest body = default(CreateKeyRequest), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.AddWithHttpMessagesAsync(body, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
private static async Task <string> CreateKey(KmsManagementClient kmsManagementClient, string compartmentId)
{
logger.Info("Creating Key");
KeyShape keyShape = new KeyShape
{
Algorithm = KeyShape.AlgorithmEnum.Aes,
Length = DefaultKeyLength
};
CreateKeyDetails createKeyDetails = new CreateKeyDetails
{
KeyShape = keyShape,
CompartmentId = compartmentId,
DisplayName = "DotNet-SDK-Key-1",
FreeformTags = GetSampleFreeformTagData()
};
CreateKeyRequest createKeyRequest = new CreateKeyRequest
{
CreateKeyDetails = createKeyDetails
};
CreateKeyResponse createKeyResponse = await kmsManagementClient.CreateKey(createKeyRequest);
logger.Info($"Created new key: {createKeyResponse.Key.DisplayName}");
return(createKeyResponse.Key.Id);
}
/// <summary>
/// Creates a new application key. There is a limit of 100 million key creations per account.
/// </summary>
/// <param name="keyName">The name for this key.</param>
/// <param name="capabilities">A list of <see cref="Capability"/> each one naming a capability the new key should have.</param>
/// <exception cref="AuthenticationException">Thrown when authentication fails.</exception>
/// <exception cref="ApiException">Thrown when an error occurs during client operation.</exception>
async Task <IApiResults <CreateKeyResponse> > IStorageKeys.CreateAsync
(string keyName, Capabilities capabilities)
{
var request = new CreateKeyRequest(AccountId, keyName, capabilities);
return(await _client.CreateKeyAsync(request, _cancellationToken));
}
private static void CreateKey(KmsClient kmsClient)
{
var req = new CreateKeyRequest
{
VersionId = "v1.0",
Body = new CreateKeyRequestBody()
{
KeyAlias = "0000"
}
};
try
{
var resp = kmsClient.CreateKey(req);
Console.WriteLine(resp.ToString());
}
catch (RequestTimeoutException requestTimeoutException)
{
Console.WriteLine(requestTimeoutException.ErrorMessage);
}
catch (ServiceResponseException clientRequestException)
{
Console.WriteLine(clientRequestException.HttpStatusCode);
Console.WriteLine(clientRequestException.ErrorCode);
Console.WriteLine(clientRequestException.ErrorMsg);
}
catch (ConnectionException connectionException)
{
Console.WriteLine(connectionException.ErrorMessage);
}
}
public async Task <IActionResult> Add(CreateKeyRequest request)
{
var key = new Key
{
Body = request.Body,
Sha = Sha256.Compute(request.Body)
};
try
{
var result = await _keyService.CreateKey(key);
var keyCreatedResponse = new KeyCreatedResponse
{
Body = result.Body,
Id = result.ShortSha
};
return(CreatedAtAction("Get", "Keys", new { id = keyCreatedResponse.Id }, keyCreatedResponse));
}
catch (ConflictingKeyConflictException e)
{
_logger.LogError(e, "caught conflicting exception");
ModelState.AddModelError("Errors", "Key already exists");
return(Conflict(new ValidationProblemDetails(ModelState)));
}
catch (Exception e)
{
ModelState.AddModelError("Errors", "Unknown error occurred");
_logger.LogError(e, "caught exception");
return(new ObjectResult(new ValidationProblemDetails(ModelState))
{
StatusCode = StatusCodes.Status500InternalServerError
});
}
}
internal CreateKeyResponse CreateKey(CreateKeyRequest request)
{
var marshaller = new CreateKeyRequestMarshaller();
var unmarshaller = CreateKeyResponseUnmarshaller.Instance;
return(Invoke <CreateKeyRequest, CreateKeyResponse>(request, marshaller, unmarshaller));
}
public void CreateKeyRequestObject()
{
moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
CreateKeyRequest request = new CreateKeyRequest
{
ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
Key = new Key(),
};
Key expectedResponse = new Key
{
KeyName = KeyName.FromProjectKey("[PROJECT]", "[KEY]"),
DisplayName = "display_name137f65c2",
WebSettings = new WebKeySettings(),
AndroidSettings = new AndroidKeySettings(),
IosSettings = new IOSKeySettings(),
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
CreateTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.CreateKey(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
RecaptchaEnterpriseServiceClient client = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);
Key response = client.CreateKey(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async stt::Task CreateKeyRequestObjectAsync()
{
moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient> mockGrpcClient = new moq::Mock <RecaptchaEnterpriseService.RecaptchaEnterpriseServiceClient>(moq::MockBehavior.Strict);
CreateKeyRequest request = new CreateKeyRequest
{
ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
Key = new Key(),
};
Key expectedResponse = new Key
{
KeyName = KeyName.FromProjectKey("[PROJECT]", "[KEY]"),
DisplayName = "display_name137f65c2",
WebSettings = new WebKeySettings(),
AndroidSettings = new AndroidKeySettings(),
IosSettings = new IOSKeySettings(),
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
CreateTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.CreateKeyAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Key>(stt::Task.FromResult(expectedResponse), null, null, null, null));
RecaptchaEnterpriseServiceClient client = new RecaptchaEnterpriseServiceClientImpl(mockGrpcClient.Object, null);
Key responseCallSettings = await client.CreateKeyAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Key responseCancellationToken = await client.CreateKeyAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Initiates the asynchronous execution of the CreateKey operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateKey operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <CreateKeyResponse> CreateKeyAsync(CreateKeyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new CreateKeyRequestMarshaller();
var unmarshaller = CreateKeyResponseUnmarshaller.Instance;
return(InvokeAsync <CreateKeyRequest, CreateKeyResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// 创建密钥
/// </summary>
public async Task <CreateKeyResponse> CreateKeyAsync(CreateKeyRequest createKeyRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("version_id", createKeyRequest.VersionId.ToString());
string urlPath = HttpUtils.AddUrlPath("/{version_id}/{project_id}/kms/create-key", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json;charset=UTF-8", createKeyRequest);
HttpResponseMessage response = await DoHttpRequestAsync("POST", request);
return(JsonUtils.DeSerialize <CreateKeyResponse>(response));
}
public async Task CreateKeyAsync_Validates_DeviceToken_NotEmpty()
{
var client = CreateTestClient();
var request = new CreateKeyRequest()
{
DeviceToken = String.Empty,
PosVendor = "Test Vendor"
};
_ = await client.CreateKeyAsync(request);
}
public async Task CreateKeyAsync_Validates_PosVendor_NotOverLength()
{
var client = CreateTestClient();
var request = new CreateKeyRequest()
{
DeviceToken = "UyWlQcseYNCC",
PosVendor = "0123456789001234567890012345678900123456789001234567890012345678900123456789001234567890012345678900123456789001234567890"
};
_ = await client.CreateKeyAsync(request);
}
public async Task CreateKeyAsync_Validates_PosVendor_NotEmpty()
{
var client = CreateTestClient();
var request = new CreateKeyRequest()
{
DeviceToken = "UyWlQcseYNCC",
PosVendor = String.Empty
};
_ = await client.CreateKeyAsync(request);
}
public async Task <string> GetKmsIdAsync()
{
if (!string.IsNullOrEmpty(_kmsId))
{
return(_kmsId);
}
using (var taggingClient = new AmazonResourceGroupsTaggingAPIClient())
{
var getResourcesRequest = new GetResourcesRequest
{
TagFilters = new List <TagFilter>
{
new TagFilter()
{
Key = KmsIdTagKey
}
}
};
var resourcesResponse = await taggingClient.GetResourcesAsync(getResourcesRequest);
if (resourcesResponse.ResourceTagMappingList.Count > 0)
{
var first = resourcesResponse.ResourceTagMappingList.First();
_kmsId = first.ResourceARN.Split('/').Last();
return(_kmsId);
}
}
using (var kmsClient = new AmazonKeyManagementServiceClient())
{
var createKeyRequest = new CreateKeyRequest
{
Description = "Key for .NET integration tests.",
Origin = OriginType.AWS_KMS,
KeyUsage = KeyUsageType.ENCRYPT_DECRYPT,
Tags = new List <Tag>
{
new Tag()
{
TagKey = KmsIdTagKey,
TagValue = string.Empty
}
}
};
var response = await kmsClient.CreateKeyAsync(createKeyRequest);
_kmsId = response.KeyMetadata.KeyId;
return(_kmsId);
}
}
public void CreateKeyRequest_Validates_Ok_When_Valid()
{
var request = new CreateKeyRequest()
{
OperatorId = "Yort",
DeviceId = Environment.GetEnvironmentVariable("Humm_Test_Sandbox_DeviceId"),
MerchantId = Environment.GetEnvironmentVariable("Humm_Test_Sandbox_MerchantId"),
PosVersion = "1.0",
DeviceToken = "UyWlQcseYNCC",
PosVendor = "Test Vendor"
};
request.Validate();
}
public async Task CreateAsync()
{
var request = new CreateKeyRequest(Storage.AccountId, _keyName, Capabilities.ReadOnly())
{
ValidDurationInSeconds = DateTime.Now.AddDays(5).Second
};
var results = await Storage.Keys.CreateAsync(request);
results.EnsureSuccessStatusCode();
_keyId = results.Response.ApplicationKeyId;
Assert.Equal(typeof(CreateKeyResponse), results.Response.GetType());
Assert.Equal(Capabilities.ReadOnly(), results.Response.Capabilities);
}
/// <summary>
/// 创建用户管理数据密钥的主密钥CMK（Custom Master Key）。
/// </summary>
/// <param name="req"><see cref="CreateKeyRequest"/></param>
/// <returns><see cref="CreateKeyResponse"/></returns>
public CreateKeyResponse CreateKeySync(CreateKeyRequest req)
{
JsonResponseModel <CreateKeyResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "CreateKey");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateKeyResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
/// <summary>Snippet for CreateKey</summary>
public void CreateKeyRequestObject()
{
// Snippet: CreateKey(CreateKeyRequest, CallSettings)
// Create client
RecaptchaEnterpriseServiceClient recaptchaEnterpriseServiceClient = RecaptchaEnterpriseServiceClient.Create();
// Initialize request argument(s)
CreateKeyRequest request = new CreateKeyRequest
{
ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
Key = new Key(),
};
// Make the request
Key response = recaptchaEnterpriseServiceClient.CreateKey(request);
// End snippet
}
public static string GetKeyByKeyStatus(KmsClient kmsClient, string status)
{
var request = new ListKeysRequest
{
VersionId = "v1.0",
Body = new ListKeysRequestBody
{
KeyState = status
}
};
try
{
var resp = kmsClient.ListKeys(request);
if (resp.Keys.Count != 0)
{
return(resp.Keys[0]);
}
var req = new CreateKeyRequest
{
VersionId = "v1.0",
Body = new CreateKeyRequestBody()
{
KeyAlias = "0000"
}
};
var createKeyResponse = kmsClient.CreateKey(req);
return(createKeyResponse.KeyInfo.KeyId);
}
catch (RequestTimeoutException requestTimeoutException)
{
Console.WriteLine(requestTimeoutException.ErrorMessage);
}
catch (ServiceResponseException clientRequestException)
{
Console.WriteLine(clientRequestException.HttpStatusCode);
Console.WriteLine(clientRequestException.ErrorCode);
Console.WriteLine(clientRequestException.ErrorMsg);
}
catch (ConnectionException connectionException)
{
Console.WriteLine(connectionException.ErrorMessage);
}
return(null);
}
private static string GetOrCreateKMSKey(AmazonS3Client s3Client,
AmazonKeyManagementServiceClient kmsClient, string bucketName)
{
try
{
// look for the s3 object that tells us the KMS key has been created
GetObjectRequest getObjectRequest = new GetObjectRequest()
{
BucketName = bucketName,
Key = KeyKMSKeyId
};
using (var getObjectResponse = s3Client.GetObject(getObjectRequest))
using (var stream = getObjectResponse.ResponseStream)
using (var reader = new StreamReader(stream))
{
return(reader.ReadToEnd());
}
}
catch (AmazonS3Exception e)
{
if (NoSuchKeyErrorCode.Equals(e.ErrorCode))
{
//create the KMS key
CreateKeyRequest createKeyRequest = new CreateKeyRequest();
createKeyRequest.Description = "Key used for Java/.NET S3 encryption client interoperability tests.";
CreateKeyResponse createKeyResponse = kmsClient.CreateKey(createKeyRequest);
String kmsKeyId = createKeyResponse.KeyMetadata.KeyId;
//save the KMS key ID into s3
PutObjectRequest putObjectRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = KeyKMSKeyId,
ContentBody = kmsKeyId
};
s3Client.PutObject(putObjectRequest);
return(kmsKeyId);
}
else
{
throw;
}
}
}
/// <summary>Snippet for CreateKeyAsync</summary>
public async Task CreateKeyRequestObjectAsync()
{
// Snippet: CreateKeyAsync(CreateKeyRequest, CallSettings)
// Additional: CreateKeyAsync(CreateKeyRequest, CancellationToken)
// Create client
RecaptchaEnterpriseServiceClient recaptchaEnterpriseServiceClient = await RecaptchaEnterpriseServiceClient.CreateAsync();
// Initialize request argument(s)
CreateKeyRequest request = new CreateKeyRequest
{
ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
Key = new Key(),
};
// Make the request
Key response = await recaptchaEnterpriseServiceClient.CreateKeyAsync(request);
// End snippet
}
public async Task CreateKeyAsync_Throws_When_Disposed()
{
var client = CreateTestClient();
client.Dispose();
var request = new CreateKeyRequest()
{
MerchantId = "30299999",
DeviceId = "d555",
OperatorId = "test_operator",
PosVersion = "123",
DeviceToken = "0123456789",
PosVendor = "Test Vendor"
};
_ = await client.CreateKeyAsync(request);
}
public async Task Client_InitializeWithAppKey()
{
var request = new CreateKeyRequest(Client.AccountId, _keyName, Capabilities.ReadOnly());
var results = await Client.Keys.CreateAsync(request);
results.EnsureSuccessStatusCode();
var options = results.Response;
var client = BackblazeClient.Initialize(options.ApplicationKeyId, options.ApplicationKey);
var findResults = await client.Buckets.FindByNameAsync(_bucketName);
Assert.Equal(_bucketName, findResults.BucketName);
var deleteResults = await Client.Keys.DeleteAsync(options.ApplicationKeyId);
Assert.Equal(typeof(DeleteKeyResponse), deleteResults.Response.GetType());
Assert.Equal(Capabilities.ReadOnly(), deleteResults.Response.Capabilities);
}
public async Task CreateAsync_With_BucketId()
{
var namePrefix = "prefix";
var request = new CreateKeyRequest(Storage.AccountId, $"{_keyName}-with-bucket-id", Capabilities.BucketOnly())
{
ValidDurationInSeconds = DateTime.Now.AddDays(5).Second,
BucketId = BucketId,
NamePrefix = namePrefix
};
var results = await Storage.Keys.CreateAsync(request);
results.EnsureSuccessStatusCode();
_keyId[1] = results.Response.ApplicationKeyId;
Assert.Equal(typeof(CreateKeyResponse), results.Response.GetType());
Assert.Equal(Capabilities.BucketOnly(), results.Response.Capabilities);
Assert.Equal(namePrefix, results.Response.NamePrefix);
}
public void Writes_Expected_CreateKey_Request_With_Signature()
{
var sigGen = new Hmac256SignatureGenerator("nb4i6ldxuVQC");
var writer = new SignedRequestWriter(sigGen);
var request = new CreateKeyRequest()
{
MerchantId = "30299999",
DeviceId = "d555",
DeviceToken = "nb4i6ldxuVQC",
OperatorId = "test_operator",
PosVersion = "123",
PosVendor = "Pos Provider"
};
var result = writer.WriteRequest(request);
Assert.AreEqual("{\"x_device_token\":\"nb4i6ldxuVQC\",\"x_pos_vendor\":\"Pos Provider\",\"x_merchant_id\":\"30299999\",\"x_device_id\":\"d555\",\"x_firmware_version\":\"123\",\"x_operator_id\":\"test_operator\",\"signature\":\"cf4f4a19662c7617ea83a47456934123f530c82cdfdd66f5b706dd2263806848\"}", result);
Assert.IsTrue(result.Contains("cf4f4a19662c7617ea83a47456934123f530c82cdfdd66f5b706dd2263806848"));
}
public async Task <IActionResult> Keys([FromBody] CreateKeyRequest request)
{
_logger.LogInformation("Adding {0} authentication key {1} to tenant {2} by {3}", request.IsAdminKey ? "admin" : "device", request.Credential.Id, User.Tenant(), User.Identity?.Name);
var credentialAttestation = request.Credential.ToCredentialAttestation();
var metadata = await _metadataService.GetMetadataAsync(credentialAttestation.Attestation.AuthenticatorData.AttestedCredentialData.Aaguid);
var credential = new KeyCredential
{
Id = WebEncoders.Base64UrlEncode(credentialAttestation.CredentialId),
PublicKey = WebEncoders.Base64UrlEncode(credentialAttestation.Attestation.AuthenticatorData
.AttestedCredentialData.PublicKey.Cbor.EncodeToBytes()),
MetadataName = metadata?.Description,
MetadataIcon = metadata?.Icon,
TenantName = User.Tenant(),
IsAdminKey = request.IsAdminKey
};
await _keyManager.CreateAsync(credential);
_logger.LogInformation("Registered {0} authentication key {1}", request.IsAdminKey ? "admin" : "device", request.Credential.Id);
return(Ok(metadata));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateKeyRequest request;
try
{
request = new CreateKeyRequest
{
CreateKeyDetails = CreateKeyDetails,
OpcRequestId = OpcRequestId,
OpcRetryToken = OpcRetryToken
};
response = client.CreateKey(request).GetAwaiter().GetResult();
WriteOutput(response, response.Key);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
/// <summary>
/// 创建一个CMK（用户主密钥），默认为启用状态
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public async Task <CreateKeyResponse> CreateKey(CreateKeyRequest request)
{
return(await new CreateKeyExecutor().Client(this).Execute <CreateKeyResponse, CreateKeyResult, CreateKeyRequest>(request).ConfigureAwait(false));
}
/// <summary>
/// 创建一个CMK（用户主密钥），默认为启用状态
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public CreateKeyResponse CreateKey(CreateKeyRequest request)
{
return(new CreateKeyExecutor().Client(this).Execute <CreateKeyResponse, CreateKeyResult, CreateKeyRequest>(request));
}
/// <summary>
/// Creates a new application key. There is a limit of 100 million key creations per account.
/// </summary>
/// <param name="request">The <see cref="CreateKeyRequest"/> to send.</param>
/// <exception cref="AuthenticationException">Thrown when authentication fails.</exception>
/// <exception cref="ApiException">Thrown when an error occurs during client operation.</exception>
async Task <IApiResults <CreateKeyResponse> > IStorageKeys.CreateAsync
(CreateKeyRequest request)
{
return(await _client.CreateKeyAsync(request, _cancellationToken));
}
