/// <summary>
/// Given the output data from the Open Sign applet, signed text is extracted if the login data is valid.
/// </summary>
/// <param name="loginData">the output data from the Open Sign applet (base64 encoded).</param>
/// <param name="agreement">the string to match against the signed text in the login data.</param>
/// <param name="logonto">expected value of the signature parameter <code>logonto</code> for OCESI applet responses or
/// of the signature parameter <code>RequestIssuer</code> for OCESII applet responses. Can be set to <code>null</code>
/// if validation should not be performed (this is not recommended)</param>.
/// <returns>true if the signed text matches the agreement parameter</returns>
/// <throws>AppletException in case the applet returned an error code.</throws>
public static SignatureValidationStatus ValidateSignatureAgainstAgreement(string loginData, string agreement, string stylesheet, string challenge, string logonto)
{
var errorCodeChecker = new ErrorCodeChecker(loginData);
if (errorCodeChecker.HasError())
{
throw new AppletException(errorCodeChecker.ExtractError());
}
var opensignSignature = CreateOpensignSignature(Base64Decode(loginData));
ValidateSignatureParameters(opensignSignature, challenge, logonto);
var encodedSignature = EncodeSignature(opensignSignature);
var encodedAgreement = Base64Encode(agreement);
var certificate = opensignSignature.SigningCertificate;
CertificateStatus status = certificate.ValidityStatus();
if (ServiceProviderSetup.CurrentChecker.IsRevoked(certificate))
{
status = CertificateStatus.Revoked;
}
var signatureMatches = SignatureMatches(encodedSignature, encodedAgreement, stylesheet, opensignSignature);
return(new SignatureValidationStatus(opensignSignature, status, signatureMatches));
}
private ResponseObject(
CertificateID certId,
CertificateStatus certStatus,
DerGeneralizedTime thisUpdate,
DerGeneralizedTime nextUpdate,
X509Extensions extensions)
{
this.certId = certId;
if (certStatus == null)
{
this.certStatus = new CertStatus();
}
else if (certStatus is UnknownStatus)
{
this.certStatus = new CertStatus(2, DerNull.Instance);
}
else
{
RevokedStatus rs = (RevokedStatus)certStatus;
CrlReason revocationReason = rs.HasRevocationReason
? new CrlReason(rs.RevocationReason)
: null;
this.certStatus = new CertStatus(
new RevokedInfo(new DerGeneralizedTime(rs.RevocationTime), revocationReason));
}
this.thisUpdate = thisUpdate;
this.nextUpdate = nextUpdate;
this.extensions = extensions;
}
private void verifyLevel2Authentication(SecureSocket socket,
Certificate cert,
CertificateChain chain,
VerifyEventArgs e
)
{
// Verify level 1 first
verifyLevel1Authentication(socket, cert, chain, e);
if (!e.Valid)
{
return;
}
CertificateStatus certStatus =
chain.VerifyChain(null, AuthType.Client, VerificationFlags.IgnoreInvalidName);
if (certStatus != CertificateStatus.ValidCertificate)
{
if ((Adk.Debug & AdkDebugFlags.Messaging_Detailed) != 0)
{
log.Warn
("Client Certificate is not trusted and fails SIF Level 2 Authentication: " +
certStatus.ToString());
}
e.Valid = false;
}
else
{
e.Valid = true;
}
}
/**
* Add a response for a particular Certificate ID.
*
* @param certID certificate ID details
* @param certStatus status of the certificate - null if okay
* @param singleExtensions optional extensions
*/
public void AddResponse(
CertificateID certID,
CertificateStatus certStatus,
X509Extensions singleExtensions)
{
list.Add(new ResponseObject(certID, certStatus, DateTime.UtcNow, singleExtensions));
}
public async Task <Unit> Handle(CertificateReprintRequest request, CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.CertificateReference, request.LastName, request.AchievementDate);
if (certificate == null)
{
throw new NotFound();
}
if (certificate.Status == CertificateStatus.Reprint)
{
return(Unit.Value);
}
if (CertificateStatus.CanRequestDuplicateCertificate(certificate.Status))
{
certificate.Status = CertificateStatus.Reprint;
await _certificateRepository.Update(certificate, request.Username, CertificateActions.Reprint);
}
else
{
throw new NotFound();
}
return(Unit.Value);
}
public static SignatureValidationStatus validateSignatureAgainstAgreementPDF(String loginData, String agreement, String challenge, String logonto)
{
var errorCodeChecker = new ErrorCodeChecker(loginData);
if (errorCodeChecker.HasError())
{
throw new AppletException(errorCodeChecker.ExtractError());
}
var opensignSignature = CreateOpensignSignature(Base64Decode(loginData));
ValidateChallenge(opensignSignature, challenge);
if (logonto != null)
{
ValidateLogonto(opensignSignature, logonto);
}
String encodedSignature = Base64Encode(Encoding.ASCII.GetString(opensignSignature.SignedDocument.SignedContent));
var encodedAgreement = Base64Encode(agreement);
var certificate = opensignSignature.SigningCertificate;
CertificateStatus status = certificate.ValidityStatus();
if (ServiceProviderSetup.CurrentChecker.IsRevoked(certificate))
{
status = CertificateStatus.Revoked;
}
var signatureMatches = SignatureMatches(encodedSignature, encodedAgreement, null, opensignSignature);
//@TODO HER MANGLER CHECK AF ATTACHMENTS !
return(new SignatureValidationStatus(opensignSignature, status, signatureMatches));
}
public async Task <IActionResult> GetLearner(long uln, string familyName, [SwaggerParameter("Standard Code or Standard Reference Number")] string standard)
{
var getRequest = new GetBatchLearnerRequest {
UkPrn = _headerInfo.Ukprn, Uln = uln, FamilyName = familyName, Standard = standard
};
var response = await _apiClient.GetLearner(getRequest);
if (response.ValidationErrors.Any())
{
ApiResponse error = new ApiResponse((int)HttpStatusCode.Forbidden, string.Join("; ", response.ValidationErrors));
return(StatusCode(error.StatusCode, error));
}
else if (response.Learner is null)
{
return(NotFound());
}
else if (response.Learner.Certificate is null)
{
return(Ok(response.Learner));
}
else
{
if (CertificateHelpers.IsDraftCertificateDeemedAsReady(response.Learner.Certificate))
{
response.Learner.Certificate.Status.CurrentStatus = CertificateStatus.Ready;
}
else if (CertificateStatus.HasPrintProcessStatus(response.Learner.Certificate.Status.CurrentStatus))
{
response.Learner.Certificate.Status.CurrentStatus = CertificateStatus.Submitted;
}
return(Ok(response.Learner));
}
}
public ActionResult Verify(string xml)
{
Response response = new Response(xml);
Challenge challenge = Session["challenge"] as Challenge;
if (!response.Valid(challenge))
{
return(Json(new { error = "Invalid DSIG" }, JsonRequestBehavior.AllowGet));
}
OcspClient ocspclient = new OcspClient();
// This uses the BouncyCastle X509 primitives (Org.BouncyCastle.X509)
X509CertificateParser parser = new X509CertificateParser();
var fullgiltbytes = System.IO.File.ReadAllBytes(HttpContext.Server.MapPath("~/certs/fullgilt.cer"));
X509Certificate fullgilt = parser.ReadCertificate(fullgiltbytes);
X509Certificate user = parser.ReadCertificate(response.Certificate);
try
{
CertificateStatus ocspresonse = ocspclient.Query(user, fullgilt);
if (ocspresonse != CertificateStatus.Good)
{
return(Json(new { error = Enum.GetName(typeof(CertificateStatus), ocspresonse) }));
}
// Do your normal login stuff here.
Session["LoggedIn"] = true;
return(Json(new { valid = true, msg = "Login successful" }, JsonRequestBehavior.AllowGet));
}
catch (Org.BouncyCastle.Ocsp.OcspException ocspex)
{
return(Json(new { error = ocspex.Message }, JsonRequestBehavior.AllowGet));
}
}
protected virtual void SendCertificateStatusMessage(CertificateStatus certificateStatus)
{
HandshakeMessage handshakeMessage = new HandshakeMessage(22);
certificateStatus.Encode(handshakeMessage);
handshakeMessage.WriteToRecordStream(this);
}
/// <summary>The default constructor for CertificateVerification.</summary>
/// <remarks>The default constructor for CertificateVerification.</remarks>
/// <param name="cert"></param>
/// <param name="ctx"></param>
public CertificateVerification(CertificateAndContext cert, ValidationContext ctx)
{
certificate = cert;
if (cert != null)
{
try
{
cert.GetCertificate().CheckValidity(ctx.GetValidationDate());
validityPeriodVerification = new Result(Result.ResultStatus.VALID, null);
}
catch (CertificateExpiredException)
{
validityPeriodVerification = new Result(Result.ResultStatus.INVALID, "certificate.expired"
);
}
catch (CertificateNotYetValidException)
{
validityPeriodVerification = new Result(Result.ResultStatus.INVALID, "certificate.not.yet.valid"
);
}
CertificateStatus status = ctx.GetCertificateStatusFromContext(cert);
if (status != null)
{
certificateStatus = new RevocationVerificationResult(status);
}
}
}
protected void Page_Load(object sender , EventArgs e)
{
string s = Request.QueryString[Helper.queryParam_specialty]; //专业id
status = GetStatus();
int p = PageIndex; //当前页码
v = !string.IsNullOrEmpty(s);
int rowcount = 0; // 记录数
if (!IsPostBack) {
IList<Certificate> list = RepositoryFactory<CertificateRepository>.Get().GetList(status , s , p , PageSize , out rowcount);
if (string.IsNullOrWhiteSpace(s)) {
} else {
linkAdd.NavigateUrl = "Add.aspx?s=" + s;
linkAdd.Visible = true;
}
Pager1.RecordCount = rowcount;
Pager1.PageSize = PageSize;
PageIndex = Helper.GetRealPageIndex(PageSize , rowcount , p);
rptList.DataSource = list.OrderByDescending(P => P.ReceiveDateTime);
rptList.DataBind();
}
}
public bool isValidCertificate(ECertificate certificate)
{
try
{
ValidationPolicy validationPolicy = CertValidationPolicyManager.getInstance().getValidationPolicy();
ValidationSystem vs = CertificateValidation.createValidationSystem(validationPolicy);
vs.setBaseValidationTime(DateTime.UtcNow);
CertificateStatusInfo csi = CertificateValidation.validateCertificate(vs, certificate);
CertificateStatus certificateStatus = csi.getCertificateStatus();
string statusText = certificateStatus.textAl();
//System.Console.WriteLine("Doğrulama Sonucu");
//System.Console.WriteLine(statusText);
//System.Console.WriteLine(csi.checkResultsToString());
//System.Console.WriteLine(csi.getDetailedMessage());
Program.HataMesaji = "\n\r" + csi.checkResultsToString() + "\n\r" + csi.getDetailedMessage();
return(certificateStatus == CertificateStatus.VALID);
}
catch (Exception exc)
{
// System.Console.WriteLine(exc.Message);
Program.HataMesaji = exc.Message;
return(false);
}
}
private void cboCertNew_MouseClick(object sender, MouseEventArgs e)
{
this.cboCertNew.Visible = true;
this.label3.Visible = true;
cboCertNew.Items.Clear();
string strPath = Globals.currentDirectory;
X509Store store = new X509Store("MY", StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2Collection filterCerts = store.Certificates.Find(X509FindType.FindByTimeValid, DateTime.Now, false);
String CN = "";
foreach (X509Certificate2 x509 in filterCerts)
{
CVM cvm = CVM.GetInstance();
string configFileName = strPath + @"cvm.xml";
cvm.config(configFileName);
CertificateStatus ret = cvm.VerifyCertificate(x509);
if (ret == CertificateStatus.VALID)
{
String subjectname = x509.Subject;
String[] names = subjectname.Split(',');
foreach (String name in names)
{
if (name.IndexOf("CN=") > 0)
{
int begin = name.IndexOf("CN=");
int len = name.Length;
CN = name.Substring(4, len - 4);
cboCertNew.Items.Add(CN);
cboCertificate.Items.Add(CN);
}
}
}
}
if (CN.Equals("") || CN == null)
{
// MessageBox.Show("没有有效的证书，请联系管理员！");
}
store.Close();
if (cboCertificate.Items.Count != 0)
{
cboCertificate.Text = cboCertificate.Items[0].ToString();
cboCertNew.Text = cboCertificate.Items[0].ToString();
cboCertNew.SelectedIndex = 0;
}
try
{
cboCertNew.Focus();
}
catch (Exception ex)
{
Globals.logAdapter.Record("EX925511256761", ex.Message + ">>" + ex.ToString(), true);
}
}
public void GetCertificateStatusFromModel(CertificateStatus certificateStatus)
{
certificateStatus.NationalDefenseAndSecurity = NationalDefenseAndSecurity;
certificateStatus.PhysicalEducation = PhysicalEducation;
certificateStatus.Language = Language;
certificateStatus.Informatics = Informatics;
certificateStatus.ExtracurricularPoint = ExtracurricularPoint;
}
public ResponseObject(
CertificateID certId,
CertificateStatus certStatus,
DateTime thisUpdate,
X509Extensions extensions)
: this(certId, certStatus, new DerGeneralizedTime(thisUpdate), null, extensions)
{
}
/// <summary>
///
/// </summary>
/// <param name="certID"></param>
/// <param name="certStatus"></param>
/// <param name="thisUpdate"></param>
/// <param name="nextUpdate"></param>
/// <param name="singleExtensions"></param>
public void addResponse(
CertificateID certID,
CertificateStatus certStatus,
DateTime thisUpdate,
DateTime nextUpdate,
X509Extensions singleExtensions)
{
list.Add(new ResponseObject(certID, certStatus, thisUpdate, nextUpdate, singleExtensions));
}
/// <summary>
/// Constructor at character's initialization time
/// </summary>
/// <param name="character"></param>
/// <param name="src"></param>
/// <param name="certClass"></param>
internal Certificate(Character character, StaticCertificate src, CertificateClass certClass)
{
m_staticData = src;
m_class = certClass;
m_character = character;
m_status = CertificateStatus.Untrained;
m_prereqSkills = new List<SkillLevel>(src.PrerequisiteSkills.ToCharacter(character));
m_prereqCertificates = new List<Certificate>();
}
/// <summary>
/// Constructor at character's initialization time
/// </summary>
/// <param name="character"></param>
/// <param name="src"></param>
/// <param name="certClass"></param>
internal Certificate(Character character, StaticCertificate src, CertificateClass certClass)
{
m_staticData = src;
m_class = certClass;
m_character = character;
m_status = CertificateStatus.Untrained;
m_prereqSkills = new List <SkillLevel>(src.PrerequisiteSkills.ToCharacter(character));
m_prereqCertificates = new List <Certificate>();
}
/// <summary>
/// Gets the certificates with the specified status
/// </summary>
/// <param name="status">The status the certificates must have</param>
/// <returns></returns>
public IEnumerable <Certificate> FilterByStatus(CertificateStatus status)
{
foreach (var cert in m_items.Values)
{
if (cert.Status == status)
{
yield return(cert);
}
}
}
public void InstallCertificate(CertificateStatus statusPreviousCertificate)
{
if (!File.Exists(_options.WellKnownFilePaths[WellKnownFile.CrtPfx]))
{
Log.Error("Certificate to install not found!");
return;
}
Log.Information("Installing certificate in store");
X509Store store = null;
X509Certificate2 newCertificate = null;
X509Certificate2 knownCertificate = null;
try
{
store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
Log.Information($"Opened Certificate Store {store.Name}");
X509KeyStorageFlags flags = X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.PersistKeySet;
// See http://paulstovell.com/blog/x509certificate2
newCertificate = new X509Certificate2(_options.WellKnownFilePaths[WellKnownFile.CrtPfx], _options.PfxPassword, flags)
{
FriendlyName = $"{_options.HostName} {(_options.TestMode ? "FAKE " : "")}{DateTime.UtcNow:O}"
};
knownCertificate = store.Certificates.OfType <X509Certificate2>().FirstOrDefault(c => c.Thumbprint == newCertificate.Thumbprint);
if (knownCertificate != null)
{
Log.Information($"Certificate already in the Store {knownCertificate.FriendlyName}");
}
else
{
Log.Information($"Adding Certificate to Store {newCertificate.FriendlyName}");
store.Add(newCertificate);
knownCertificate = newCertificate;
}
bool needsRecycle = !_options.Renew || statusPreviousCertificate == CertificateStatus.NotFound;
_iisService.Install(store, knownCertificate, needsRecycle);
}
finally
{
Log.Information("Closing Certificate Store");
IDisposable disposable = newCertificate as IDisposable;
disposable?.Dispose();
disposable = knownCertificate as IDisposable;
disposable?.Dispose();
store?.Close();
}
}
/// <summary>
/// Try to update the certificate's status.
/// </summary>
/// <returns>True if the status was updated, false otherwise.</returns>
internal bool TryUpdateCertificateStatus()
{
if (m_initialized)
{
return(false);
}
bool claimable = true;
bool noPrereq = true;
// Scan prerequisite certfiicates
foreach (var cert in m_prereqCertificates)
{
// Status not defined yet ? Then, we quit
if (!cert.m_initialized)
{
return(false);
}
// Claimable only if every prereq certificate has been granted
claimable &= (cert.Status == CertificateStatus.Granted);
// Untrainable if no prereq is satisfied
noPrereq &= (cert.Status == CertificateStatus.Untrained | cert.Status == CertificateStatus.PartiallyTrained);
}
// Scan prerequisite skills
foreach (var prereqSkill in m_prereqSkills)
{
var skill = prereqSkill.Skill;
// Claimable only if the skill's level is grater or equal than the minium level
claimable &= (skill.Level >= prereqSkill.Level);
// Untrainable if no prereq is satisfied
noPrereq &= (skill.Level < prereqSkill.Level);
}
// Updates status
if (claimable)
{
m_status = CertificateStatus.Claimable;
}
else if (noPrereq)
{
m_status = CertificateStatus.Untrained;
}
else
{
m_status = CertificateStatus.PartiallyTrained;
}
m_initialized = true;
return(true);
}
/// <summary>
/// verifies the certificate chain against the certificate store
/// </summary>
/// <param name="allCertsReceived">the chain to verify</param>
/// <param name="expectedCNName">the expected CN; may be null</param>
/// <param name="authType">the authtype: is the certificate to verify a client or server certificate;
/// i.e when verifying a client cert, pass AuthType.Client; when verifying a server cert: pass AuthType.Server</param>ram>
/// <returns></returns>
protected bool IsValidCertificate(CertificateChain allCertsReceived, string expectedCNName, AuthType authType)
{
VerificationFlags verificationFlags = VerificationFlags.None;
if (expectedCNName == null)
{
verificationFlags = VerificationFlags.IgnoreInvalidName;
}
CertificateStatus status = allCertsReceived.VerifyChain(expectedCNName, authType, verificationFlags);
return(status == CertificateStatus.ValidCertificate);
}
/// <summary>
/// Gets an <see cref="OCSPSingleResponse"/> object from the <see cref="OCSPSingleResponseCollection"/> object by revoked certificate's
/// serial number.
/// </summary>
/// <param name="status">A string that represents a <see cref="OCSPSingleResponse.CertStatus">CertStatus</see>
/// property.</param>
/// <remarks>Use this property to retrieve an <see cref="OCSPSingleResponse"/> object from an <see cref="OCSPSingleResponseCollection"/>
/// object if you know the <see cref="OCSPSingleResponse.CertStatus">Status</see> value of the <see cref="OCSPSingleResponse"/>
/// object. You can use the <see cref="this[int]"/> property to retrieve an <see cref="OCSPSingleResponse"/> object if you know
/// its location in the collection</remarks>
/// <returns>An <see cref="OCSPSingleResponse"/> object.</returns>
public OCSPSingleResponse this[CertificateStatus status] {
get {
foreach (OCSPSingleResponse entry in _list)
{
if (entry.CertStatus == status)
{
return(entry);
}
}
return(null);
}
}
/// <summary>The default constructor for RevocationVerificationResult.</summary>
/// <remarks>The default constructor for RevocationVerificationResult.</remarks>
public RevocationVerificationResult(CertificateStatus certificateStatus)
{
if (certificateStatus != null)
{
this.certificateStatus = certificateStatus;
}
else
{
this.certificateStatus = new CertificateStatus();
this.certificateStatus.Validity = CertificateValidity.UNKNOWN;
}
}
public async Task <Certificate> Handle(StaffCertificateDuplicateRequest request,
CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.Id);
if (CertificateStatus.CanRequestDuplicateCertificate(certificate.Status))
{
certificate.Status = CertificateStatus.Reprint;
await _certificateRepository.Update(certificate, request.Username, action : CertificateActions.Reprint);
}
return(certificate);
}
private DateTime GetUpdatedStatusDate(string learnerCertificateStatus)
{
if (CertificateStatus.HasPrintNotificateStatus(learnerCertificateStatus))
{
if (Learner.PrintStatusAt != null)
{
return((DateTime)Learner.PrintStatusAt);
}
}
if (Learner.LastUpdatedAt != null)
{
return((DateTime)Learner.LastUpdatedAt);
}
return(default);
/// <summary>
/// Procesa la respuesta del servidor OCSP y devuelve el estado del certificado
/// </summary>
/// <param name="binaryResp"></param>
/// <returns></returns>
public CertificateStatus ProcessOcspResponse(byte[] binaryResp, bool checkNonce)
{
if (binaryResp.Length == 0)
{
return(CertificateStatus.Unknown);
}
OcspResp r = new OcspResp(binaryResp);
CertificateStatus cStatus = CertificateStatus.Unknown;
if (r.Status == OcspRespStatus.Successful)
{
BasicOcspResp or = (BasicOcspResp)r.GetResponseObject();
if (checkNonce)
{
if (or.GetExtensionValue(OcspObjectIdentifiers.PkixOcspNonce).ToString() !=
_nonceAsn1OctetString.ToString())
{
throw new Exception("Bad nonce value");
}
}
if (or.Responses.Length == 1)
{
SingleResp resp = or.Responses[0];
object certificateStatus = resp.GetCertStatus();
if (certificateStatus == Org.BouncyCastle.Ocsp.CertificateStatus.Good)
{
cStatus = CertificateStatus.Good;
}
else if (certificateStatus is Org.BouncyCastle.Ocsp.RevokedStatus)
{
cStatus = CertificateStatus.Revoked;
}
else if (certificateStatus is Org.BouncyCastle.Ocsp.UnknownStatus)
{
cStatus = CertificateStatus.Unknown;
}
}
}
else
{
throw new Exception("Unknow status '" + r.Status + "'.");
}
return(cStatus);
}
/// <summary>
/// Sets the WaitHandle to signalled and calls the appropriate delegate.
/// </summary>
/// <param name="error">An exception that may have occurred.</param>
/// <param name="status">The status of the certificate chain.</param>
internal void VerificationCompleted(Exception error, CertificateStatus status)
{
m_ThrowException = error;
m_Status = status;
m_IsCompleted = true;
if (m_Callback != null)
{
m_Callback(this);
}
if (m_WaitHandle != null)
{
m_WaitHandle.Set();
}
}
public static PassportStatus ContractTypeToApiType(CertificateStatus contractType)
{
switch (contractType)
{
case CertificateStatus.PrivatePerson:
return(PassportStatus.PrivatePerson);
case CertificateStatus.Entity:
return(PassportStatus.Entity);
default:
throw new ArgumentOutOfRangeException(nameof(contractType), contractType, null);
}
}
private CertificateStatus processOcspResponse(X509Certificate clientCert, X509Certificate issuerCert, byte[] binaryResp, out string respMsg)
{
OcspResp r = new OcspResp(binaryResp);
CertificateStatus cStatus = CertificateStatus.unknown;
switch (r.Status)
{
case OcspRespStatus.Successful:
BasicOcspResp or = (BasicOcspResp)r.GetResponseObject();
validateResponse(or, issuerCert);
respMsg = string.Empty;
if (or.Responses.Length == 1)
{
SingleResp resp = or.Responses[0];
validateCertificateId(issuerCert, clientCert, resp.GetCertID());
validateThisUpdate(resp);
validateNextUpdate(resp);
Object certificateStatus = resp.GetCertStatus();
if (certificateStatus == Org.BouncyCastle.Ocsp.CertificateStatus.Good)
{
cStatus = CertificateStatus.good;
respMsg = "Certificado Válido";
}
else if (certificateStatus is RevokedStatus)
{
cStatus = CertificateStatus.revoked;
respMsg = "Certificado Revocado";
}
else if (certificateStatus is UnknownStatus)
{
cStatus = CertificateStatus.unknown;
respMsg = "Certificado Desconocido";
}
}
break;
default:
respMsg = "No se ha podido procesar la respuesta OCSP";
//throw new Exception("Status Desconocido '" + r.Status + "'.");
return(cStatus);
}
return(cStatus);
}
private async Task <Certificate> GetCertificate(GetBatchCertificateRequest request)
{
_logger.LogInformation("GetCertificate Before Get Certificate from db");
var certificate = await _certificateRepository.GetCertificate(request.Uln, request.StandardCode, request.FamilyName, request.IncludeLogs);
_logger.LogInformation("GetCertificate Before Get Searching Organisation from db");
var searchingOrganisation = await _organisationQueryRepository.GetByUkPrn(request.UkPrn);
var allowedCertificateStatus = new[] { CertificateStatus.Draft, CertificateStatus.Submitted }.Concat(CertificateStatus.PrintProcessStatus);
if (certificate == null || searchingOrganisation == null || !allowedCertificateStatus.Contains(certificate.Status))
{
return(null);
}
var certData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
certificate = await CertificateHelpers.ApplyStatusInformation(_certificateRepository, _contactQueryRepository, certificate);
if ((certificate.Status == CertificateStatus.Submitted || CertificateStatus.HasPrintProcessStatus(certificate.Status)) && certData.OverallGrade == CertificateGrade.Fail)
{
return(null);
}
else if (certificate.Status == CertificateStatus.Draft &&
EpaOutcome.Pass.Equals(certData.EpaDetails?.LatestEpaOutcome, StringComparison.InvariantCultureIgnoreCase) &&
certData.OverallGrade == null)
{
return(null);
}
if (certificate.OrganisationId != searchingOrganisation.Id)
{
var providedStandards = await _standardRepository.GetEpaoRegisteredStandards(searchingOrganisation.EndPointAssessorOrganisationId, int.MaxValue, 1);
if (providedStandards.PageOfResults.Any(s => s.StandardCode == certificate.StandardCode))
{
// Shared standard but not the EPAO who created the certificate
certificate = RedactCertificateInformation(certificate, false);
}
else
{
certificate = null;
}
}
return(certificate);
}
public async Task <Certificate> Handle(UpdateCertificateRequestReprintCommand request, CancellationToken cancellationToken)
{
var certificate = await _certificateRepository.GetCertificate(request.CertificateId);
if (certificate == null)
{
throw new NotFoundException();
}
if (certificate.Status != CertificateStatus.Reprint && CertificateStatus.CanRequestReprintCertificate(certificate.Status))
{
certificate.Status = CertificateStatus.Reprint;
await _certificateRepository.Update(certificate, request.Username, CertificateActions.Reprint);
}
return(certificate);
}
/// <summary>
/// Try to update the certificate's status.
/// </summary>
/// <returns>True if the status was updated, false otherwise.</returns>
internal bool TryUpdateCertificateStatus()
{
if (m_initialized) return false;
bool claimable = true;
bool noPrereq = true;
// Scan prerequisite certfiicates
foreach (var cert in m_prereqCertificates)
{
// Status not defined yet ? Then, we quit
if (!cert.m_initialized) return false;
// Claimable only if every prereq certificate has been granted
claimable &= (cert.Status == CertificateStatus.Granted);
// Untrainable if no prereq is satisfied
noPrereq &= (cert.Status == CertificateStatus.Untrained | cert.Status == CertificateStatus.PartiallyTrained);
}
// Scan prerequisite skills
foreach (var prereqSkill in m_prereqSkills)
{
var skill = prereqSkill.Skill;
// Claimable only if the skill's level is grater or equal than the minium level
claimable &= (skill.Level >= prereqSkill.Level);
// Untrainable if no prereq is satisfied
noPrereq &= (skill.Level < prereqSkill.Level);
}
// Updates status
if (claimable) m_status = CertificateStatus.Claimable;
else if (noPrereq) m_status = CertificateStatus.Untrained;
else m_status = CertificateStatus.PartiallyTrained;
m_initialized = true;
return true;
}
public bool IsOfStatus(CertificateStatus status)
{
switch (status)
{
case CertificateStatus.None:
return false;
case CertificateStatus.All:
return true;
default:
return Status == status;
}
}
/// <summary>
/// Sets the WaitHandle to signalled and calls the appropriate delegate.
/// </summary>
/// <param name="error">An exception that may have occurred.</param>
/// <param name="status">The status of the certificate chain.</param>
internal void VerificationCompleted(Exception error, CertificateStatus status) {
m_ThrowException = error;
m_Status = status;
m_IsCompleted = true;
if (m_Callback != null)
m_Callback(this);
if (m_WaitHandle != null)
m_WaitHandle.Set();
}
public SignatureValidationStatus(OpensignSignature signature, CertificateStatus certificateStatus, bool signatureMatches)
{
Signature = signature;
CertificateStatus = certificateStatus;
SignatureMatches = signatureMatches;
}
/// <summary>
/// Restes the data before we import a deserialization object
/// </summary>
/// <param name="fromCCP"></param>
internal void Reset()
{
m_status = CertificateStatus.Untrained;
m_initialized = false;
}
/// <summary>
/// Marks the certificate as granted
/// </summary>
internal void MarkAsGranted()
{
m_status = CertificateStatus.Granted;
m_initialized = true;
}
public virtual CertificateStatus Check(X509Certificate childCertificate, X509Certificate
certificate, DateTime validationDate)
{
CertificateStatus status = new CertificateStatus();
status.Certificate = childCertificate;
status.ValidationDate = validationDate;
status.IssuerCertificate = certificate;
if (ocspSource == null)
{
LOG.Warn("OCSPSource null");
return null;
}
try
{
BasicOcspResp ocspResp = ocspSource.GetOcspResponse(childCertificate, certificate
);
if (null == ocspResp)
{
LOG.Info("OCSP response not found");
return null;
}
BasicOcspResp basicOCSPResp = (BasicOcspResp)ocspResp;
CertificateID certificateId = new CertificateID(CertificateID.HashSha1, certificate
, childCertificate.SerialNumber);
SingleResp[] singleResps = basicOCSPResp.Responses;
foreach (SingleResp singleResp in singleResps)
{
CertificateID responseCertificateId = singleResp.GetCertID();
if (false == certificateId.Equals(responseCertificateId))
{
continue;
}
DateTime thisUpdate = singleResp.ThisUpdate;
LOG.Info("OCSP thisUpdate: " + thisUpdate);
LOG.Info("OCSP nextUpdate: " + singleResp.NextUpdate);
status.StatusSourceType = ValidatorSourceType.OCSP;
status.StatusSource = ocspResp;
status.RevocationObjectIssuingTime = ocspResp.ProducedAt;
if (null == singleResp.GetCertStatus())
{
LOG.Info("OCSP OK for: " + childCertificate.SubjectDN);
status.Validity = CertificateValidity.VALID;
}
else
{
LOG.Info("OCSP certificate status: " + singleResp.GetCertStatus().GetType().FullName
);
if (singleResp.GetCertStatus() is RevokedStatus)
{
LOG.Info("OCSP status revoked");
if (validationDate.CompareTo(((RevokedStatus)singleResp.GetCertStatus()).RevocationTime) < 0) //jbonilla - Before
{
LOG.Info("OCSP revocation time after the validation date, the certificate was valid at "
+ validationDate);
status.Validity = CertificateValidity.VALID;
}
else
{
status.RevocationDate = ((RevokedStatus)singleResp.GetCertStatus()).RevocationTime;
status.Validity = CertificateValidity.REVOKED;
}
}
else
{
if (singleResp.GetCertStatus() is UnknownStatus)
{
LOG.Info("OCSP status unknown");
status.Validity = CertificateValidity.UNKNOWN;
}
}
}
return status;
}
LOG.Info("no matching OCSP response entry");
return null;
}
catch (IOException ex)
{
LOG.Error("OCSP exception: " + ex.Message);
return null;
}
catch (OcspException ex)
{
LOG.Error("OCSP exception: " + ex.Message);
throw new RuntimeException(ex);
}
}
public CertificateAndStatus(OcesCertificate certificate,
CertificateStatus certificateStatus)
{
Certificate = certificate;
CertificateStatus = certificateStatus;
}
/// <summary>
/// Translates the certificate status
/// </summary>
/// <param name="status">The CertificateStatus</param>
/// <returns>Descriptive message.</returns>
public static string GetCertificateStatusText(CertificateStatus status)
{
return ErrorCodes["certificate." + status];
}
