Merge 7beec7d into 33d52cc

joevanwanzeeleKF · web-flow · commit 3e7935e2d7dc · 2025-12-01T19:13:00.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,6 @@
+## 1.0.2
+* bug fix: _certDataReader is now initialized in the Initialize method
+
 ## 1.0.1
 * added retrieval of roles associated with enrolled certificates via metadata for Vault Enterprise users
 
diff --git a/hashicorp-vault-cagateway/APIProxy/WrappedResponse.cs b/hashicorp-vault-cagateway/APIProxy/WrappedResponse.cs
@@ -12,6 +12,9 @@ namespace Keyfactor.Extensions.CAPlugin.HashicorpVault.APIProxy
 {
     public class WrappedResponse<T>
     {
+        [JsonPropertyName("request_id")]
+        public string RequestId { get; set; }
+
         [JsonPropertyName("lease_id")]
         public string LeaseId { get; set; }
 
@@ -30,6 +33,9 @@ public class WrappedResponse<T>
         [JsonPropertyName("mount_point")]
         public string MountPoint { get; set; }
 
+        [JsonPropertyName("mount_type")]
+        public string MountType { get; set; }
+
         [JsonPropertyName("mount_running_plugin_version")]
         public string PluginVersion { get; set; }
 
diff --git a/hashicorp-vault-cagateway/Client/HashicorpVaultClient.cs b/hashicorp-vault-cagateway/Client/HashicorpVaultClient.cs
@@ -132,7 +132,13 @@ public async Task<CertResponse> GetCertificate(string certSerial)
             try
             {
                 var response = await _vaultHttp.GetAsync<CertResponse>($"cert/{certSerial}");
+                
                 logger.LogTrace($"successfully received a response for certificate with serial number: {certSerial}");
+                logger.LogTrace($"--response data--");
+                logger.LogTrace($"cert string: {response.Certificate}");
+                logger.LogTrace($"revocation time: {response.RevocationTime}");
+                
+
                 return response;
             }
             catch (Exception ex)
@@ -189,7 +195,7 @@ public async Task<bool> PingServer()
         }
 
         /// <summary>
-        /// Retreives all serial numbers for issued certificates 
+        /// Retrieves all serial numbers for issued certificates 
         /// </summary>
         /// <returns>a list of the certificate serial number strings</returns>
         public async Task<List<string>> GetAllCertSerialNumbers()
@@ -247,7 +253,7 @@ public async Task<List<string>> GetRoleNamesAsync()
         }
 
         /// <summary>
-        /// Retreives the metadata for the certificate
+        /// Retrieves the metadata for the certificate
         /// </summary>
         /// <param name="certSerial"></param>
         /// <returns></returns>
@@ -275,7 +281,7 @@ public async Task<MetadataResponse> GetCertMetadata(string certSerial)
             }
             catch (Exception ex)
             { 
-                logger.LogError($"an error occurred when attempting to retreive the certificate metadata: {ex.Message}");
+                logger.LogError($"an error occurred when attempting to retrieve the certificate metadata: {ex.Message}");
                 throw;
             }            
             finally { logger.MethodExit(); }
diff --git a/hashicorp-vault-cagateway/Client/VaultHttp.cs b/hashicorp-vault-cagateway/Client/VaultHttp.cs
@@ -8,13 +8,15 @@
 using Keyfactor.Extensions.CAPlugin.HashicorpVault.APIProxy;
 using Keyfactor.Logging;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
 using RestSharp;
 using RestSharp.Serializers.Json;
 using System;
 using System.Collections.Generic;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Threading.Tasks;
