///////////////////////////////////////////////////////////////////////
private static bool MatchCertificatePublicKey(
X509Certificate certificate,
byte[] publicKey
)
{
//
// NOTE: Make sure the certificate public key matches what we
// expect it to be for our own software updates.
//
if (certificate != null)
{
byte[] certificatePublicKey = certificate.GetPublicKey();
if ((certificatePublicKey != null) &&
(certificatePublicKey.Length > 0))
{
if ((publicKey != null) && (publicKey.Length > 0))
{
return(GenericOps <byte> .Equals(
certificatePublicKey, publicKey));
}
}
}
return(false);
}
///////////////////////////////////////////////////////////////////////////////////////////////
public static ReturnCode Combine(
IList <IList <StringBuilder> > lists, /* in */
ref IList <StringBuilder> list, /* in, out */
ref Result error /* out */
)
{
if (lists == null)
{
error = "invalid list of lists";
return(ReturnCode.Error);
}
if (lists.Count == 0)
{
error = "no lists in list";
return(ReturnCode.Error);
}
IList <StringBuilder> list1 = lists[0];
if (lists.Count > 1)
{
for (int index = 1; index < lists.Count; index++)
{
IList <StringBuilder> list2 = lists[index];
IList <StringBuilder> list3 = null;
if (Combine(
list1, list2, ref list3, ref error) != ReturnCode.Ok)
{
return(ReturnCode.Error);
}
list1 = list3;
}
}
if (list != null)
{
GenericOps <StringBuilder> .AddRange(list, list1);
}
else
{
list = new List <StringBuilder>(list1);
}
return(ReturnCode.Ok);
}
///////////////////////////////////////////////////////////////////////
public ReturnCode DumpCommands(
ref Result result
)
{
CheckDisposed();
QueueList <string, string> queue = GetQueue();
if (queue == null)
{
result = "debugger command queue not available";
return(ReturnCode.Error);
}
result = GenericOps <string> .ListToString(
queue.Values, ToStringFlags.None, Characters.Space.ToString(),
null, false);
return(ReturnCode.Ok);
}
///////////////////////////////////////////////////////////////////////
public static bool IsDefaultPublicKeyToken(
byte[] publicKeyToken
)
{
if (publicKeyToken == null)
{
return(true);
}
byte[] defaultPublicKeyToken = PublicKeyToken.Default;
if (defaultPublicKeyToken == null)
{
return(false);
}
if (GenericOps <byte> .Equals(publicKeyToken, defaultPublicKeyToken))
{
return(true);
}
return(false);
}
///////////////////////////////////////////////////////////////////////
#region Public Parsing Methods
public static bool ParseData(
Configuration configuration,
string text,
ref IEqualityComparer <Configuration> comparer,
ref IDictionary <Configuration, Release> releases,
ref int[] protocolCounts,
ref string error
)
{
if (configuration == null)
{
error = "Invalid configuration.";
return(false);
}
if (text == null)
{
error = "Invalid release data.";
return(false);
}
//
// NOTE: This will contain the counts of the protocols encountered
// while parsing the release data (e.g. "1", "2", "3", or
// other).
//
if (protocolCounts == null)
{
protocolCounts = new int[4];
}
int parseCount = 0;
string[] lines = text.Split(Line.Separators);
for (int lineIndex = 0; lineIndex < lines.Length; lineIndex++)
{
string line = lines[lineIndex];
if (line == null)
{
continue;
}
line = line.Trim(Characters.Space);
if (line.Length == 0)
{
continue;
}
if (GenericOps <char> .Contains(Line.Comments, line[0]))
{
continue;
}
Release release = ParseLine(
configuration, NextId(), lineIndex, line, ref error);
if (release != null)
{
/* IGNORED */
release.MaybeUseDownloadBaseUri(configuration.Assembly);
parseCount++;
if (release.ProtocolId != null)
{
switch (release.ProtocolId)
{
case Protocol.Build: /* NOTE: Release build. */
{
protocolCounts[0]++;
break;
}
case Protocol.Script: /* NOTE: Update script. */
{
protocolCounts[1]++;
break;
}
case Protocol.Self: /* NOTE: Updater itself. */
{
protocolCounts[2]++;
break;
}
default: /* NOTE: Other and/or unknown. */
{
protocolCounts[3]++;
break;
}
}
}
if (comparer == null)
{
comparer = new _Comparers._Configuration(
StringComparison.Ordinal, Defaults.Encoding);
}
if (releases == null)
{
releases = new Dictionary <Configuration, Release>(
comparer);
}
Configuration releaseConfiguration =
Configuration.CreateFrom(release);
if (releaseConfiguration == null)
{
Trace(configuration, String.Format(
"Could not create configuration from parsed " +
"release {0} on line #{1}, using the " +
"pre-existing one...", FormatOps.ForDisplay(
release), lineIndex), TraceCategory);
releaseConfiguration = configuration;
}
releases[releaseConfiguration] = release;
}
}
return((parseCount > 0) ? true : false);
}
///////////////////////////////////////////////////////////////////////
public bool VerifyFile(
Configuration configuration,
string fileName,
bool strongName
)
{
try
{
if (!File.Exists(fileName))
{
Trace(configuration, String.Format(
"File \"{0}\" does not exist.", fileName),
TraceCategory);
return(false);
}
///////////////////////////////////////////////////////////////
string error = null;
if (strongName)
{
#if NATIVE && WINDOWS
if (VersionOps.IsWindowsOperatingSystem() &&
!StrongNameEx.IsStrongNameSigned(
configuration, fileName, true, ref error))
{
Trace(configuration, String.Format(
"Assembly in file \"{0}\" is not signed.",
fileName), TraceCategory);
Trace(configuration, String.Format(
"Assembly signature error: {0}", error),
TraceCategory);
return(false);
}
#endif
///////////////////////////////////////////////////////////
AssemblyName assemblyName =
AssemblyName.GetAssemblyName(fileName);
if (assemblyName == null)
{
Trace(configuration, String.Format(
"Assembly in file \"{0}\" has no name.", fileName),
TraceCategory);
return(false);
}
byte[] filePublicKeyToken = assemblyName.GetPublicKeyToken();
if (!GenericOps <byte> .Equals(
filePublicKeyToken, publicKeyToken))
{
Trace(configuration, String.Format(
"Assembly in file \"{0}\" has incorrect " +
"public key token \"{1}\".", fileName,
FormatOps.ToHexString(filePublicKeyToken)),
TraceCategory);
return(false);
}
}
///////////////////////////////////////////////////////////////
byte[] hash = null;
if (FileOps.Hash(
configuration, "md5", fileName, ref hash, ref error))
{
if (!GenericOps <byte> .Equals(hash, md5Hash))
{
Trace(configuration, String.Format(
"File \"{0}\" MD5 hash mismatch, got: {1}.",
fileName, FormatOps.ToHexString(hash)),
TraceCategory);
return(false);
}
}
else
{
Trace(configuration, error, TraceCategory);
return(false);
}
///////////////////////////////////////////////////////////////
if (FileOps.Hash(
configuration, "sha1", fileName, ref hash, ref error))
{
if (!GenericOps <byte> .Equals(hash, sha1Hash))
{
Trace(configuration, String.Format(
"File \"{0}\" SHA1 hash mismatch, got: {1}.",
fileName, FormatOps.ToHexString(hash)),
TraceCategory);
return(false);
}
}
else
{
Trace(configuration, error, TraceCategory);
return(false);
}
///////////////////////////////////////////////////////////////
if (FileOps.Hash(
configuration, "sha512", fileName, ref hash, ref error))
{
if (!GenericOps <byte> .Equals(hash, sha512Hash))
{
Trace(configuration, String.Format(
"File \"{0}\" SHA512 hash mismatch, got: {1}.",
fileName, FormatOps.ToHexString(hash)),
TraceCategory);
return(false);
}
}
else
{
Trace(configuration, error, TraceCategory);
return(false);
}
return(true);
}
catch (Exception e)
{
Trace(configuration, e, TraceCategory);
}
return(false);
}
///////////////////////////////////////////////////////////////////////////////////////////////
private static ReturnCode Combine(
IList <StringBuilder> list1, /* in */
IList <StringBuilder> list2, /* in */
ref IList <StringBuilder> list3, /* in, out */
ref Result error /* out */
)
{
if (list1 == null)
{
if (list2 == null)
{
error = "cannot combine, neither list is valid";
return(ReturnCode.Error);
}
if (list3 != null)
{
GenericOps <StringBuilder> .AddRange(list3, list2);
}
else
{
list3 = new List <StringBuilder>(list2);
}
}
else if (list2 == null)
{
if (list3 != null)
{
GenericOps <StringBuilder> .AddRange(list3, list1);
}
else
{
list3 = new List <StringBuilder>(list1);
}
}
else
{
if ((list1.Count > 0) || (list2.Count > 0))
{
if (list3 == null)
{
list3 = new List <StringBuilder>();
}
}
foreach (StringBuilder element1 in list1)
{
foreach (StringBuilder element2 in list2)
{
int capacity = 0;
if (element1 != null)
{
capacity += element1.Length;
}
if (element2 != null)
{
capacity += element2.Length;
}
StringBuilder element3 = StringOps.NewStringBuilder(
capacity);
element3.Append(element1);
element3.Append(element2);
list3.Add(element3);
}
}
}
return(ReturnCode.Ok);
}
///////////////////////////////////////////////////////////////////////
public static bool IsStrongNameSigned(
Assembly assembly,
ref byte[] publicKeyToken,
ref string error
)
{
if (assembly == null)
{
error = "assembly is invalid";
return(false);
}
AssemblyName assemblyName = assembly.GetName();
if (assemblyName == null)
{
error = "assembly has invalid name";
return(false);
}
byte[] publicKey = assemblyName.GetPublicKey();
if (publicKey == null)
{
error = "assembly has invalid public key";
return(false);
}
Evidence evidence = assembly.Evidence;
if (evidence == null)
{
error = "assembly has invalid evidence";
return(false);
}
IEnumerator enumerator = evidence.GetHostEnumerator();
if (enumerator == null)
{
error = "assembly has invalid evidence enumerator";
return(false);
}
while (enumerator.MoveNext())
{
StrongName strongName = enumerator.Current as StrongName;
if (strongName == null)
{
continue;
}
StrongNamePublicKeyBlob strongNamePublicKey =
strongName.PublicKey;
if (strongNamePublicKey == null)
{
error = "assembly strong name has invalid public key";
return(false);
}
if (GenericOps <byte> .Equals(ParseOps.HexString(
strongNamePublicKey.ToString()), publicKey))
{
publicKeyToken = assemblyName.GetPublicKeyToken();
if (publicKeyToken == null)
{
error = "assembly has invalid public key token";
return(false);
}
return(true);
}
}
error = "assembly is not signed";
return(false);
}
