private static SignatureStatus GetSignatureStatusFromWin32Error(DWORD error)
{
SignatureStatus isc = SignatureStatus.UnknownError;
switch (error)
{
case Win32Errors.NO_ERROR:
isc = SignatureStatus.Valid;
break;
case Win32Errors.NTE_BAD_ALGID:
isc = SignatureStatus.Incompatible;
break;
case Win32Errors.TRUST_E_NOSIGNATURE:
isc = SignatureStatus.NotSigned;
break;
case Win32Errors.TRUST_E_BAD_DIGEST:
case Win32Errors.CRYPT_E_BAD_MSG:
isc = SignatureStatus.HashMismatch;
break;
case Win32Errors.TRUST_E_PROVIDER_UNKNOWN:
isc = SignatureStatus.NotSupportedFileFormat;
break;
case Win32Errors.TRUST_E_EXPLICIT_DISTRUST:
isc = SignatureStatus.NotTrusted;
break;
}
return(isc);
}
internal Signature(string filePath, uint error)
{
this.status = SignatureStatus.UnknownError;
this.statusMessage = string.Empty;
Utils.CheckArgForNullOrEmpty(filePath, "filePath");
this.Init(filePath, null, error, null);
}
internal Signature(string filePath, uint error)
{
this.status = SignatureStatus.UnknownError;
this.statusMessage = string.Empty;
Utils.CheckArgForNullOrEmpty(filePath, "filePath");
this.Init(filePath, null, error, null);
}
/// <summary>
/// Verifies a given XPS digital signature.
/// </summary>
/// <remarks>This computes and checks the hashes of all the package
/// parts, so it may take a long time to complete.</remarks>
/// <param name="xpsSignature">The XPS signature to verify</param>
/// <returns>The status of the signature</returns>
private static SignatureStatus VerifyXpsDigitalSignature(XpsDigitalSignature xpsDigitalSignature)
{
SignatureStatus status = SignatureStatus.Unknown;
//Verify signature and map to DRPs SignatureStatus enum.
switch (xpsDigitalSignature.Verify())
{
case VerifyResult.Success:
{
status = SignatureStatus.Valid;
break;
}
case VerifyResult.NotSigned:
{
status = SignatureStatus.NotSigned;
break;
}
default:
{
status = SignatureStatus.Invalid;
break;
}
}
return(status);
}
internal Signature(string filePath, uint error, X509Certificate2 signer)
{
this.status = SignatureStatus.UnknownError;
this.statusMessage = string.Empty;
Utils.CheckArgForNullOrEmpty(filePath, "filePath");
Utils.CheckArgForNull(signer, "signer");
this.Init(filePath, signer, error, null);
}
internal Signature(string filePath, uint error, X509Certificate2 signer)
{
this.status = SignatureStatus.UnknownError;
this.statusMessage = string.Empty;
Utils.CheckArgForNullOrEmpty(filePath, "filePath");
Utils.CheckArgForNull(signer, "signer");
this.Init(filePath, signer, error, null);
}
public static Bitmap GetStatusImage(SignatureStatus status)
{
var imageName = "RedX";
if (status == SignatureStatus.Complete)
{
imageName = "GreenCheck";
}
return(new Bitmap(System.Web.HttpContext.Current.Server.MapPath(string.Format("~/Content/Img/{0}.gif", imageName))));
}
private void Init(string filePath, X509Certificate2 signer, uint error, X509Certificate2 timestamper)
{
this.path = filePath;
this.win32Error = error;
this.signerCert = signer;
this.timeStamperCert = timestamper;
SignatureStatus status = GetSignatureStatusFromWin32Error(error);
this.status = status;
this.statusMessage = GetSignatureStatusMessage(status, error, filePath);
}
private SignatureStatus VerifyFileSignature(Stream literalDataStream, PgpOnePassSignatureList pgpOnePassSignatureList, PgpSignatureList pgpSignatureList)
{
try
{
const int BUFFER_SIZE = 1 << 16; // should always be power of 2
SignatureStatus signatureStatus = SignatureStatus.Invalid;
var signatureKeys = GetAllSignatureKeys();
if (pgpOnePassSignatureList == null)
{
return(SignatureStatus.NoSignature);
}
for (int i = 0; i < pgpOnePassSignatureList.Count; i++)
{
if (literalDataStream.CanSeek)
{
literalDataStream.Seek(0, SeekOrigin.Begin);
}
PgpOnePassSignature pgpOnePassSignature = pgpOnePassSignatureList[i];
Stream dIn = literalDataStream;
var keyIn = FindSignatureKey(signatureKeys, pgpOnePassSignature.KeyId);
if (keyIn == null)
{
continue;
}
pgpOnePassSignature.InitVerify(keyIn);
byte[] buf = new byte[BUFFER_SIZE];
int len;
while ((len = dIn.Read(buf, 0, buf.Length)) > 0)
{
pgpOnePassSignature.Update(buf, 0, len);
}
PgpSignature pgpSignature = pgpSignatureList[i];
if (pgpOnePassSignature.Verify(pgpSignature))
{
signatureStatus = SignatureStatus.Valid;
break;
}
}
return(signatureStatus);
}
catch
{
return(SignatureStatus.Error);
}
}
/// <summary>Initializes this list given the key whose signatures will be displayed.</summary>
public void Initialize(Dictionary<string,Signature[]> sigs)
{
if(sigs == null) throw new ArgumentNullException();
Items.Clear();
this.SmallImageList = TreeImageList;
foreach(KeyValuePair<string,Signature[]> pair in sigs)
{
ListViewItem sourceItem = new ListViewItem(pair.Key);
Items.Add(sourceItem);
ListViewItem subItem = null;
SignatureStatus overallStatus = SignatureStatus.Valid;
if(pair.Value == null)
{
subItem = new ListViewItem("An error occurred");
subItem.ForeColor = Color.FromArgb(255, 96, 96);
subItem.IndentCount = 1;
Items.Add(subItem);
overallStatus = SignatureStatus.Error;
}
else if(pair.Value.Length == 0)
{
subItem = new ListViewItem("No signatures");
subItem.IndentCount = 1;
Items.Add(subItem);
}
else
{
foreach(Signature sig in pair.Value)
{
if(sig.IsInvalid) overallStatus = SignatureStatus.Invalid;
else if(!sig.IsValid && overallStatus != SignatureStatus.Invalid) overallStatus = SignatureStatus.Error;
SignatureItem sigItem = CreateSignatureItem(sig);
if(sigItem != null)
{
sigItem.ImageIndex = IndentImage;
sigItem.IndentCount = 1;
SetFont(sigItem);
Items.Add(sigItem);
subItem = sigItem;
}
}
}
subItem.ImageIndex = CornerImage;
SetFont(sourceItem, overallStatus);
}
}
/// <include file="documentation.xml" path="/UI/ListBase/SetSourceItemFont/*"/>
protected virtual void SetFont(ListViewItem sourceItem, SignatureStatus status)
{
SignatureStatus basicStatus = status & SignatureStatus.SuccessMask;
if(basicStatus == SignatureStatus.Invalid)
{
sourceItem.ForeColor = Color.Red;
}
else if(basicStatus != SignatureStatus.Valid)
{
sourceItem.ForeColor = Color.FromArgb(255, 96, 96);
}
if(boldFont == null) boldFont = new Font(Font, FontStyle.Bold);
sourceItem.Font = boldFont;
}
private static SignatureStatus GetSignatureStatusFromWin32Error(uint error)
{
SignatureStatus unknownError = SignatureStatus.UnknownError;
uint num = error;
if (num <= 0x8009200d)
{
switch (num)
{
case 0:
return(SignatureStatus.Valid);
case 0x80090008:
return(SignatureStatus.Incompatible);
case 0x8009200d:
goto Label_005A;
}
return(unknownError);
}
if (num <= 0x800b0001)
{
switch (num)
{
case 0x80096010:
goto Label_005A;
case 0x800b0001:
return(SignatureStatus.NotSupportedFileFormat);
}
return(unknownError);
}
switch (num)
{
case 0x800b0100:
return(SignatureStatus.NotSigned);
case 0x800b0111:
return(SignatureStatus.NotTrusted);
default:
return(unknownError);
}
Label_005A:
return(SignatureStatus.HashMismatch);
}
private void Init(
string filePath,
X509Certificate2 signer,
uint error,
X509Certificate2 timestamper)
{
using (Signature.tracer.TraceMethod())
{
this.path = filePath;
this.win32Error = error;
this.signerCert = signer;
this.timeStamperCert = timestamper;
SignatureStatus statusFromWin32Error = Signature.GetSignatureStatusFromWin32Error(error);
this.status = statusFromWin32Error;
this.statusMessage = Signature.GetSignatureStatusMessage(statusFromWin32Error, error, filePath);
}
}
/// <summary>
/// Get the DrawingBrush icon for the status.
/// </summary>
/// <param name="status">Requested status</param>
/// <returns>A DrawingBrush on success (valid status, DrawingBrush found), null
/// otherwise.</returns>
private static DrawingBrush GetDrawingBrushFromStatus(SignatureStatus sigStatus)
{
if (_brushResources == null)
{
// Get the entire list of SignatureStatus values.
Array statusList = Enum.GetValues(typeof(SignatureStatus));
// Construct the array to hold brush references.
_brushResources = new DrawingBrush[statusList.Length];
// To find the DrawingBrushes in the theme resources we need a
// FrameworkElement. TextBlock was used as it appears to have a very small
// footprint, and won't take long to construct. The actual
// FrameworkElement doesn't matter as long as we have an instance to one
_frameworkElement = new TextBlock();
}
if ((_brushResources != null) && (_frameworkElement != null))
{
int index = (int)sigStatus;
// If there is no cached value of the requested DrawingBrush, then find
// it in the Resources.
if (_brushResources[index] == null)
{
// Determine resource name.
string resourceName = "PUISignatureStatus"
+ Enum.GetName(typeof(SignatureStatus), sigStatus)
+ "BrushKey";
// Acquire reference to the brush.
object resource = _frameworkElement.FindResource(
new ComponentResourceKey(
typeof(PresentationUIStyleResources), resourceName));
// Set cache value for the brush.
_brushResources[index] = resource as DrawingBrush;
}
return(_brushResources[index]);
}
return(null);
}
private void Init(string filePath,
X509Certificate2 signer,
DWORD error,
X509Certificate2 timestamper)
{
_path = filePath;
_win32Error = error;
_signerCert = signer;
_timeStamperCert = timestamper;
SignatureType = SignatureType.None;
SignatureStatus isc =
GetSignatureStatusFromWin32Error(error);
_status = isc;
_statusMessage = GetSignatureStatusMessage(isc,
error,
filePath);
}
/// <summary>
/// Acquire the UI message associated with the signature status
/// </summary>
/// <param name="sigStatus">The signature status to represent</param>
/// <param name="certStatus">The certificate status for the signature</param>
/// <returns>The string associated with the status, otherwise String.Empty.</returns>
private static string GetSignatureSummaryMessage(SignatureStatus sigStatus, CertificatePriorityStatus certStatus)
{
string message = String.Empty;
if (sigStatus == SignatureStatus.Valid)
{
message = (certStatus == CertificatePriorityStatus.Ok) ?
SR.Get(SRID.SignatureResourceHelperSignatureStatusValid) : // Cert valid
SR.Get(SRID.SignatureResourceHelperSignatureStatusValidCertInvalid); // Cert invalid
}
else if (sigStatus == SignatureStatus.Unverifiable)
{
message = SR.Get(SRID.SignatureResourceHelperSignatureStatusUnverifiable);
}
else
{
message = SR.Get(SRID.SignatureResourceHelperSignatureStatusInvalid);
}
return(message);
}
public object Convert(object value, Type targetType,
object parameter, CultureInfo culture)
{
SignatureStatus status = value as SignatureStatus;
if (status == null)
{
return("No");
}
if (!status.IsSigned)
{
return("No");
}
else if (status.IsSignatureValid)
{
return("Yes");
}
else
{
return("Signature invalid");
}
}
public object Convert(object value, Type targetType,
object parameter, CultureInfo culture)
{
SignatureStatus status = value as SignatureStatus;
if (status == null)
{
return(FontWeights.Normal);
}
if (!status.IsSigned)
{
return(FontWeights.Normal);
}
else if (status.IsSignatureValid)
{
return(FontWeights.Bold);
}
else
{
return(FontWeights.Bold);
}
}
public object Convert(object value, Type targetType,
object parameter, CultureInfo culture)
{
SignatureStatus status = value as SignatureStatus;
if (status == null)
{
return(Brushes.White);
}
if (!status.IsSigned)
{
return(Brushes.White);
}
else if (status.IsSignatureValid)
{
return(Brushes.LimeGreen);
}
else
{
return(Brushes.Red);
}
}
/// <summary>
/// Get the Image icon for the status.
/// </summary>
/// <param name="sigStatus">Requested signature status</param>
/// <param name="certStatus">Requested certificate status</param>
/// <returns>A Image on success (valid status, DrawingBrush found), null
/// otherwise.</returns>
internal static Drawing.Image GetImageFromStatus(
int height,
int width,
SignatureStatus sigStatus,
CertificatePriorityStatus certStatus)
{
// TODO: #1239315 - Mongoose: Restore Dynamic Rendering of Icons from DrawingBrush
// If the signature is okay, but the certificate cannot be trusted then display
// invalid signature image.
if ((sigStatus == SignatureStatus.Valid) && (certStatus != CertificatePriorityStatus.Ok))
{
sigStatus = SignatureStatus.Invalid;
}
string resourceName = string.Format(
CultureInfo.InvariantCulture,
@"{0}_{1}x{2}",
sigStatus.ToString(),
height,
width);
return((Drawing.Image)Resources.ResourceManager.GetObject(resourceName));
}
private static string GetSignatureStatusMessage(SignatureStatus status, uint error, string filePath)
{
string message = null;
string formatSpec = null;
string extension = null;
switch (status)
{
case SignatureStatus.Valid:
formatSpec = MshSignature.MshSignature_Valid;
goto Label_00A4;
case SignatureStatus.UnknownError:
{
Win32Exception exception = new Win32Exception(SecuritySupport.GetIntFromDWORD(error));
message = exception.Message;
goto Label_00A4;
}
case SignatureStatus.NotSigned:
formatSpec = MshSignature.MshSignature_NotSigned;
extension = filePath;
goto Label_00A4;
case SignatureStatus.HashMismatch:
formatSpec = MshSignature.MshSignature_HashMismatch;
extension = filePath;
goto Label_00A4;
case SignatureStatus.NotTrusted:
formatSpec = MshSignature.MshSignature_NotTrusted;
extension = filePath;
goto Label_00A4;
case SignatureStatus.NotSupportedFileFormat:
formatSpec = MshSignature.MshSignature_NotSupportedFileFormat;
extension = System.IO.Path.GetExtension(filePath);
if (string.IsNullOrEmpty(extension))
{
formatSpec = MshSignature.MshSignature_NotSupportedFileFormat_NoExtension;
extension = null;
}
goto Label_00A4;
case SignatureStatus.Incompatible:
if (error != 0x80090008)
{
formatSpec = MshSignature.MshSignature_Incompatible;
break;
}
formatSpec = MshSignature.MshSignature_Incompatible_HashAlgorithm;
break;
default:
goto Label_00A4;
}
extension = filePath;
Label_00A4:
if (message != null)
{
return message;
}
if (extension == null)
{
return formatSpec;
}
return StringUtil.Format(formatSpec, extension);
}
private static string GetSignatureStatusMessage(SignatureStatus status,
DWORD error,
string filePath)
{
string message = null;
string resourceString = null;
string arg = null;
switch (status)
{
case SignatureStatus.Valid:
resourceString = "Signature verified.";
break;
case SignatureStatus.UnknownError:
int intError = SecuritySupport.GetIntFromDWORD(error);
Win32Exception e = new Win32Exception(intError);
message = e.Message;
break;
case SignatureStatus.Incompatible:
if (error == Win32Errors.NTE_BAD_ALGID)
{
resourceString = "The signature cannot be verified because it is incompatible with the current system. The hash algorithm is not valid.";
}
else
{
resourceString = "The signature cannot be verified because it is incompatible with the current system.";
}
arg = filePath;
break;
case SignatureStatus.NotSigned:
resourceString = "The file {0} is not digitally signed. You cannot run this script on the current system. For more information about running scripts and setting execution policy, see about_Execution_Policies at https://go.microsoft.com/fwlink/?LinkID=135170";
arg = filePath;
break;
case SignatureStatus.HashMismatch:
resourceString = "The contents of file {0} might have been changed by an unauthorized user or process, because the hash of the file does not match the hash stored in the digital signature. The script cannot run on the specified system. For more information, run Get-Help about_Signing.";
arg = filePath;
break;
case SignatureStatus.NotTrusted:
resourceString = "File {0} is signed but the signer is not trusted on this system.";
arg = filePath;
break;
case SignatureStatus.NotSupportedFileFormat:
resourceString = "Cannot sign the file because the system does not support signing operations on {0} files.";
arg = System.IO.Path.GetExtension(filePath);
if (string.IsNullOrEmpty(arg))
{
resourceString = "Cannot sign the file because the system does not support signing operations on files that do not have a file name extension.";
arg = null;
}
break;
}
if (message == null)
{
if (arg == null)
{
message = resourceString;
}
else
{
message = string.Format(resourceString, arg);
}
}
return(message);
}
private static string GetSignatureStatusMessage(SignatureStatus status, uint error, string filePath)
{
string message = null;
string formatSpec = null;
string extension = null;
switch (status)
{
case SignatureStatus.Valid:
formatSpec = MshSignature.MshSignature_Valid;
goto Label_00A4;
case SignatureStatus.UnknownError:
{
Win32Exception exception = new Win32Exception(SecuritySupport.GetIntFromDWORD(error));
message = exception.Message;
goto Label_00A4;
}
case SignatureStatus.NotSigned:
formatSpec = MshSignature.MshSignature_NotSigned;
extension = filePath;
goto Label_00A4;
case SignatureStatus.HashMismatch:
formatSpec = MshSignature.MshSignature_HashMismatch;
extension = filePath;
goto Label_00A4;
case SignatureStatus.NotTrusted:
formatSpec = MshSignature.MshSignature_NotTrusted;
extension = filePath;
goto Label_00A4;
case SignatureStatus.NotSupportedFileFormat:
formatSpec = MshSignature.MshSignature_NotSupportedFileFormat;
extension = System.IO.Path.GetExtension(filePath);
if (string.IsNullOrEmpty(extension))
{
formatSpec = MshSignature.MshSignature_NotSupportedFileFormat_NoExtension;
extension = null;
}
goto Label_00A4;
case SignatureStatus.Incompatible:
if (error != 0x80090008)
{
formatSpec = MshSignature.MshSignature_Incompatible;
break;
}
formatSpec = MshSignature.MshSignature_Incompatible_HashAlgorithm;
break;
default:
goto Label_00A4;
}
extension = filePath;
Label_00A4:
if (message != null)
{
return(message);
}
if (extension == null)
{
return(formatSpec);
}
return(StringUtil.Format(formatSpec, extension));
}
internal SignatureInfo(SignatureStatus status, string reason)
{
m_Status = status;
m_Reason = reason;
}
private void Init(string filePath, X509Certificate2 signer, uint error, X509Certificate2 timestamper)
{
this.path = filePath;
this.win32Error = error;
this.signerCert = signer;
this.timeStamperCert = timestamper;
SignatureStatus status = GetSignatureStatusFromWin32Error(error);
this.status = status;
this.statusMessage = GetSignatureStatusMessage(status, error, filePath);
}
private static string GetSignatureStatusMessage(SignatureStatus status,
DWORD error,
string filePath)
{
string message = null;
string resourceString = null;
string arg = null;
switch (status)
{
case SignatureStatus.Valid:
resourceString = MshSignature.MshSignature_Valid;
break;
case SignatureStatus.UnknownError:
int intError = SecuritySupport.GetIntFromDWORD(error);
Win32Exception e = new Win32Exception(intError);
message = e.Message;
break;
case SignatureStatus.Incompatible:
if (error == Win32Errors.NTE_BAD_ALGID)
{
resourceString = MshSignature.MshSignature_Incompatible_HashAlgorithm;
}
else
{
resourceString = MshSignature.MshSignature_Incompatible;
}
arg = filePath;
break;
case SignatureStatus.NotSigned:
resourceString = MshSignature.MshSignature_NotSigned;
arg = filePath;
break;
case SignatureStatus.HashMismatch:
resourceString = MshSignature.MshSignature_HashMismatch;
arg = filePath;
break;
case SignatureStatus.NotTrusted:
resourceString = MshSignature.MshSignature_NotTrusted;
arg = filePath;
break;
case SignatureStatus.NotSupportedFileFormat:
resourceString = MshSignature.MshSignature_NotSupportedFileFormat;
arg = System.IO.Path.GetExtension(filePath);
if (String.IsNullOrEmpty(arg))
{
resourceString = MshSignature.MshSignature_NotSupportedFileFormat_NoExtension;
arg = null;
}
break;
}
if (message == null)
{
if (arg == null)
{
message = resourceString;
}
else
{
message = StringUtil.Format(resourceString, arg);
}
}
return message;
}
public PgpDecryptionTask Run()
{
SignatureStatus = DecryptFile();
return(this);
}
private static string GetSignatureStatusMessage(SignatureStatus status,
DWORD error,
string filePath)
{
string message = null;
string resourceString = null;
string arg = null;
switch (status)
{
case SignatureStatus.Valid:
resourceString = MshSignature.MshSignature_Valid;
break;
case SignatureStatus.UnknownError:
int intError = SecuritySupport.GetIntFromDWORD(error);
Win32Exception e = new Win32Exception(intError);
message = e.Message;
break;
case SignatureStatus.Incompatible:
if (error == Win32Errors.NTE_BAD_ALGID)
{
resourceString = MshSignature.MshSignature_Incompatible_HashAlgorithm;
}
else
{
resourceString = MshSignature.MshSignature_Incompatible;
}
arg = filePath;
break;
case SignatureStatus.NotSigned:
resourceString = MshSignature.MshSignature_NotSigned;
arg = filePath;
break;
case SignatureStatus.HashMismatch:
resourceString = MshSignature.MshSignature_HashMismatch;
arg = filePath;
break;
case SignatureStatus.NotTrusted:
resourceString = MshSignature.MshSignature_NotTrusted;
arg = filePath;
break;
case SignatureStatus.NotSupportedFileFormat:
resourceString = MshSignature.MshSignature_NotSupportedFileFormat;
arg = System.IO.Path.GetExtension(filePath);
if (string.IsNullOrEmpty(arg))
{
resourceString = MshSignature.MshSignature_NotSupportedFileFormat_NoExtension;
arg = null;
}
break;
}
if (message == null)
{
if (arg == null)
{
message = resourceString;
}
else
{
message = StringUtil.Format(resourceString, arg);
}
}
return(message);
}
private static string GetSignatureStatusMessage(
SignatureStatus status,
uint error,
string filePath)
{
using (Signature.tracer.TraceMethod())
{
string str1 = (string)null;
string resourceId = (string)null;
string str2 = (string)null;
switch (status)
{
case SignatureStatus.Valid:
resourceId = "MshSignature_Valid";
break;
case SignatureStatus.UnknownError:
str1 = new Win32Exception(SecuritySupport.GetIntFromDWORD(error)).Message;
break;
case SignatureStatus.NotSigned:
resourceId = "MshSignature_NotSigned";
str2 = filePath;
break;
case SignatureStatus.HashMismatch:
resourceId = "MshSignature_HashMismatch";
str2 = filePath;
break;
case SignatureStatus.NotTrusted:
resourceId = "MshSignature_NotTrusted";
str2 = filePath;
break;
case SignatureStatus.NotSupportedFileFormat:
resourceId = "MshSignature_NotSupportedFileFormat";
str2 = System.IO.Path.GetExtension(filePath);
if (string.IsNullOrEmpty(str2))
{
resourceId = "MshSignature_NotSupportedFileFormat_NoExtension";
str2 = (string)null;
break;
}
break;
case SignatureStatus.Incompatible:
resourceId = error != 2148073480U ? "MshSignature_Incompatible" : "MshSignature_Incompatible_HashAlgorithm";
str2 = filePath;
break;
}
if (str1 == null)
{
if (str2 == null)
{
str1 = ResourceManagerCache.GetResourceString("MshSignature", resourceId);
}
else
{
str1 = ResourceManagerCache.FormatResourceString("MshSignature", resourceId, (object)str2);
}
}
return(str1);
}
}
private void Init(string filePath,
X509Certificate2 signer,
DWORD error,
X509Certificate2 timestamper)
{
_path = filePath;
_win32Error = error;
_signerCert = signer;
_timeStamperCert = timestamper;
SignatureType = SignatureType.None;
SignatureStatus isc =
GetSignatureStatusFromWin32Error(error);
_status = isc;
_statusMessage = GetSignatureStatusMessage(isc,
error,
filePath);
}
internal static KeyValuePair <SignerIdentifier, SignatureStatus> ExpectedSignerStatus(SignerIdentifier signer, SignatureStatus status)
{
return(new KeyValuePair <SignerIdentifier, SignatureStatus>(signer, status));
}