+using JsonSerializer = Newtonsoft.Json.JsonSerializer;
 
 namespace Keyfactor.Extensions.CAPlugin.HashicorpVault.Client
 {
@@ -35,13 +37,13 @@ public VaultHttp(string host, string mountPoint, string authToken, string nameSp
 
             _serializerOptions = new()
             {
-                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault,
+                DefaultIgnoreCondition = JsonIgnoreCondition.Never,
                 RespectNullableAnnotations = true,
                 PropertyNameCaseInsensitive = true,
-                PreferredObjectCreationHandling = JsonObjectCreationHandling.Replace,
+                PreferredObjectCreationHandling = JsonObjectCreationHandling.Replace                
             };
 
-            var restClientOptions = new RestClientOptions($"{host.TrimEnd('/')}/v1") { ThrowOnAnyError = true };
+            var restClientOptions = new RestClientOptions($"{host.TrimEnd('/')}/v1") { ThrowOnAnyError = true  };
             _restClient = new RestClient(restClientOptions, configureSerialization: s => s.UseSystemTextJson(_serializerOptions));
 
             _mountPoint = mountPoint.TrimStart('/').TrimEnd('/'); // remove leading and trailing slashes
@@ -69,19 +71,29 @@ public VaultHttp(string host, string mountPoint, string authToken, string nameSp
         public async Task<T> GetAsync<T>(string path, Dictionary<string, string> parameters = null)
         {
             logger.MethodEntry();
-            logger.LogTrace($"preparing to send GET request to {path} with parameters {JsonSerializer.Serialize(parameters)}");
-            logger.LogTrace($"will attempt to deserialize the response into a {typeof(T)}");
+            logger.LogTrace($"preparing to send GET request to {path} with parameters {JsonConvert.SerializeObject(parameters)}");
+            
             try
             {
                 var request = new RestRequest($"{_mountPoint}/{path}", Method.Get);
-                if (parameters != null) { request.AddJsonBody(parameters); }
-
-                var response = await _restClient.ExecuteGetAsync<T>(request);
+                if (parameters != null && parameters.Keys.Count > 0) { request.AddJsonBody(parameters); }
+                var response = await _restClient.ExecuteGetAsync(request);
+                
                 logger.LogTrace($"raw response: {response.Content}");
 
+                logger.LogTrace($"response status: {response.StatusCode}");
+
+                logger.LogTrace($"response error msg: {response.ErrorMessage}");
+
                 response.ThrowIfError();
+                if (string.IsNullOrEmpty(response.Content)) throw new Exception(response.ErrorMessage ?? "no content returned from Vault");
 
-                return response.Data;
+                logger.LogTrace($"deserializing the response into a {typeof(T)}");
+                var deserialized = JsonConvert.DeserializeObject<T>(response.Content);
+
+                logger.LogTrace($"successfully deserialized the reponse");
+                
+                return deserialized;
             }
             catch (Exception ex)
             {
@@ -108,8 +120,8 @@ public async Task<T> PostAsync<T>(string path, dynamic parameters = default)
                 var request = new RestRequest(resourcePath, Method.Post);
                 if (parameters != null)
                 {
-                    string serializedParams = JsonSerializer.Serialize(parameters, _serializerOptions);
-                    logger.LogTrace($"serialized parameters (from {parameters.GetType()?.Name}): {serializedParams}");
+                    string serializedParams = JsonConvert.SerializeObject(parameters);
+                    logger.LogTrace($"deserialized parameters (from {parameters.GetType()?.Name}): {serializedParams}");
                     request.AddJsonBody(serializedParams);
                 }
 
@@ -127,7 +139,7 @@ public async Task<T> PostAsync<T>(string path, dynamic parameters = default)
 
                 if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
                 {
-                    errorResponse = JsonSerializer.Deserialize<ErrorResponse>(response.Content!);
+                    errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(response.Content ?? "no content");
                     string allErrors = "(Bad Request)";
                     if (errorResponse?.Errors.Count > 0)
                     {
diff --git a/hashicorp-vault-cagateway/HashicorpVaultCAConnector.cs b/hashicorp-vault-cagateway/HashicorpVaultCAConnector.cs
@@ -18,6 +18,7 @@
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Reflection;
 
 namespace Keyfactor.Extensions.CAPlugin.HashicorpVault
 {
@@ -50,10 +51,22 @@ public void Initialize(IAnyCAPluginConfigProvider configProvider, ICertificateDa
         {
             logger.MethodEntry(LogLevel.Trace);
             string rawConfig = JsonSerializer.Serialize(configProvider.CAConnectionData);
-            logger.LogTrace($"serialized config: {rawConfig}");
             _caConfig = JsonSerializer.Deserialize<HashicorpVaultCAConfig>(rawConfig);
             logger.MethodExit(LogLevel.Trace);
             _client = new HashicorpVaultClient(_caConfig);
+            _certificateDataReader = certificateDataReader;
+
+            Assembly targetAssembly = typeof(HashicorpVaultCAConnector).Assembly;
+
+            // Get the AssemblyName object
+            AssemblyName assemblyName = targetAssembly?.GetName();
+
+            // Get the Version object
+            Version version = assemblyName?.Version;
+
+            logger.LogTrace($"-- {assemblyName?.Name ?? "unknown"} v{version}  --");
+
+            logger.LogTrace($"serialized config: {rawConfig}");
         }
 
         /// <summary>
@@ -239,7 +252,7 @@ public async Task Synchronize(BlockingCollection<AnyCAPluginCertificate> blockin
             }
             catch (Exception ex)
             {
-                logger.LogError($"failed to retreive serial numbers: {LogHandler.FlattenException(ex)}");
+                logger.LogError($"failed to retrieve serial numbers: {LogHandler.FlattenException(ex)}");
                 throw;
             }
 
@@ -250,25 +263,25 @@ public async Task Synchronize(BlockingCollection<AnyCAPluginCertificate> blockin
                 CertResponse certFromVault = null;
                 var dbStatus = -1;
 
-                // first, retreive the details from Vault
+                // first, retrieve the details from Vault
                 try
                 {
                     logger.LogTrace($"Calling GetCertificate on our client, passing serial number: {certSerial}");
                     certFromVault = await _client.GetCertificate(certSerial);
                 }
                 catch (Exception ex)
                 {
-                    logger.LogError($"Failed to retreive details for certificate with serial number {certSerial} from Vault.  Errors: {LogHandler.FlattenException(ex)}");
+                    logger.LogError($"Failed to retrieve details for certificate with serial number {certSerial} from Vault.  Errors: {LogHandler.FlattenException(ex)}");
                     throw;
                 }
                 logger.LogTrace($"converting {certSerial} to database trackingId");
 
-                var trackingId =  certSerial.Replace(":", "-"); // we store with '-'; hashi stores with ':'
+                var trackingId = certSerial.Replace(":", "-"); // we store with '-'; hashi stores with ':'
 
                 // then, check for an existing local entry
                 try
                 {
-                    logger.LogTrace($"attempting to retreive status of cert with tracking id {trackingId} from the database");
+                    logger.LogTrace($"attempting to retrieve status of cert with tracking id {trackingId} from the database");
                     dbStatus = await _certificateDataReader.GetStatusByRequestID(trackingId);
                 }
                 catch
@@ -280,29 +293,29 @@ public async Task Synchronize(BlockingCollection<AnyCAPluginCertificate> blockin
                 {
                     logger.LogTrace($"adding cert with serial {trackingId} to the database.  fullsync is {fullSync}, and the certificate {(dbStatus == -1 ? "does not yet exist" : "already exists")} in the database.");
 
-                    logger.LogTrace("attempting to retreive the role name (productId) from the certificate metadata, if available");
+                    logger.LogTrace("attempting to retrieve the role name (productId) from the certificate metadata, if available");
 
                     var metaData = new MetadataResponse();
-                    
+
                     try
                     {
                         metaData = await _client.GetCertMetadata(certSerial);
                     }
-                    catch (Exception) 
+                    catch (Exception)
                     {
-                        logger.LogTrace("an error occurred when attempting to retreive the metadata, continuing..");
+                        logger.LogTrace("an error occurred when attempting to retrieve the metadata, continuing..");
                     }
 
                     var newCert = new AnyCAPluginCertificate
                     {
                         CARequestID = trackingId,
                         Certificate = certFromVault.Certificate,
                         Status = certFromVault.RevocationTime != null ? (int)EndEntityStatus.REVOKED : (int)EndEntityStatus.GENERATED,
-                        RevocationDate = certFromVault.RevocationTime,                        
+                        RevocationDate = certFromVault.RevocationTime,
                     };
 
                     // if we were able to get the role name from metadata, we include it
-                    if (!string.IsNullOrEmpty(metaData?.Role)) 
+                    if (!string.IsNullOrEmpty(metaData?.Role))
                     {
                         newCert.ProductID = metaData.Role;
                     }
@@ -346,7 +359,7 @@ public async Task Synchronize(BlockingCollection<AnyCAPluginCertificate> blockin
         /// </summary>
         /// <param name="connectionInfo">The information used to connect to the CA.</param>
         public async Task ValidateCAConnectionInfo(Dictionary<string, object> connectionInfo)
-        {            
+        {
             logger.MethodEntry();
             logger.LogTrace(message: $"Validating CA connection info: {JsonSerializer.Serialize(connectionInfo)}");
 
@@ -372,7 +385,7 @@ public async Task ValidateCAConnectionInfo(Dictionary<string, object> connection
 
             // make sure an authentication mechanism is defined (either certificate or token)
             var token = connectionInfo[Constants.CAConfig.TOKEN] as string;
-            
+
             //var cert = connectionInfo[Constants.CAConfig.CLIENTCERT] as string;
 
             var cert = string.Empty; // temporary until client cert auth into vault is implemented
@@ -422,12 +435,12 @@ public async Task ValidateCAConnectionInfo(Dictionary<string, object> connection
 
             _client = new HashicorpVaultClient(config);
 
-            // attempt an authenticated request to retreive role names
+            // attempt an authenticated request to retrieve role names
             try
             {
                 logger.LogTrace("making an authenticated request to the Vault server to verify credentials (listing role names)..");
                 var roleNames = await _client.GetRoleNamesAsync();
-                logger.LogTrace($"successfule request: received a response containing {roleNames.Count} role names");
+                logger.LogTrace($"successful request: received a response containing {roleNames?.Count} role names");
             }
             catch (Exception ex)
             {
@@ -465,7 +478,7 @@ public Task ValidateProductInfo(EnrollmentProductInfo productInfo, Dictionary<st
                 logger.LogError(LogHandler.FlattenException(ex));
                 throw;
             }
-                        
+
             // if any errors, throw
             if (errors.Any())
             {
@@ -570,7 +583,10 @@ public List<string> GetProductIds()
             try
             {
                 logger.LogTrace("requesting role names from vault..");
-                var roleNames = _client.GetRoleNamesAsync().Result;
+                var roleNames = _client.GetRoleNamesAsync().GetAwaiter().GetResult();
+                if (roleNames == null) {
+                    throw new Exception("no role names returned, or deserialization failed.");
+                }
                 logger.LogTrace($"got {roleNames.Count} role names from vault:");
                 foreach (var name in roleNames)
                 {
diff --git a/hashicorp-vault-cagateway/hashicorp-vault-caplugin.csproj b/hashicorp-vault-cagateway/hashicorp-vault-caplugin.csproj
@@ -37,6 +37,7 @@
 		<PackageReference Include="Keyfactor.AnyGateway.IAnyCAPlugin" Version="3.0.0" />
 		<PackageReference Include="Keyfactor.Logging" Version="1.1.2" />
 		<PackageReference Include="Keyfactor.PKI" Version="5.5.0" />
+		<PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
 		<PackageReference Include="RestSharp" Version="112.1.0" />
 		<PackageReference Include="System.Formats.Asn1" Version="9.0.0" />
 		<PackageReference Include="System.Net.Http.WinHttpHandler" Version="9.0.0" />
diff --git a/readme_source.md b/readme_source.md
@@ -95,7 +95,7 @@ Certificates issued for the Hashicorp Vault CA from within the Keyfactor Command
     1. Create an entry for each of the PKI secrets engine roles you would like to use for issuing certificates from the Hashicorp Vault CA.          
     1. Navigate to the "Certificate Authorities" tab and click "Edit"
     1. In the "Edit CA" window, navigate to the "Templates" tab.
-    1. Create an association between each of the certificate profiles we just created with the PKI secrets engine roles retreived from Vault.
+    1. Create an association between each of the certificate profiles we just created with the PKI secrets engine roles retrieved from Vault.
     
 ### Configure the CA in Keyfactor Command
 

Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,13 @@ public async Task<CertResponse> GetCertificate(string certSerial)`
`132`	`132`	`try`
`133`	`133`	`{`
`134`	`134`	`var response = await _vaultHttp.GetAsync<CertResponse>($"cert/{certSerial}");`
	`135`	`+`
`135`	`136`	`logger.LogTrace($"successfully received a response for certificate with serial number: {certSerial}");`
	`137`	`+ logger.LogTrace($"--response data--");`
	`138`	`+ logger.LogTrace($"cert string: {response.Certificate}");`
	`139`	`+ logger.LogTrace($"revocation time: {response.RevocationTime}");`
	`140`	`+`
	`141`	`+`
`136`	`142`	`return response;`
`137`	`143`	`}`
`138`	`144`	`catch (Exception ex)`
`@@ -189,7 +195,7 @@ public async Task<bool> PingServer()`
`189`	`195`	`}`
`190`	`196`
`191`	`197`	`/// <summary>`
`192`		`- /// Retreives all serial numbers for issued certificates`
	`198`	`+ /// Retrieves all serial numbers for issued certificates`
`193`	`199`	`/// </summary>`
`194`	`200`	`/// <returns>a list of the certificate serial number strings</returns>`
`195`	`201`	`public async Task<List<string>> GetAllCertSerialNumbers()`
`@@ -247,7 +253,7 @@ public async Task<List<string>> GetRoleNamesAsync()`
`247`	`253`	`}`
`248`	`254`
`249`	`255`	`/// <summary>`
`250`		`- /// Retreives the metadata for the certificate`
	`256`	`+ /// Retrieves the metadata for the certificate`
`251`	`257`	`/// </summary>`
`252`	`258`	`/// <param name="certSerial"></param>`
`253`	`259`	`/// <returns></returns>`
`@@ -275,7 +281,7 @@ public async Task<MetadataResponse> GetCertMetadata(string certSerial)`
`275`	`281`	`}`
`276`	`282`	`catch (Exception ex)`
`277`	`283`	`{`
`278`		`- logger.LogError($"an error occurred when attempting to retreive the certificate metadata: {ex.Message}");`
	`284`	`+ logger.LogError($"an error occurred when attempting to retrieve the certificate metadata: {ex.Message}");`
`279`	`285`	`throw;`
`280`	`286`	`}`
`281`	`287`	`finally { logger.MethodExit(); }`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`using System.Text.Json;`
`19`	`19`	`using System.Threading;`
`20`	`20`	`using System.Threading.Tasks;`
	`21`	`+using System.Reflection;`
`21`	`22`
`22`	`23`	`namespace Keyfactor.Extensions.CAPlugin.HashicorpVault`
`23`	`24`	`{`
`@@ -50,10 +51,22 @@ public void Initialize(IAnyCAPluginConfigProvider configProvider, ICertificateDa`
`50`	`51`	`{`
`51`	`52`	`logger.MethodEntry(LogLevel.Trace);`
`52`	`53`	`string rawConfig = JsonSerializer.Serialize(configProvider.CAConnectionData);`
`53`		`- logger.LogTrace($"serialized config: {rawConfig}");`
`54`	`54`	`_caConfig = JsonSerializer.Deserialize<HashicorpVaultCAConfig>(rawConfig);`
`55`	`55`	`logger.MethodExit(LogLevel.Trace);`
`56`	`56`	`_client = new HashicorpVaultClient(_caConfig);`
	`57`	`+ _certificateDataReader = certificateDataReader;`
	`58`	`+`
	`59`	`+ Assembly targetAssembly = typeof(HashicorpVaultCAConnector).Assembly;`
	`60`	`+`
	`61`	`+ // Get the AssemblyName object`
	`62`	`+ AssemblyName assemblyName = targetAssembly?.GetName();`
	`63`	`+`
	`64`	`+ // Get the Version object`
	`65`	`+ Version version = assemblyName?.Version;`
	`66`	`+`
	`67`	`+ logger.LogTrace($"-- {assemblyName?.Name ?? "unknown"} v{version} --");`
	`68`	`+`
	`69`	`+ logger.LogTrace($"serialized config: {rawConfig}");`
`57`	`70`	`}`
`58`	`71`
`59`	`72`	`/// <summary>`
`@@ -239,7 +252,7 @@ public async Task Synchronize(BlockingCollection<AnyCAPluginCertificate> blockin`
`239`	`252`	`}`
`240`	`253`	`catch (Exception ex)`
`241`	`254`	`{`
`242`		`- logger.LogError($"failed to retreive serial numbers: {LogHandler.FlattenException(ex)}");`
	`255`	`+ logger.LogError($"failed to retrieve serial numbers: {LogHandler.FlattenException(ex)}");`
`243`	`256`	`throw;`
`244`	`257`	`}`
`245`	`258`
`@@ -250,25 +263,25 @@ public async Task Synchronize(BlockingCollection<AnyCAPluginCertificate> blockin`
`250`	`263`	`CertResponse certFromVault = null;`
`251`	`264`	`var dbStatus = -1;`
`252`	`265`
`253`		`- // first, retreive the details from Vault`
	`266`	`+ // first, retrieve the details from Vault`
`254`	`267`	`try`
`255`	`268`	`{`
`256`	`269`	`logger.LogTrace($"Calling GetCertificate on our client, passing serial number: {certSerial}");`
`257`	`270`	`certFromVault = await _client.GetCertificate(certSerial);`
`258`	`271`	`}`
`259`	`272`	`catch (Exception ex)`
`260`	`273`	`{`
`261`		`- logger.LogError($"Failed to retreive details for certificate with serial number {certSerial} from Vault. Errors: {LogHandler.FlattenException(ex)}");`
	`274`	`+ logger.LogError($"Failed to retrieve details for certificate with serial number {certSerial} from Vault. Errors: {LogHandler.FlattenException(ex)}");`
`262`	`275`	`throw;`
`263`	`276`	`}`
`264`	`277`	`logger.LogTrace($"converting {certSerial} to database trackingId");`
`265`	`278`
`266`		`- var trackingId = certSerial.Replace(":", "-"); // we store with '-'; hashi stores with ':'`
	`279`	`+ var trackingId = certSerial.Replace(":", "-"); // we store with '-'; hashi stores with ':'`
`267`	`280`
`268`	`281`	`// then, check for an existing local entry`
`269`	`282`	`try`
`270`	`283`	`{`
`271`		`- logger.LogTrace($"attempting to retreive status of cert with tracking id {trackingId} from the database");`
	`284`	`+ logger.LogTrace($"attempting to retrieve status of cert with tracking id {trackingId} from the database");`
`272`	`285`	`dbStatus = await _certificateDataReader.GetStatusByRequestID(trackingId);`
`273`	`286`	`}`
`274`	`287`	`catch`
`@@ -280,29 +293,29 @@ public async Task Synchronize(BlockingCollection<AnyCAPluginCertificate> blockin`
`280`	`293`	`{`
`281`	`294`	`logger.LogTrace($"adding cert with serial {trackingId} to the database. fullsync is {fullSync}, and the certificate {(dbStatus == -1 ? "does not yet exist" : "already exists")} in the database.");`
`282`	`295`
`283`		`- logger.LogTrace("attempting to retreive the role name (productId) from the certificate metadata, if available");`
	`296`	`+ logger.LogTrace("attempting to retrieve the role name (productId) from the certificate metadata, if available");`
`284`	`297`
`285`	`298`	`var metaData = new MetadataResponse();`
`286`		`-`
	`299`	`+`
`287`	`300`	`try`
`288`	`301`	`{`
`289`	`302`	`metaData = await _client.GetCertMetadata(certSerial);`
`290`	`303`	`}`
`291`		`- catch (Exception)`
	`304`	`+ catch (Exception)`
`292`	`305`	`{`
`293`		`- logger.LogTrace("an error occurred when attempting to retreive the metadata, continuing..");`
	`306`	`+ logger.LogTrace("an error occurred when attempting to retrieve the metadata, continuing..");`
`294`	`307`	`}`
`295`	`308`
`296`	`309`	`var newCert = new AnyCAPluginCertificate`
`297`	`310`	`{`
`298`	`311`	`CARequestID = trackingId,`
`299`	`312`	`Certificate = certFromVault.Certificate,`
`300`	`313`	`Status = certFromVault.RevocationTime != null ? (int)EndEntityStatus.REVOKED : (int)EndEntityStatus.GENERATED,`
`301`		`- RevocationDate = certFromVault.RevocationTime,`
	`314`	`+ RevocationDate = certFromVault.RevocationTime,`
`302`	`315`	`};`
`303`	`316`
`304`	`317`	`// if we were able to get the role name from metadata, we include it`
`305`		`- if (!string.IsNullOrEmpty(metaData?.Role))`
	`318`	`+ if (!string.IsNullOrEmpty(metaData?.Role))`
`306`	`319`	`{`
`307`	`320`	`newCert.ProductID = metaData.Role;`
`308`	`321`	`}`
`@@ -346,7 +359,7 @@ public async Task Synchronize(BlockingCollection<AnyCAPluginCertificate> blockin`
`346`	`359`	`/// </summary>`
`347`	`360`	`/// <param name="connectionInfo">The information used to connect to the CA.</param>`
`348`	`361`	`public async Task ValidateCAConnectionInfo(Dictionary<string, object> connectionInfo)`
`349`		`- {`
	`362`	`+ {`
`350`	`363`	`logger.MethodEntry();`
`351`	`364`	`logger.LogTrace(message: $"Validating CA connection info: {JsonSerializer.Serialize(connectionInfo)}");`
`352`	`365`
`@@ -372,7 +385,7 @@ public async Task ValidateCAConnectionInfo(Dictionary<string, object> connection`
`372`	`385`
`373`	`386`	`// make sure an authentication mechanism is defined (either certificate or token)`
`374`	`387`	`var token = connectionInfo[Constants.CAConfig.TOKEN] as string;`
`375`		`-`
	`388`	`+`
`376`	`389`	`//var cert = connectionInfo[Constants.CAConfig.CLIENTCERT] as string;`
`377`	`390`
`378`	`391`	`var cert = string.Empty; // temporary until client cert auth into vault is implemented`
`@@ -422,12 +435,12 @@ public async Task ValidateCAConnectionInfo(Dictionary<string, object> connection`
`422`	`435`
`423`	`436`	`_client = new HashicorpVaultClient(config);`
`424`	`437`
`425`		`- // attempt an authenticated request to retreive role names`
	`438`	`+ // attempt an authenticated request to retrieve role names`
`426`	`439`	`try`
`427`	`440`	`{`
`428`	`441`	`logger.LogTrace("making an authenticated request to the Vault server to verify credentials (listing role names)..");`
`429`	`442`	`var roleNames = await _client.GetRoleNamesAsync();`
`430`		`- logger.LogTrace($"successfule request: received a response containing {roleNames.Count} role names");`
	`443`	`+ logger.LogTrace($"successful request: received a response containing {roleNames?.Count} role names");`
`431`	`444`	`}`
`432`	`445`	`catch (Exception ex)`
`433`	`446`	`{`
`@@ -465,7 +478,7 @@ public Task ValidateProductInfo(EnrollmentProductInfo productInfo, Dictionary<st`
`465`	`478`	`logger.LogError(LogHandler.FlattenException(ex));`
`466`	`479`	`throw;`
`467`	`480`	`}`
`468`		`-`
	`481`	`+`
`469`	`482`	`// if any errors, throw`
`470`	`483`	`if (errors.Any())`
`471`	`484`	`{`
`@@ -570,7 +583,10 @@ public List<string> GetProductIds()`
`570`	`583`	`try`
`571`	`584`	`{`
`572`	`585`	`logger.LogTrace("requesting role names from vault..");`
`573`		`- var roleNames = _client.GetRoleNamesAsync().Result;`
	`586`	`+ var roleNames = _client.GetRoleNamesAsync().GetAwaiter().GetResult();`
	`587`	`+ if (roleNames == null) {`
	`588`	`+ throw new Exception("no role names returned, or deserialization failed.");`
	`589`	`+ }`
`574`	`590`	`logger.LogTrace($"got {roleNames.Count} role names from vault:");`
`575`	`591`	`foreach (var name in roleNames)`
`576`	`592`	`{`