/// <summary>
/// Erstellt ein ein asymmetrisches Schlüsselpaar, ein Passwort für den privaten Teil des Zertifikates und generiert
/// aus diesen erstellten Bestandteilen ein Zertifikat entsprechend der übergebenen Schlüsselstärke. Nach Bedarf können die
/// Bestandteile (Zertifikat, KeyStore, Passwort) auf dem Dateisystem gespeichert werden
/// </summary>
/// <param name="hashtype">Algorithmus des Hashtyps</param>
/// <param name="antragsteller">Antragssteller (Subject DN)</param>
/// <param name="aussteller">Austeller (Issuer DN)</param>
/// <param name="passwortKeyStore">Passwort für den KeyStore, ist es leer wird eins geniert, ist es nicht leer wird das übertragene verwendet</param>
/// <param name="keyStore">Rückgabe des generierten KeyStores als Objekt</param>
/// <param name="gueltigVon">Ab wann ist das Zertifikat gültig</param>
/// <param name="gueltiBis">Bis wann ist das Zertifikat gültig</param>
/// <param name="keyStrength">Schlüsselstärke</param>
/// <param name="zertifikatSpeicherPfad">Soll das Zertifikat auf einem Laufwerk gespeichert werden, wird hier der Ordner angegeben</param>
/// <param name="dateiname">Namen der Dateien für das Passwort, das öffentliche Zertifikat und den KeyStore</param>
/// <param name="zertifikatImPfadSpeichern">Soll das Zertifikat in dem angegebenen Pfad gespeichert werden (.der)</param>
/// <param name="keyStoreImPfadSpeicher">Soll der KeyStore in dem angebeneen Pfad gespeichert werden (.pfx)</param>
/// <param name="passwortImPfadSpeichern">Soll das Passwort in dem angegebenen Pfad gespeichert werden (.pas)</param>
/// <returns></returns>
public static X509Certificate CreateCertificateAndKeyStore(Standards.HashType hashtype,
string antragsteller,
string aussteller,
ref string passwortKeyStore,
out Pkcs12Store keyStore,
DateTime gueltigVon,
DateTime gueltiBis,
KeyHelper.KeyStrength keyStrength = KeyHelper.KeyStrength.ks2048,
string zertifikatSpeicherPfad = null,
string dateiname = null,
bool zertifikatImPfadSpeichern = false,
bool keyStoreImPfadSpeicher = false,
bool passwortImPfadSpeichern = false)
{
//Erstellen eines Schlüsselpaares:
AsymmetricCipherKeyPair schluesselPaar = KeyHelper.CreateAsymmetricKeyPair(keyStrength);
//Erstellen eines Passwortes für den privaten Teil des Zertifikates:
if (string.IsNullOrEmpty(passwortKeyStore))
{
passwortKeyStore = KeyHelper.CreateRSAPasswort();
}
//Erstellen des Zertifikates:
X509Certificate certificate = CreateX509Certificate(schluesselPaar.Public, schluesselPaar.Private, hashtype, antragsteller, aussteller, gueltigVon, gueltiBis);
//Erstelle KeyStore:
keyStore = CreatePkcs12Store(certificate, schluesselPaar, antragsteller);
//Falls ein Pfad angegeben ist und das Speichern der Zertifikatsinformationen gewünscht ist, werden diese
//im Pfad als PKcs12 und DER Format gespeichert, das Passwort falls gewünscht in einer Textfile
if (!string.IsNullOrEmpty(zertifikatSpeicherPfad))
{
if (string.IsNullOrEmpty(dateiname))
{
dateiname = aussteller + "_" + antragsteller + "_" + DateTime.Now.ToString("yyyyMMddHHmmss");
}
string speicherPfad = zertifikatSpeicherPfad + "\\" + dateiname;
//Speichern des Zertifikates
if (zertifikatImPfadSpeichern)
{
SaveCertAsDER(certificate, speicherPfad);
}
//Speichern des KeyStores
if (keyStoreImPfadSpeicher)
{
SaveCertAsPkcs12(keyStore, speicherPfad, passwortKeyStore);
}
//Speichern des Passwortes:
if (passwortImPfadSpeichern)
{
ParseHelper.WriteTextToFile(speicherPfad + ".pas", passwortKeyStore);
}
}
return(certificate);
}
/// <summary>
/// Generiert zu den übergebenen Parametern ein X509 Zertifikat.
/// </summary>
/// <param name="keyPair">Asymmetrisches Schlüsselpaar</param>
/// <param name="hashtype">Verschlüsselungsalgorithmus</param>
/// <param name="antragssteller">Antragssteller</param>
/// <param name="aussteller">Aussteller</param>
/// <param name="gueltigVon">Ab wann ist das Zertifikat gültig</param>
/// <param name="gueltigBis">Bis wann ist das Zertifikat gültig</param>
/// <param name="caZertifikat">Stammzertifikat</param>
/// <param name="caPrivateKey">Privater Schlüssel Stammzertifikat</param>
/// <returns></returns>
private static X509Certificate CreateX509Certificate(AsymmetricKeyParameter oeffentlicherSchluessel,
AsymmetricKeyParameter privaterSchluessel,
Standards.HashType hashtype,
string antragssteller,
string aussteller,
DateTime?gueltigVon = null,
DateTime?gueltigBis = null,
X509Certificate caZertifikat = null,
AsymmetricKeyParameter caPrivateKey = null
)
{
if (!gueltigVon.HasValue)
{
gueltigVon = DateTime.Parse(DateTime.Now.ToString("dd.MM.yyyy"));
}
else
{
gueltigVon = DateTime.Parse(gueltigVon.Value.ToString("dd.MM.yyyy"));
}
if (!gueltigBis.HasValue)
{
gueltigBis = DateTime.Now.AddYears(1);
}
else
{
gueltigBis = DateTime.Parse(gueltigBis.Value.ToString("dd.MM.yyyy"));
}
X509V3CertificateGenerator certGenerator = new X509V3CertificateGenerator();
ArrayList nameOidsSubjectDn = new ArrayList();
nameOidsSubjectDn.Add(X509Name.CN);
nameOidsSubjectDn.Add(X509Name.O);
nameOidsSubjectDn.Add(X509Name.C);
ArrayList nameValuesSubjectDn = new ArrayList();
nameValuesSubjectDn.Add(antragssteller);
nameValuesSubjectDn.Add(antragssteller);
nameValuesSubjectDn.Add("DE");
X509Name subjectDN = new X509Name(nameOidsSubjectDn, nameValuesSubjectDn);
certGenerator.SetSerialNumber(BigInteger.ProbablePrime(120, new Random()));
certGenerator.SetNotBefore(gueltigVon.Value);
certGenerator.SetNotAfter(gueltigBis.Value);
certGenerator.SetSubjectDN(subjectDN);
certGenerator.SetPublicKey(oeffentlicherSchluessel);
certGenerator.SetSignatureAlgorithm(hashtype.ToString());
X509Certificate certificate = null;
if (caZertifikat != null)
{
certGenerator.AddExtension(X509Extensions.AuthorityKeyIdentifier, false, new AuthorityKeyIdentifierStructure(caZertifikat.GetPublicKey()));
certGenerator.AddExtension(X509Extensions.SubjectKeyIdentifier, false, new SubjectKeyIdentifierStructure(oeffentlicherSchluessel));
certGenerator.SetIssuerDN(caZertifikat.IssuerDN);
certificate = certGenerator.Generate(caPrivateKey);
}
else
{
ArrayList nameOidsIssuerDn = new ArrayList();
nameOidsIssuerDn.Add(X509Name.CN);
nameOidsIssuerDn.Add(X509Name.O);
nameOidsIssuerDn.Add(X509Name.C);
ArrayList nameValuesIssuerDn = new ArrayList();
nameValuesIssuerDn.Add(antragssteller);
nameValuesIssuerDn.Add(antragssteller);
nameValuesIssuerDn.Add("DE");
X509Name issuerDn = new X509Name(nameOidsSubjectDn, nameValuesIssuerDn);
certGenerator.SetIssuerDN(issuerDn);
certificate = certGenerator.Generate(privaterSchluessel);
}
return(certificate);
}
