/// <summary>
/// Show a dialog and have the user select a certificate to sign.
/// </summary>
/// <returns></returns>
public static X509Certificate2 GetByDialog(StoreName storeName = StoreName.My, StoreLocation storeLocation = StoreLocation.CurrentUser, bool validOnly = false, bool requirePrivateKey = false)
{
X509Store store = null;
X509Certificate2 result;
try
{
store = new X509Store(storeName, storeLocation);
store.Open(OpenFlags.ReadOnly);
var selections = store.Certificates;
if (requirePrivateKey)
{
var filtered = selections
.Cast <X509Certificate2>()
.Where(cert => cert.HasPrivateKey)
.ToArray();
selections = new X509Certificate2Collection(filtered);
}
var selection = X509Certificate2UI.SelectFromCollection(selections, "Certificates", "Select one to sign", X509SelectionFlag.SingleSelection);
result = selection.Count == 0
? null
: selection
.Cast <X509Certificate2>()
.FirstOrDefault();
}
finally
{
if (store != null)
{
store.Close();
}
}
return(result);
}
private void btnViewRootCertificate_Click(object sender, EventArgs e)
{
try
{
//check if certificate needs to be signed by root authority
if (cmbRootLocation.SelectedIndex != -1 && cmbRootStore.SelectedIndex != -1)
{
X509Store rootStore = new X509Store((StoreName)cmbRootStore.SelectedItem, (StoreLocation)cmbRootLocation.SelectedItem);
rootStore.Open(OpenFlags.ReadOnly);
_selectedCertificates = X509Certificate2UI.SelectFromCollection(rootStore.Certificates, "Pick a Root Authority Certificate", "Click on the root authority certificate for which you have a private key. Newly created certificate will be signed using this certificate", X509SelectionFlag.SingleSelection);
}
else
{
errorProvider.SetError(btnViewRootCertificate, "Please select both store and location to view certificates");
}
if (_selectedCertificates != null && _selectedCertificates.Count == 1)
{
X509Certificate2 certificate = _selectedCertificates[0];
string label = string.Format("Subject:{0} and Issuer Name:{1}", certificate.Subject, certificate.Issuer);
lblRootCertificate.Text = label.Substring(0, 47) + "...";
toolTip.SetToolTip(lblRootCertificate, label);
}
else
{
lblRootCertificate.Text = "No Root Authority Certificate selected";
}
}
catch (Exception ex)
{
errorProvider.SetError(cmbRootLocation, ex.Message);
}
}
internal static X509Certificate2 GetX509Certificate2FromDongle()
{
List <X509Certificate2> certList = new List <X509Certificate2>();
using (X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser))
{
store.Open(OpenFlags.ReadOnly);
foreach (X509Certificate2 cert in (X509Certificate2Collection)store.Certificates)
{
//Filter for not showing unnecessery certificates
if (
cert.HasPrivateKey &&
!cert.Issuer.Contains("localhost") &&
(cert.NotAfter >= DateTime.UtcNow && cert.NotBefore <= DateTime.UtcNow)
)
{
certList.Add(cert);
}
}
store.Close(); //No Need
}
X509Certificate2Collection selectedCert = X509Certificate2UI.SelectFromCollection(
new X509Certificate2Collection(certList.ToArray()),
"Digital Document Signer",
"Please Select a Certificate for Signing Document",
X509SelectionFlag.SingleSelection
);
X509Certificate2 x509Certificate2 = selectedCert[0];
Log.Print(LogLevel._Low, "Selected Certificate Subject - " + x509Certificate2.Subject);
Log.Print(LogLevel._Low, "Selected Certificate Issuer - " + x509Certificate2.Issuer);
bool?status = CheckOCSP(x509Certificate2);
return(x509Certificate2);
}
private void TrvMain_AfterSelect(object sender, TreeViewEventArgs e)
{
if (File.Exists(e.Node.Name))
{
//X.509 certificates
if (e.Node.Name.EndsWith(@".crt"))
{
var certBytes = File.ReadAllBytes(e.Node.Name);
var cert = new X509Certificate2(certBytes);
X509Certificate2UI.DisplayCertificate(cert);
}
//Arcadyan config
else if (e.Node.Name.EndsWith(@".dft") || e.Node.Name.EndsWith(@".glbcfg"))
{
SetTable(FileToDataTable(e.Node.Name));
}
//SQLite Databases
else if (e.Node.Name.EndsWith(@".db") || e.Node.Name.EndsWith(@".sqlite"))
{
SqliteBrowser.ShowBrowser(e.Node.Name);
}
//Anything else is treated as a text file
else
{
//try text load
SetText(File.ReadAllText(e.Node.Name));
}
}
else
{
SetClear();
}
}
public void DisplayCertificate_Certificate_Empty()
{
// this is unusable
X509Certificate2 empty = new X509Certificate2();
X509Certificate2UI.DisplayCertificate(empty);
}
private void OpenExternalLink(object sender, ExecutedRoutedEventArgs e)
{
if (e.Command != NavigationCommands.GoToPage)
{
return;
}
// We might get a certificate to display instead
if (e.Parameter is X509Certificate2 cert)
{
var hwnd = new WindowInteropHelper(this).Handle;
X509Certificate2UI.DisplayCertificate(cert, hwnd);
return;
}
var uri = e.Parameter as Uri;
if (uri == null)
{
var url = (string)e.Parameter;
Uri.TryCreate(url, UriKind.Absolute, out uri);
}
if (uri != null)
{
UriHelper.OpenExternalLink(uri);
}
}
/// <summary>
/// Metodo encargado de obtener el certificado seleccionado desde el almacen de windows
/// </summary>
/// <returns></returns>
public static X509Certificate2 SelectCertManual()
{
try
{
//Firmar con selección de certificado en el almacén de certificados de windows
X509Store store = new X509Store(StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);
X509Certificate2 cert = null;
//eligió manualmente el certificado en el almacén
//Para "X509Certificate2UI" se debe agregar la referencia a "X509Certificate2UI", llamar a "using System.Security;"
//**X509Certificate2Collection sel = X509Certificate2UI.SelectFromCollection(store.Certificates, null, null, X509SelectionFlag.SingleSelection);
X509Certificate2Collection sel = X509Certificate2UI.SelectFromCollection(store.Certificates.Find(X509FindType.FindByKeyUsage, "DigitalSignature", false), null, null, X509SelectionFlag.SingleSelection);
//X509Certificate2Collection sel = X509Certificate2UI.SelectFromCollection(store.Certificates, null, null, X509SelectionFlag.MultiSelection);
if (sel.Count > 0)
{
cert = sel[0];
}
else
{
//MessageBox.Show("Certificado no Funciona");
return(null);
}
return(cert);
}
catch (Exception ex)
{
throw new Exception("ERROR: " + ex);
}
}
/// <summary>
/// Displays a dialog box for selecting an X.509 certificate from a certificate collection.
/// </summary>
/// <param name="title">The title of the dialog box.</param>
/// <param name="message">A descriptive message to guide the user. The message is displayed in the dialog box.</param>
/// <returns>An X509Certificate2 object that contains the selected certificate.</returns>
public static X509Certificate2 PickCertificate(string title, string message)
{
var x509Store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
try
{
x509Store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
var certificates = X509Certificate2UI.SelectFromCollection(x509Store.Certificates, title, message,
X509SelectionFlag.SingleSelection);
if (certificates.Count == 0)
{
throw new NullReferenceException(
"Oops!! Certificado não informado... Não será possível emitir notas fiscais sem um certificado válido.");
}
var certificate = certificates[0];
return(certificate);
}
finally
{
x509Store.Close();
}
}
static X509Certificate2 SelectCertificate(StoreName storeName, StoreLocation storeLocation)
{
X509Certificate2 result;
X509Store store = new X509Store(storeName, storeLocation);
store.Open(OpenFlags.ReadOnly);
try
{
X509Certificate2Collection matches;
matches = X509Certificate2UI.SelectFromCollection(store.Certificates, "Select certificate", "Select the certificate to find the location of the associated private key file:", X509SelectionFlag.SingleSelection);
if (matches.Count != 1)
{
result = null;
}
else
{
result = matches[0];
}
}
finally
{
store.Close();
}
return(result);
}
private void ButtonEncryptWithStore_Click(object sender, EventArgs e)
{
X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);
X509Certificate2Collection certs = X509Certificate2UI.SelectFromCollection(store.Certificates, "Certificates", "Choose one certificate...", X509SelectionFlag.SingleSelection);
store.Close();
if (certs.Count == 1)
{
//ShowCertificate(certs[0]);
byte[] data = Encoding.UTF8.GetBytes(textBoxInfo.Text);
ContentInfo contentInfo = new ContentInfo(data);
CmsRecipient cmsRecipient = new CmsRecipient(certs[0]);
EnvelopedCms envelopedCms = new EnvelopedCms(contentInfo);
envelopedCms.Encrypt(cmsRecipient);
this.tempEnvelope = envelopedCms.Encode();
MessageBox.Show("Data encrypted" + Environment.NewLine + Convert.ToBase64String(this.tempEnvelope));
}
else
{
MessageBox.Show("No certificate selected");
}
}
public void ChooseClientCertificate()
{
var store = new X509Store(mStoreName, mStoreLocation);
store.Open(OpenFlags.ReadOnly);
var c = store.Certificates.Find(mFindType, mFindTerm, mValidOnly);
var selectedCertificate = X509Certificate2UI.SelectFromCollection(
c,
"Client Certificate",
"Choose a client certificate for this session",
X509SelectionFlag.SingleSelection);
if (selectedCertificate != null)
{
if (selectedCertificate.Count > 0)
{
mCert = selectedCertificate[0];
if (CertificateChosen != null)
{
CertificateChosen(mCert);
}
}
else
{
if (CertificateNotChosen != null)
{
CertificateNotChosen();
}
}
}
}
public void Sign(string inputPath, string outPath, string imagePath, bool visible = true)
{
X509Store store = new X509Store(StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);
X509Certificate2Collection sel = X509Certificate2UI.SelectFromCollection(store.Certificates, null, null, X509SelectionFlag.SingleSelection);
X509Certificate2 cert = sel[0];
Org.BouncyCastle.X509.X509CertificateParser cp = new Org.BouncyCastle.X509.X509CertificateParser();
Org.BouncyCastle.X509.X509Certificate[] chain = new Org.BouncyCastle.X509.X509Certificate[] {
cp.ReadCertificate(cert.RawData)
};
IExternalSignature externalSignature = new X509Certificate2Signature(cert, "SHA-1");
PdfReader pdfReader = new PdfReader(inputPath);
var signedPdf = new FileStream(outPath, FileMode.Create);
var pdfStamper = PdfStamper.CreateSignature(pdfReader, signedPdf, '\0');
PdfSignatureAppearance signatureAppearance = pdfStamper.SignatureAppearance;
if (imagePath != null && imagePath != string.Empty)
{
signatureAppearance.SignatureGraphic = Image.GetInstance(imagePath);
}
signatureAppearance.SetVisibleSignature(new Rectangle(100, 100, 250, 150), pdfReader.NumberOfPages, "Signature");
signatureAppearance.SignatureRenderingMode = PdfSignatureAppearance.RenderingMode.GRAPHIC_AND_DESCRIPTION;
MakeSignature.SignDetached(signatureAppearance, externalSignature, chain, null, null, null, 0, CryptoStandard.CMS);
Process.Start(outPath);
}
static void Main()
{
X509Store store = new X509Store("MY", StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2Collection collection = (X509Certificate2Collection)store.Certificates;
X509Certificate2Collection fcollection = (X509Certificate2Collection)collection.Find(X509FindType.FindByTimeValid, DateTime.Now, false);
X509Certificate2Collection scollection = X509Certificate2UI.SelectFromCollection(fcollection, "Test Certificate Select", "Select a certificate from the following list to get information on that certificate", X509SelectionFlag.MultiSelection);
Console.WriteLine("Number of certificates: {0}{1}", scollection.Count, Environment.NewLine);
foreach (X509Certificate2 x509 in scollection)
{
try
{
byte[] rawdata = x509.RawData;
Console.WriteLine("Content Type: {0}{1}", X509Certificate2.GetCertContentType(rawdata), Environment.NewLine);
Console.WriteLine("Friendly Name: {0}{1}", x509.FriendlyName, Environment.NewLine);
Console.WriteLine("Certificate Verified?: {0}{1}", x509.Verify(), Environment.NewLine);
Console.WriteLine("Simple Name: {0}{1}", x509.GetNameInfo(X509NameType.SimpleName, true), Environment.NewLine);
Console.WriteLine("Signature Algorithm: {0}{1}", x509.SignatureAlgorithm.FriendlyName, Environment.NewLine);
Console.WriteLine("Public Key: {0}{1}", x509.PublicKey.Key.ToXmlString(false), Environment.NewLine);
Console.WriteLine("Certificate Archived?: {0}{1}", x509.Archived, Environment.NewLine);
Console.WriteLine("Length of Raw Data: {0}{1}", x509.RawData.Length, Environment.NewLine);
X509Certificate2UI.DisplayCertificate(x509);
x509.Reset();
}
catch (CryptographicException)
{
Console.WriteLine("Information could not be written out for this certificate.");
}
}
store.Close();
}
public static X509Certificate2 ChooseCertificate()
{
X509Certificate2 certificate = null;
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
var collection = store.Certificates;
var fcollection = collection.Find(X509FindType.FindByTimeValid, DateTime.Now, true);
var scollection = X509Certificate2UI.SelectFromCollection(fcollection, "Certificados válidos:",
"Selecione o certificado que deseja usar",
X509SelectionFlag.SingleSelection);
if (scollection.Count == 0)
{
throw new Exception("Nenhum certificado foi selecionado!");
}
certificate = scollection[0];
if (certificate == null)
{
throw new Exception("Nenhum certificado foi selecionado!");
}
store.Close();
return(certificate);
}
private static StoredCertificate PickCertificate()
{
var availableCertificates =
from location in new[] { StoreLocation.CurrentUser, StoreLocation.LocalMachine }
from name in new[] { StoreName.My }
select Tuple.Create(Tuple.Create(location, name), GetCertificates(location, name));
var appropriateCertificates =
availableCertificates
.SelectMany(v => v.Item2)
.OfType <X509Certificate2>()
.Where(v => v.HasPrivateKey)
.GroupBy(v => v.Thumbprint)
.Select(v => v.First());
X509Certificate2 selectedCertificate = X509Certificate2UI.SelectFromCollection(
new X509Certificate2Collection(appropriateCertificates.ToArray()), "Select certificate", string.Empty, X509SelectionFlag.SingleSelection, GetWindowHandle())
.OfType <X509Certificate2>()
.FirstOrDefault();
if (selectedCertificate == null)
{
return(null);
}
var store = availableCertificates.First(v => v.Item2.Contains(selectedCertificate)).Item1;
return(new StoredCertificate(store.Item1, store.Item2, selectedCertificate));
}
/// <summary>
/// Gets a X509 certificate from windows store. Asks the user for the correct certificate.
/// </summary>
/// <returns></returns>
public static X509Certificate2 GetCertificate()
{
var st = new X509Store(StoreName.My, StoreLocation.CurrentUser);
st.Open(OpenFlags.ReadOnly);
X509Certificate2 card = null;
try
{
X509Certificate2Collection col = st.Certificates;
X509Certificate2Collection sel = X509Certificate2UI.SelectFromCollection(
col,
"Certificates",
"Select one to sign",
X509SelectionFlag.SingleSelection);
if (sel.Count > 0)
{
X509Certificate2Enumerator en = sel.GetEnumerator();
en.MoveNext();
card = en.Current;
}
}
finally
{
st.Close();
}
return(card);
}
} // Main
private static X509Certificate2 SeleccionarCertificado(string vMessage, StoreLocation vLocation, StoreName vName)
{
X509Store certStore;
X509Certificate2 oCertificado = null;
try
{
certStore = new X509Store(vName, vLocation);
certStore.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2Collection certsSelect = certStore.Certificates.Find(X509FindType.FindByTimeValid, DateTime.Now, true);
X509Certificate2Collection certs =
X509Certificate2UI.SelectFromCollection(
certsSelect,
"Selección certificado",
vMessage,
X509SelectionFlag.SingleSelection, IntPtr.Zero);
if (certs.Count > 0)
{ //Almacenamos el certificado en nuestro objeto interno
oCertificado = certs[0];
}
certStore.Close();
return(oCertificado);
}
catch (Exception e)
{
throw (e);
}
finally
{
certStore = null;
}
} //Obtiene un certificado de usuario
public CertificadoDigital()
{
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
var collection = store.Certificates;
var fcollection = collection.Find(X509FindType.FindByTimeValid, DateTime.Now, true);
var scollection = X509Certificate2UI.SelectFromCollection(fcollection, "Certificados válidos:", "Selecione o certificado que deseja usar",
X509SelectionFlag.SingleSelection);
if (scollection.Count == 0)
{
throw new Exception("Nenhum certificado foi selecionado!");
}
foreach (var x509 in scollection)
{
try
{
Serial = x509.SerialNumber;
Validade = Convert.ToDateTime(x509.GetExpirationDateString());
x509.Reset();
}
catch (CryptographicException)
{
Console.WriteLine("Não foi possível obter as informações do certificado selecionado!");
}
}
store.Close();
}
/// <summary>
/// Método responsável por abrir um browse para selecionar o
/// certificado digital que será utilizado para autenticação
/// dos WebServices e gravar ele no atributo oCertificado
/// </summary>
/// <returns>
/// Retorna se o certificado foi selecionado corretamente ou não.
/// true = foi selecionado corretamente.
/// false = não foi selecionado, algum problema ocorreu ou foi cancelado o selecionamento pelo usuário.
/// </returns>
/// <by>Wandrey Mundin Ferreira</by>
/// <date>04/06/2008</date>
public bool SelecionarCertificado()
{
bool vRetorna;
X509Certificate2 oX509Cert = new X509Certificate2();
X509Store store = new X509Store("MY", StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2Collection collection = (X509Certificate2Collection)store.Certificates;
X509Certificate2Collection collection1 = (X509Certificate2Collection)collection.Find(X509FindType.FindByTimeValid, DateTime.Now, false);
X509Certificate2Collection collection2 = (X509Certificate2Collection)collection.Find(X509FindType.FindByKeyUsage, X509KeyUsageFlags.DigitalSignature, false);
X509Certificate2Collection scollection = X509Certificate2UI.SelectFromCollection(collection2, "Certificado(s) Digital(is) disponível(is)", "Selecione o certificado digital para uso no aplicativo", X509SelectionFlag.SingleSelection);
if (scollection.Count == 0)
{
string msgResultado = "Nenhum certificado digital foi selecionado ou o certificado selecionado está com problemas.";
MessageBox.Show(msgResultado, "Advertência", MessageBoxButtons.OK, MessageBoxIcon.Warning);
vRetorna = false;
}
else
{
oX509Cert = scollection[0];
oCertificado = oX509Cert;
vRetorna = true;
}
return(vRetorna);
}
private void OpenCertificateFile_Click(object sender, RoutedEventArgs e)
{
// get file path for log
var certPath = this.MainViewModel.SelectedItem.CertificatePath;
//check file exists, if not inform user
if (!String.IsNullOrEmpty(certPath) && System.IO.File.Exists(certPath))
{
//open file
var cert = CertificateManager.LoadCertificate(certPath);
if (cert != null)
{
//var test = cert.PrivateKey.KeyExchangeAlgorithm;
// System.Diagnostics.Debug.WriteLine(test.ToString());
X509Certificate2UI.DisplayCertificate(cert);
}
//MessageBox.Show(Newtonsoft.Json.JsonConvert.SerializeObject(cert.PrivateKey, Newtonsoft.Json.Formatting.Indented));
}
else
{
MessageBox.Show(SR.ManagedItemSettings_CertificateNotReady);
}
}
public static void ShowX509Certificate(string certString)
{
var bytes = Convert.FromBase64String(certString);
var cert = new X509Certificate2(bytes);
X509Certificate2UI.DisplayCertificate(cert);
}
/// <summary>
/// Select certificate from selected store name and store location
/// </summary>
/// <returns></returns>
public string SelectSertificateName()
{
var store = new X509Store(m_StoreName, m_StoreLocation);
store.Open(OpenFlags.ReadOnly);
try
{
var certs = X509Certificate2UI.SelectFromCollection(
store.Certificates,
"Real Certificate Select",
"Select real monitoring certificate",
X509SelectionFlag.SingleSelection);
if (certs.Count == 1)
{
return(certs[0].Subject.Substring(3));
}
else
{
return("");
}
}
finally
{
store.Close();
}
}
private void bt_UserClientCertSelect_Click(object sender, RoutedEventArgs e)
{
var SeachScope = ((Button)sender).Content.ToString();
String StoreLocationAsString = SeachScope.Substring(0, SeachScope.IndexOf("."));
String StoreNameAsString = SeachScope.Substring(SeachScope.IndexOf(".") + 1);
StoreName StoreNameParsed;
StoreLocation StoreLocationParsed;
if (Enum.TryParse(StoreNameAsString, out StoreNameParsed) && Enum.TryParse(StoreLocationAsString, out StoreLocationParsed))
{
X509Store store = new X509Store(StoreNameParsed, StoreLocationParsed);
store.Open(OpenFlags.ReadOnly);
X509Certificate2Collection sel = X509Certificate2UI.SelectFromCollection(store.Certificates, null, null, X509SelectionFlag.SingleSelection);
store.Close();
if (sel.Count > 0)
{
this.AppConfiguration.CertStoreName = StoreNameAsString;
this.AppConfiguration.CertStoreLocation = StoreLocationAsString;
this.AppConfiguration.CertSerial = sel[0].SerialNumber;
txt_ClientCertSubject.Text = sel[0].Subject;
}
}
}
private void oAddFromStoreButton_Click(object sender, RoutedEventArgs e)
{
// open the locate personal certificate store
using (X509Store oStore = new X509Store(StoreName.My, StoreLocation.CurrentUser))
{
oStore.Open(OpenFlags.ReadOnly);
// downselect to only display rsa certs
X509Certificate2Collection oCollection = new X509Certificate2Collection();
foreach (X509Certificate2 oCert in oStore.Certificates)
{
if (oCert.GetRSAPublicKey() != null && CertificateOperations.CheckCertificateStatus(oCert))
{
oCollection.Add(oCert);
}
}
// ask the user which certificate to publish
oCollection = X509Certificate2UI.SelectFromCollection(oCollection,
"Select Certificate", "Select Certificate To Add",
X509SelectionFlag.SingleSelection, new WindowInteropHelper(this).Handle);
// commit the certificate to the database
foreach (X509Certificate2 oCert in oCollection)
{
AddCertificate(oCert, WindowsIdentity.GetCurrent().User.Value);
}
}
}
private void btnViewCert_Click(object sender, EventArgs e) //Angepasst, sodass beide Zertifikate angezeigt werden können
{
X509Certificate2 cert = null; //Standard Cert
X509Certificate2 cert2 = null; //Admin Cert
string devName = YubikeyPivManager.Instance.ListDevices().FirstOrDefault();
if (!string.IsNullOrEmpty(devName))
{
using (YubikeyPivDevice dev = YubikeyPivManager.Instance.OpenDevice(devName))
{
cert = dev.GetCertificate9a();
cert2 = dev.GetCertificate9d();
}
}
if (cert == null)
{
MetroMessageBox.Show(this, "No Standard User certificate on device.", "No Certificate", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
X509Certificate2UI.DisplayCertificate(cert);
}
if (cert2 == null)
{
MetroMessageBox.Show(this, "No Admin User certificate on device.", "No Certificate", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
X509Certificate2UI.DisplayCertificate(cert2);
}
}
private static X509Certificate2 selectcert() //select cert from store & set selectedcert
{
try
{
if (File.Exists("c:\\hasher.cer"))
{
X509Certificate2 cert = new X509Certificate2("c:\\hasher.cer");
appLog.WriteEntry("Selected Cert: " + cert.Subject, System.Diagnostics.EventLogEntryType.Information);
return(cert);
}
else
{
System.Security.Cryptography.X509Certificates.X509Store mystore = new System.Security.Cryptography.X509Certificates.X509Store(StoreLocation.CurrentUser);
mystore.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2Collection certCollection = (X509Certificate2Collection)mystore.Certificates;
X509Certificate2Collection foundCollection = (X509Certificate2Collection)certCollection.Find(X509FindType.FindByTimeValid, DateTime.Now, false);
X509Certificate2Collection selectedcollection = X509Certificate2UI.SelectFromCollection(foundCollection, "Select a Certificate.", "Select a Certificate from the following list to get information on that certificate", X509SelectionFlag.SingleSelection);
if (selectedcollection.Count > 0)
{
X509Certificate2 certz = selectedcollection[0];
appLog.WriteEntry("Selected Cert: " + certz.Subject, System.Diagnostics.EventLogEntryType.Information);
return(certz);
}
appLog.WriteEntry("No Cert Selected", System.Diagnostics.EventLogEntryType.Warning);
return(null);
}
}
catch (Exception e)
{
appLog.WriteEntry(e.Message + e.StackTrace, System.Diagnostics.EventLogEntryType.Warning);
return(null);
}
}
private void OpenCertificateFile_Click(object sender, RoutedEventArgs e)
{
var certPath = ItemViewModel.SelectedItem.CertificatePath;
//check file exists, if not inform user
if (!string.IsNullOrEmpty(certPath) && System.IO.File.Exists(certPath))
{
//open file, can fail if file is in use TODO: will fail if cert has a pwd
try
{
var cert = CertificateManager.LoadCertificate(certPath);
if (cert != null)
{
//var test = cert.PrivateKey.KeyExchangeAlgorithm;
// System.Diagnostics.Debug.WriteLine(test.ToString());
X509Certificate2UI.DisplayCertificate(cert);
}
}
catch { }
}
else
{
MessageBox.Show(SR.ManagedCertificateSettings_CertificateNotReady);
}
}
/// <summary>
/// Requests the user to pick a certificate from the provided <see cref="X509Store"/>.
/// </summary>
/// <param name="info">The Credential request info from the <see cref="AuthenticationManager"/>.</param>
/// <param name="x509Store">The certificate store.</param>
/// <returns>A certificate picked by the user.</returns>
public static CertificateCredential?SelectCertificate(CredentialRequestInfo info, X509Store x509Store)
{
if (info is null)
{
throw new ArgumentNullException(nameof(info));
}
if (x509Store is null)
{
throw new ArgumentNullException(nameof(x509Store));
}
x509Store.Open(OpenFlags.ReadOnly);
X509Certificate2Collection col = x509Store.Certificates;
X509Certificate2Collection sel = X509Certificate2UI.SelectFromCollection(col, "Login required", "Certificate required for " + info.ServiceUri, X509SelectionFlag.SingleSelection);
X509Certificate2Enumerator en = sel.GetEnumerator();
if (en.MoveNext())
{
return(new CertificateCredential(en.Current));
}
return(null);
}
private void CertifikataBtn_Click(object sender, EventArgs e)
{
X509Store certificateStore = new X509Store(StoreName.My, StoreLocation.CurrentUser);
certificateStore.Open(OpenFlags.OpenExistingOnly);
try
{
X509Certificate2Collection certCollection = X509Certificate2UI.SelectFromCollection(
certificateStore.Certificates, "Certifikata", "Zgjedh certifikaten", X509SelectionFlag.SingleSelection);
certifikata = certCollection[0];
if (certifikata.HasPrivateKey)
{
MessageBox.Show("Certifikata e zgjedhur : " +
certifikata.Subject);
}
else
{
MessageBox.Show("Certifikata e zgjedhur nuk permbane celes privat!");
}
}
catch (Exception ex)
{
}
if (certifikata != null)
{
byte[] byteCert = certifikata.Export(X509ContentType.Cert, "Altin1");
accept.Send(byteCert, 0, byteCert.Length, 0);
}
}
private X509Certificate2 SeleccionarCertificado()
{
X509Certificate2 cert = null;
try
{
X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2Collection collection = (X509Certificate2Collection)store.Certificates;
X509Certificate2Collection fcollection = (X509Certificate2Collection)collection.Find(X509FindType.FindByTimeValid, DateTime.Now, false);
X509Certificate2Collection scollection = X509Certificate2UI.SelectFromCollection(fcollection, "Seleccionar certificado", "Certificado para firmar la solicitud", X509SelectionFlag.SingleSelection);
if (scollection != null && scollection.Count == 1)
{
cert = scollection[0];
if (cert.HasPrivateKey == false)
{
throw new Exception("El certificado no tiene asociada una clave privada.");
}
}
store.Close();
}
catch (Exception ex)
{
throw new Exception("No se ha podido obtener la clave privada.", ex);
}
return(cert);
}
