public JsonResult SignCertificaste(SignPrivateCertificateModel model)
        {
            PrivateCertificateProcessing processor = new PrivateCertificateProcessing(certificateRepository, configurationRepository, certificateProvider, authorizationLogic, templateLogic, audit);

            SignPrivateCertificateResult result = processor.SignCertificate(model, User);

            return(http.RespondSuccess(result));
        }
        private SignPrivateCertificateResult ProcessPendingSigningWorkflow(SignPrivateCertificateModel model)
        {
            SignPrivateCertificateResult result = new SignPrivateCertificateResult(PrivateCertificateRequestStatus.Pending);

            PendingCertificate pendingCertificate = new PendingCertificate(model);

            certificateRepository.Insert <PendingCertificate>(pendingCertificate);

            return(result);
        }
        public SignPrivateCertificateResult SignCertificate(SignPrivateCertificateModel model, ClaimsPrincipal user)
        {
            CertificateRequest csr = certificateProvider.InitializeFromEncodedCsr(model.EncodedCsr);

            AdcsTemplate template = templateLogic.DiscoverTemplate(csr.CipherAlgorithm, WindowsApi.Cng, KeyUsage.ServerAuthentication);

            if (authorizationLogic.IsAuthorized(template, user))
            {
                MicrosoftCertificateAuthority ca = configurationRepository.GetPrivateCertificateAuthority(model.HashAlgorithm);

                CertificateAuthorityRequestResponse response = ca.Sign(csr, template.Name, template.KeyUsage);

                return(HandleCertificateAuthorityResponse(model, response, csr.Subject));
            }
            else
            {
                return(ProcessPendingSigningWorkflow(model));
            }
        }
        private SignPrivateCertificateResult HandleCertificateAuthorityResponse(SignPrivateCertificateModel model, CertificateAuthorityRequestResponse response, CertificateSubject subject)
        {
            SignPrivateCertificateResult result;

            switch (response.CertificateRequestStatus)
            {
            case CertificateRequestStatus.Issued:
                result = ProcessCertificateAuthoritySigningResponse(model, response, subject);
                break;

            case CertificateRequestStatus.Pending:
                throw new CertificateAuthorityDeniedRequestException(string.Format("Error while processing request id {0}", response.RequestId));
                break;

            default:
                throw new CertificateAuthorityDeniedRequestException(string.Format("Error while processing request id {0}", response.RequestId));
                break;
            }

            return(result);
        }
 private SignPrivateCertificateResult ProcessCertificateAuthoritySigningResponse(SignPrivateCertificateModel model, CertificateAuthorityRequestResponse response, CertificateSubject subject)
 {
     return(null);
 }