/// <summary>
/// Constructor.
/// </summary>
/// <param name="character">The character</param>
/// <param name="src">The static certificate class</param>
/// <param name="category">The owning category</param>
internal CertificateClass(Character character, StaticCertificateClass src, CertificateGroup category)
{
Character = character;
Category = category;
StaticData = src;
Certificate = new Certificate(character, src.Certificate, this);
}
/// <summary>
/// Does any initialization required before the address space can be used.
/// </summary>
/// <remarks>
/// The externalReferences is an out parameter that allows the node manager to link to nodes
/// in other node managers. For example, the 'Objects' node is managed by the CoreNodeManager and
/// should have a reference to the root folder node(s) exposed by this node manager.
/// </remarks>
public override void CreateAddressSpace(IDictionary <NodeId, IList <IReference> > externalReferences)
{
lock (Lock)
{
base.CreateAddressSpace(externalReferences);
_database.NamespaceIndex = NamespaceIndexes[0];
_request.NamespaceIndex = NamespaceIndexes[0];
foreach (CertificateGroupConfiguration certificateGroupConfiguration in _certificateGroupConfigurationCollection)
{
try
{
CertificateGroup certificateGroup = _certificateGroupFactory.Create(
_authoritiesStorePath, certificateGroupConfiguration);
SetCertificateGroupNodes(certificateGroup);
certificateGroup.Init();
_certificateGroups[certificateGroup.Id] = certificateGroup;
}
catch (Exception e)
{
Utils.Trace(e, $"Unexpected error initializing certificateGroup: {certificateGroupConfiguration.Id}\r\n{e.StackTrace}");
// make sure gds server doesn't start without cert groups!
throw;
}
}
_certTypeMap = new Dictionary <NodeId, string>
{
// list of supported cert type mappings (V1.04)
{ ObjectTypeIds.HttpsCertificateType, nameof(ObjectTypeIds.HttpsCertificateType) },
{ ObjectTypeIds.UserCredentialCertificateType, nameof(ObjectTypeIds.UserCredentialCertificateType) },
{ ObjectTypeIds.ApplicationCertificateType, nameof(ObjectTypeIds.ApplicationCertificateType) },
{ ObjectTypeIds.RsaMinApplicationCertificateType, nameof(ObjectTypeIds.RsaMinApplicationCertificateType) },
{ ObjectTypeIds.RsaSha256ApplicationCertificateType, nameof(ObjectTypeIds.RsaSha256ApplicationCertificateType) }
};
}
}
public override async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation($"Worker started at: {DateTime.Now}");
//server settings
StringCollection baseAddress = new StringCollection
{
DiscoveryEndpointUrl
};
StringCollection serverCapabilities = new StringCollection {
"LDS", "GDS"
};
StringCollection discoveryUrls = new StringCollection
{
"opc.tcp://localhost:58810/UADiscovery"
};
//Initialise
_applicationInstanceManager = new ApplicationInstanceManager(ApplicationName, ApplicationUri,
baseAddress,
serverCapabilities,
DiscoveryEndpointUrl,
DiscoveryEndpointApplicationUri,
discoveryUrls,
null,
_applicationType,
true);
string directoryName = Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly()?.Location);
if (!string.IsNullOrEmpty(directoryName))
{
string databaseDirectory = Path.Combine(directoryName, "gds\\database");
if (!Directory.Exists(databaseDirectory))
{
Directory.CreateDirectory(databaseDirectory);
}
string databaseFile = Path.Combine(databaseDirectory, "gds.database.json");
if (!File.Exists(databaseFile))
{
File.Create(databaseFile).Close();
}
ApplicationsDatabase applicationDatabase = ApplicationsDatabase.Load(databaseFile);
CertificateGroup certificateGroup = new CertificateGroup();
_mainServer = new MainServer(
applicationDatabase,
applicationDatabase,
certificateGroup);
_mainServer.Start(_applicationInstanceManager.ApplicationInstance.ApplicationConfiguration);
}
await base.StartAsync(cancellationToken);
}
/// <summary>
/// Create CA test certificates.
/// </summary>
private async Task CreateCATestCerts(string tempStorePath)
{
Assert.IsTrue(EraseStore(tempStorePath));
string subjectName = "CN=CA Test Cert, O=OPC Foundation";
X509Certificate2 newCACert = CertificateFactory.CreateCertificate(
null, null, subjectName, null)
.SetCAConstraint()
.CreateForRSA()
.AddToStore(CertificateStoreType.Directory, tempStorePath);
_caCert = newCACert;
// initialize cert revocation list (CRL)
X509CRL newCACrl = await CertificateGroup.RevokeCertificateAsync(tempStorePath, newCACert);
_caCrl = newCACrl;
}
private void PopulateModelWithSelectedValues(IEnumerable <string> applicationIds, IEnumerable <string> serverIds, IEnumerable <string> groupIds, Certificate certificate)
{
foreach (string item in applicationIds)
{
CertificateApplication certificateApplication = new CertificateApplication();
certificateApplication.Application = _context.Application.FirstOrDefault(x => x.Id == Convert.ToInt32(item));
certificate.Applications.Add(certificateApplication);
}
foreach (string item in serverIds)
{
CertificateServer certificateServer = new CertificateServer();
certificateServer.Server = _context.Server.FirstOrDefault(x => x.Id == Convert.ToInt32(item));
certificate.Servers.Add(certificateServer);
}
foreach (string item in groupIds)
{
CertificateGroup certificateGroup = new CertificateGroup();
certificateGroup.Group = _context.Group.FirstOrDefault(x => x.Id == Convert.ToInt32(item));
certificate.Groups.Add(certificateGroup);
}
}
/// <summary>
/// Create CA test certificates.
/// </summary>
private async Task CreateCATestCerts(string tempStorePath)
{
Assert.IsTrue(EraseStore(tempStorePath));
string subjectName = "CN=CA Test Cert, O=OPC Foundation";
X509Certificate2 newCACert = CertificateFactory.CreateCertificate(
CertificateStoreType.Directory, tempStorePath, null,
null,
null,
subjectName,
null,
CertificateFactory.DefaultKeySize,
DateTime.UtcNow,
CertificateFactory.DefaultLifeTime,
CertificateFactory.DefaultHashSize,
true);
_caCert = newCACert;
// initialize cert revocation list (CRL)
X509CRL newCACrl = await CertificateGroup.RevokeCertificateAsync(tempStorePath, newCACert);
_caCrl = newCACrl;
}
