/// <summary>
/// Handles a certificate validation error.
/// </summary>
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
ManualResetEvent ev = new ManualResetEvent(false);
Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
async () =>
{
await GuiUtils.HandleCertificateValidationError(this, validator, e);
ev.Set();
}
).AsTask().Wait();
ev.WaitOne();
}
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (InvokeRequired)
{
Invoke(new CertificateValidationEventHandler(CertificateValidator_CertificateValidation), validator, e);
return;
}
try
{
GuiUtils.HandleCertificateValidationError(this, validator, e);
}
catch (Exception exception)
{
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
}
}
private void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
e.Accept = autoAccept;
if (autoAccept)
{
Log(conn_name + " - " + "Accepted Certificate: " + e.Certificate.Subject);
}
else
{
Log(conn_name + " - " + "Rejected Certificate: " + e.Certificate.Subject);
}
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
try
{
Opc.Ua.Client.Controls.GuiUtils.HandleCertificateValidationError(this, validator, e);
}
catch (Exception exception)
{
Opc.Ua.Client.Controls.GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="caller">The caller's text is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static async Task HandleCertificateValidationError(Page caller, CertificateValidator validator, CertificateValidationEventArgs e)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat("Certificate could not be validated: {0}\r\n\r\n", e.Error.StatusCode);
buffer.AppendFormat("Subject: {0}\r\n", e.Certificate.Subject);
buffer.AppendFormat("Issuer: {0}\r\n", (e.Certificate.Subject == e.Certificate.Issuer) ? "Self-signed" : e.Certificate.Issuer);
buffer.AppendFormat("Thumbprint: {0}\r\n\r\n", e.Certificate.Thumbprint);
buffer.AppendFormat("The security certificate was not issued by a trusted certificate authority.\r\n");
buffer.AppendFormat("Security certificate problems may indicate an attempt to intercept any data you send\r\n");
buffer.AppendFormat("to a server or to allow an untrusted client to connect to your server.\r\n");
buffer.AppendFormat("\r\nAccept anyway?");
MessageDlg dialog = new MessageDlg(buffer.ToString(), MessageDlgButton.Yes, MessageDlgButton.No);
MessageDlgButton result = await dialog.ShowAsync();
if (result == MessageDlgButton.Yes)
{
e.Accept = true;
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="caller">The caller's text is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static void HandleCertificateValidationError(Form caller, CertificateValidator validator, CertificateValidationEventArgs e)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat("Certificate could not be validated: {0}\r\n\r\n", e.Error.StatusCode);
buffer.AppendFormat("Subject: {0}\r\n", e.Certificate.Subject);
buffer.AppendFormat("Issuer: {0}\r\n", (e.Certificate.Subject == e.Certificate.Issuer)?"Self-signed":e.Certificate.Issuer);
buffer.AppendFormat("Valid From: {0}\r\n", e.Certificate.NotBefore);
buffer.AppendFormat("Valid To: {0}\r\n", e.Certificate.NotAfter);
buffer.AppendFormat("Thumbprint: {0}\r\n\r\n", e.Certificate.Thumbprint);
buffer.AppendFormat("The security certificate was not issued by a trusted certificate authority. ");
buffer.AppendFormat("Security certificate problems may indicate an attempt to intercept any data you send ");
buffer.AppendFormat("to a server or to allow an untrusted client to connect to your server.");
buffer.AppendFormat("\r\n\r\nAccept anyway?");
if (MessageBox.Show(buffer.ToString(), caller.Text, MessageBoxButtons.YesNo) == DialogResult.Yes)
{
e.Accept = true;
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
private void CertificateValidator_CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
{
if (this.InvokeRequired)
{
this.Invoke(new CertificateValidationEventHandler(CertificateValidator_CertificateValidation), sender, e);
return;
}
try
{
e.Accept = m_configuration.SecurityConfiguration.AutoAcceptUntrustedCertificates;
if (!m_configuration.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
DialogResult result = MessageBox.Show(
e.Certificate.Subject,
"Untrusted Certificate",
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning);
e.Accept = (result == DialogResult.Yes);
}
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
public static Task OnCertificateValidation(object sender, CertificateValidationEventArgs e)
{
if (e.SslPolicyErrors == System.Net.Security.SslPolicyErrors.None)
e.IsValid = true;
return Task.FromResult(0);
}
private void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
e.Accept = config.SecurityConfiguration.AutoAcceptUntrustedCertificates;
if (config.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
info.LabelText = "Accepted Certificate: " + e.Certificate.Subject.ToString();
}
else
{
info.LabelText = "Rejected Certificate: " + e.Certificate.Subject.ToString();
}
}
}
/// <summary>
/// Prompts the user to accept an untrusted certificate.
/// </summary>
private void CertificateValidator_CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
{
if (this.InvokeRequired)
{
this.Invoke(new CertificateValidationEventHandler(CertificateValidator_CertificateValidation), sender, e);
return;
}
try
{
DialogResult result = MessageBox.Show(
e.Certificate.Subject,
"Untrusted Certificate",
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning);
e.Accept = (result == DialogResult.Yes);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private static void CertificateValidator_CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateTimeInvalid)
{
//if (isInvalidPeriodAccepted)
{
e.Accept = true;
return;
}
return;
}
else if (e.Error.StatusCode == StatusCodes.BadCertificateHostNameInvalid)
{
//if (isInvalidHostNameAllowed)
{
e.Accept = true;
return;
}
}
else if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
if (configuredEndpoint.Description.SecurityPolicyUri == SecurityPolicies.None &&
configuredEndpoint.Description.SecurityMode == MessageSecurityMode.None)
{
e.Accept = true;
return;
}
}
e.Accept = false;
return;
}
private static void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
string logPrefix = $"{_logClassPrefix}:CertificateValidator_CertificateValidation:";
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
e.Accept = AutoAccept;
if (AutoAccept)
{
Logger.Verbose($"{logPrefix} Accepted Certificate: {0}", e.Certificate.Subject);
}
else
{
Logger.Warning($"{logPrefix} Rejected Certificate: {0}", e.Certificate.Subject);
}
}
}
/// <summary>
/// Standard certificate validation callback
/// </summary>
private static void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
Trace("Certificate \""
+ e.Certificate.Subject
+ "\" not trusted. If you want to trust this certificate, please copy it from the \""
+ m_configuration.SecurityConfiguration.RejectedCertificateStore.StorePath + "/certs"
+ "\" to the \""
+ m_configuration.SecurityConfiguration.TrustedPeerCertificates.StorePath + "/certs"
+ "\" folder. A restart of the gateway is NOT required.");
}
}
/// <summary>
/// UI: handle server certificate validation
/// and prompt for user interaction if required.
/// </summary>
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
ManualResetEvent ev = new ManualResetEvent(false);
Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
async() =>
{
await GuiUtils.HandleCertificateValidationError(this, validator, e);
if (e.Accept)
{
MessageDialog showDialog = new MessageDialog("Would you like to save this certificate?");
showDialog.Commands.Add(new UICommand("Save")
{
Id = 0
});
showDialog.Commands.Add(new UICommand("Cancel")
{
Id = 1
});
showDialog.DefaultCommandIndex = 1;
showDialog.CancelCommandIndex = 1;
var result = await showDialog.ShowAsync();
if ((int)result.Id == 0)
{
try
{
byte[] cert = e.Certificate.Export(System.Security.Cryptography.X509Certificates.X509ContentType.Cert);
string issuerName = e.Certificate.GetNameInfo(System.Security.Cryptography.X509Certificates.X509NameType.SimpleName, true);
string filePath = Path.Combine(m_cert_full_path, String.Format("{0} [{1}].der", issuerName, e.Certificate.Thumbprint));
File.WriteAllBytes(filePath, cert);
}
catch (Exception)
{
}
}
}
progringConnection.IsActive = true;
ev.Set();
}
).AsTask().Wait();
ev.WaitOne();
}
private static void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
e.Accept = false;
Console.WriteLine("Rejected Certificate: {0}", e.Certificate.Subject);
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
private void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
try
{
if (m_applicationConfiguration.SecurityConfiguration != null &&
m_applicationConfiguration.SecurityConfiguration.AutoAcceptUntrustedCertificates &&
e.Error != null && e.Error.Code == StatusCodes.BadCertificateUntrusted)
{
e.Accept = true;
Utils.Trace((int)Utils.TraceMasks.Security, "Automatically accepted certificate: {0}", e.Certificate.Subject);
}
}
catch (Exception exception)
{
Utils.Trace(exception, "Error accepting certificate.");
}
}
/// <summary>
/// Auto accept certificates
/// </summary>
/// <param name="validator"></param>
/// <param name="e"></param>
private void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
e.Accept = true;
Console.WriteLine($"Opc.Ua.Client.SampleModule: WARNING: Auto-accepting certificate: {e.Certificate.Subject}");
}
}
private void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
e.Accept = _autoAccept;
if (_autoAccept)
{
Console.WriteLine("Accepted Certificate: {0}", e.Certificate.Subject);
}
else
{
Console.WriteLine("Rejected Certificate: {0}", e.Certificate.Subject);
}
}
}
private static void Application_CertificateValidation(object sender, CertificateValidationEventArgs e)
{
e.ValidationOption = CertificateValidationOption.AcceptOnce;
}
/// <summary>
/// Checks that the domains in the certificate match the current host.
/// </summary>
private void RegistrationValidator_CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
{
Task t = Task.Run(async () =>
{
System.Net.IPAddress[] targetAddresses = await Utils.GetHostAddresses(Utils.GetHostName());
foreach (string domain in Utils.GetDomainsFromCertficate(e.Certificate))
{
System.Net.IPAddress[] actualAddresses = await Utils.GetHostAddresses(domain);
foreach (System.Net.IPAddress actualAddress in actualAddresses)
{
foreach (System.Net.IPAddress targetAddress in targetAddresses)
{
if (targetAddress.Equals(actualAddress))
{
e.Accept = true;
return;
}
}
}
}
});
t.Wait();
}
/// <summary>
/// The certificate validator is used
/// if auto accept is not selected in the configuration.
/// </summary>
private void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
if (AutoAccept)
{
m_output.WriteLine("Accepted Certificate: [{0}] [{1}]", e.Certificate.Subject, e.Certificate.Thumbprint);
e.Accept = true;
return;
}
}
m_output.WriteLine("Rejected Certificate: {0} [{1}] [{2}]", e.Error, e.Certificate.Subject, e.Certificate.Thumbprint);
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="caller">The caller's text is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static void HandleCertificateValidationError(Form caller, CertificateValidator validator, CertificateValidationEventArgs e)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat("Certificate could not validated: {0}\r\n\r\n", e.Error.StatusCode);
buffer.AppendFormat("Subject: {0}\r\n", e.Certificate.Subject);
buffer.AppendFormat("Issuer: {0}\r\n", (e.Certificate.Subject == e.Certificate.Issuer)?"Self-signed":e.Certificate.Issuer);
buffer.AppendFormat("Valid From: {0}\r\n", e.Certificate.NotBefore);
buffer.AppendFormat("Valid To: {0}\r\n", e.Certificate.NotAfter);
buffer.AppendFormat("Thumbprint: {0}\r\n\r\n", e.Certificate.Thumbprint);
buffer.AppendFormat("Accept anyways?");
if (MessageBox.Show(buffer.ToString(), caller.Text, MessageBoxButtons.YesNo) == DialogResult.Yes)
{
e.Accept = true;
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="form">The caller's form is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static void HandleCertificateValidationError(Form form, CertificateValidator validator, CertificateValidationEventArgs e)
{
HandleCertificateValidationError(form.Text, validator, e);
}
/// <summary>
/// Handles an error validating the server certificate.
/// </summary>
/// <remarks>
/// Applications should never accept certificates silently. Doing do will create the illusion of security
/// that will come back to haunt the vendor in the future. Compliance tests by the OPC Foundation will
/// fail products that silently accept untrusted certificates.
/// </remarks>
static void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
e.Accept = true;
Console.WriteLine("WARNING: Accepting Untrusted Certificate: {0}", e.Certificate.Subject);
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="caption">The caller's text is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static void HandleCertificateValidationError(string caption, CertificateValidator validator, CertificateValidationEventArgs e)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat("Certificate could not be validated!\r\n");
buffer.AppendFormat("Validation error(s): \r\n");
buffer.AppendFormat("\t{0}\r\n", e.Error.StatusCode);
if (e.Error.InnerResult != null)
{
buffer.AppendFormat("\t{0}\r\n", e.Error.InnerResult.StatusCode);
}
buffer.AppendFormat("\r\nSubject: {0}\r\n", e.Certificate.Subject);
buffer.AppendFormat("Issuer: {0}\r\n", (e.Certificate.Subject == e.Certificate.Issuer) ? "Self-signed" : e.Certificate.Issuer);
buffer.AppendFormat("Valid From: {0}\r\n", e.Certificate.NotBefore);
buffer.AppendFormat("Valid To: {0}\r\n", e.Certificate.NotAfter);
buffer.AppendFormat("Thumbprint: {0}\r\n\r\n", e.Certificate.Thumbprint);
buffer.AppendFormat("Certificate validation errors may indicate an attempt to intercept any data you send ");
buffer.AppendFormat("to a server or to allow an untrusted client to connect to your server.");
buffer.AppendFormat("\r\n\r\nAccept anyway?");
if (MessageBox.Show(buffer.ToString(), caption, MessageBoxButtons.YesNo) == DialogResult.Yes)
{
e.Accept = true;
}
}
/// <summary>
/// Check for untrusted certificates and only accept them if the user has accepted them
/// </summary>
private void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (e.Error.StatusCode == StatusCodes.BadCertificateUntrusted)
{
// Session is not accessible from here so we need to iterate through all key-value-pairs
foreach (KeyValuePair <string, OpcSessionCacheData> pair in OpcSessionCache.ToArray())
{
// try processing each entry
try
{
string hostName = pair.Value.EndpointURL.Substring("opc.tcp://".Length);
if (hostName.Contains(":"))
{
hostName = hostName.Substring(0, hostName.IndexOf(':'));
}
// Look up by cert thumbprint
if (string.Equals(pair.Value.CertThumbprint, e.Certificate.Thumbprint, StringComparison.InvariantCultureIgnoreCase))
{
// check if the current session user has confirmed trust
if (pair.Value.Trusted)
{
// In this case, we accept the cert
e.Accept = true;
break;
}
}
// Update our cache data
if (e.Certificate.Subject.Contains(hostName))
{
OpcSessionCacheData newValue = new OpcSessionCacheData
{
OPCSession = pair.Value.OPCSession,
EndpointURL = pair.Value.EndpointURL,
Trusted = pair.Value.Trusted,
CertThumbprint = e.Certificate.Thumbprint
};
OpcSessionCache.TryUpdate(pair.Key, newValue, pair.Value);
break;
}
}
catch (Exception)
{
// do nothing
}
}
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="caller">The caller's text is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static async Task HandleCertificateValidationError(Page caller, CertificateValidator validator, CertificateValidationEventArgs e)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat("Certificate could not validated: {0}\r\n\r\n", e.Error.StatusCode);
buffer.AppendFormat("Subject: {0}\r\n", e.Certificate.Subject);
buffer.AppendFormat("Issuer: {0}\r\n", (e.Certificate.Subject == e.Certificate.Issuer) ? "Self-signed" : e.Certificate.Issuer);
buffer.AppendFormat("Thumbprint: {0}\r\n\r\n", e.Certificate.Thumbprint);
buffer.AppendFormat("Accept anyways?");
MessageDlg dialog = new MessageDlg(buffer.ToString(), MessageDlgButton.Yes, MessageDlgButton.No);
MessageDlgButton result = await dialog.ShowAsync();
if (result == MessageDlgButton.Yes)
{
e.Accept = true;
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
private static void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
try
{
if (e.Error != null && e.Error.Code == StatusCodes.BadCertificateUntrusted)
{
e.Accept = true;
Utils.Trace((int)Utils.TraceMasks.Security, "Automatically accepted certificate: {0}", e.Certificate.Subject);
}
}
catch (Exception exception)
{
Utils.Trace(exception, "Error accepting certificate.");
}
}
/// <summary>
/// Handles a certificate validation error.
/// 处理证书验证失败的情况
/// </summary>
private void CertificateValidator_CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
{
try
{
e.Accept = m_configuration.SecurityConfiguration.AutoAcceptUntrustedCertificates;
if (!m_configuration.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
e.Accept = true;
//if (!m_configuration.SecurityConfiguration.AutoAcceptUntrustedCertificates)
//{
// DialogResult result = MessageBox.Show(
// e.Certificate.Subject,
// "Untrusted Certificate",
// MessageBoxButtons.YesNo,
// MessageBoxIcon.Warning);
// e.Accept = (result == DialogResult.Yes);
//}
}
}
catch (Exception exception)
{
ClientUtils.HandleException(application.ApplicationName, exception);
}
}
private void my_Server_CertificateEvent(CertificateValidator validator, CertificateValidationEventArgs e)
{
// Accept all certificate -> better ask user
e.Accept = true;
}
/// <summary>
/// Accepts server certificates.
/// </summary>
void CertificateValidator_CertificateValidation(CertificateValidator validator,
CertificateValidationEventArgs e)
{
// always safe to trust servers when connecting as a test application.
e.Accept = true;
}
private void CertificateValidator_CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
{
if (InvokeRequired)
{
Invoke(new CertificateValidationEventHandler(CertificateValidator_CertificateValidation), sender, e);
return;
}
try
{
var result = new UntrustedCertificateDialog().ShowDialog(this, e.Certificate);
if (result == DialogResult.OK)
{
e.Accept = true;
}
}
catch (Exception ex)
{
Opc.Ua.Client.Controls.ExceptionDlg.Show(Text, ex);
}
}
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
if (InvokeRequired)
{
Invoke(new CertificateValidationEventHandler(CertificateValidator_CertificateValidation), validator, e);
return;
}
try
{
GuiUtils.HandleCertificateValidationError(this, validator, e);
}
catch (Exception exception)
{
GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
}
}
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
ManualResetEvent ev = new ManualResetEvent(false);
Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
async() =>
{
await GuiUtils.HandleCertificateValidationError(this, validator, e);
ev.Set();
}
).AsTask().Wait();
ev.WaitOne();
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="caller">The caller's text is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static async Task HandleCertificateValidationError(Page caller, CertificateValidator validator, CertificateValidationEventArgs e)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat("Certificate could not validated: {0}\r\n\r\n", e.Error.StatusCode);
buffer.AppendFormat("Subject: {0}\r\n", e.Certificate.Subject);
buffer.AppendFormat("Issuer: {0}\r\n", (e.Certificate.Subject == e.Certificate.Issuer) ? "Self-signed" : e.Certificate.Issuer);
buffer.AppendFormat("Thumbprint: {0}\r\n\r\n", e.Certificate.Thumbprint);
buffer.AppendFormat("Accept anyways?");
MessageDlg dialog = new MessageDlg(buffer.ToString(), MessageDlgButton.Yes, MessageDlgButton.No);
MessageDlgButton result = await dialog.ShowAsync();
if (result == MessageDlgButton.Yes)
{
e.Accept = true;
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
private void CertificateValidator_CertificateValidation(CertificateValidator sender, CertificateValidationEventArgs e)
{
if (this.InvokeRequired)
{
this.Invoke(new CertificateValidationEventHandler(CertificateValidator_CertificateValidation), sender, e);
return;
}
try
{
e.Accept = m_configuration.SecurityConfiguration.AutoAcceptUntrustedCertificates;
if (!m_configuration.SecurityConfiguration.AutoAcceptUntrustedCertificates)
{
DialogResult result = MessageBox.Show(
e.Certificate.Subject,
"Untrusted Certificate",
MessageBoxButtons.YesNo,
MessageBoxIcon.Warning);
e.Accept = (result == DialogResult.Yes);
}
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
private Task OnCertificateValidation(object sender, CertificateValidationEventArgs e)
{
throw new NotImplementedException();
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="caller">The caller's text is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static void HandleCertificateValidationError(Form caller, CertificateValidator validator, CertificateValidationEventArgs e)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat("Certificate could not be validated: {0}\r\n\r\n", e.Error.StatusCode);
buffer.AppendFormat("Subject: {0}\r\n", e.Certificate.Subject);
buffer.AppendFormat("Issuer: {0}\r\n", (e.Certificate.Subject == e.Certificate.Issuer)?"Self-signed":e.Certificate.Issuer);
buffer.AppendFormat("Valid From: {0}\r\n", e.Certificate.NotBefore);
buffer.AppendFormat("Valid To: {0}\r\n", e.Certificate.NotAfter);
buffer.AppendFormat("Thumbprint: {0}\r\n\r\n", e.Certificate.Thumbprint);
buffer.AppendFormat("The security certificate was not issued by a trusted certificate authority. ");
buffer.AppendFormat("Security certificate problems may indicate an attempt to intercept any data you send ");
buffer.AppendFormat("to a server or to allow an untrusted client to connect to your server.");
buffer.AppendFormat("\r\n\r\nAccept anyway?");
if (MessageBox.Show(buffer.ToString(), caller.Text, MessageBoxButtons.YesNo) == DialogResult.Yes)
{
e.Accept = true;
}
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
/// <param name="caller">The caller's text is used as the caption of the <see cref="MessageBox"/> shown to provide details about the error.</param>
/// <param name="validator">The validator (not used).</param>
/// <param name="e">The <see cref="Opc.Ua.CertificateValidationEventArgs"/> instance event arguments provided when a certificate validation error occurs.</param>
public static void HandleCertificateValidationError(Form caller, CertificateValidator validator, CertificateValidationEventArgs e)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat("Certificate could not validated: {0}\r\n\r\n", e.Error.StatusCode);
buffer.AppendFormat("Subject: {0}\r\n", e.Certificate.Subject);
buffer.AppendFormat("Issuer: {0}\r\n", (e.Certificate.Subject == e.Certificate.Issuer)?"Self-signed":e.Certificate.Issuer);
buffer.AppendFormat("Valid From: {0}\r\n", e.Certificate.NotBefore);
buffer.AppendFormat("Valid To: {0}\r\n", e.Certificate.NotAfter);
buffer.AppendFormat("Thumbprint: {0}\r\n\r\n", e.Certificate.Thumbprint);
buffer.AppendFormat("Accept anyways?");
if (MessageBox.Show(buffer.ToString(), caller.Text, MessageBoxButtons.YesNo) == DialogResult.Yes)
{
e.Accept = true;
}
}
/// <summary>
/// Always accept server certificates.
/// </summary>
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
e.Accept = true;
}
private static Task ProxyServer_ServerCertificateValidationCallback(object arg1, CertificateValidationEventArgs e)
{
//set IsValid to true/false based on Certificate Errors
if (e.SslPolicyErrors == System.Net.Security.SslPolicyErrors.None)
{
e.IsValid = true;
}
return(Task.FromResult(0));
}
/// <summary>
/// Accepts server certificates.
/// </summary>
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
// always safe to trust servers when connecting as a test application.
e.Accept = true;
}
/// <summary>
/// Handles a certificate validation error.
/// </summary>
void CertificateValidator_CertificateValidation(CertificateValidator validator, CertificateValidationEventArgs e)
{
try
{
Opc.Ua.Client.Controls.GuiUtils.HandleCertificateValidationError(this, validator, e);
}
catch (Exception exception)
{
Opc.Ua.Client.Controls.GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception);
}
}
