/// <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)); }