public void TrustPackageWithUpdate()
{
string package = Path.Combine(DataDirectory, "Package", "signedpackage.zip");
string temp = Path.Combine(TempDirectory, "signedpackage.zip");
string keyFile = Path.Combine(DataDirectory, "Key", "openiiottest-private.asc");
string key = File.ReadAllText(keyFile);
string passphrase = File.ReadAllText(Path.Combine(DataDirectory, "Key", "openiiottest-passphrase.txt"));
string publicKey = File.ReadAllText(Path.Combine(DataDirectory, "Key", "openiiottest-public.asc"));
File.Copy(package, temp);
Truster.Updated += Truster_Updated;
Exception ex = Record.Exception(() => Truster.TrustPackage(temp, key, passphrase));
Assert.Null(ex);
bool verified = false;
PackageVerifier verifier = new PackageVerifier();
verifier.TrustPGPPublicKey = publicKey;
ex = Record.Exception(() => verified = verifier.VerifyPackage(temp));
Assert.Null(ex);
Assert.True(verified);
}
/// <summary>
/// Retrieves the <see cref="PackageVerification"/> for the specified <paramref name="packageArchive"/>.
/// </summary>
/// <param name="packageArchive">The <see cref="IPackageArchive"/> instance to verify.</param>
/// <returns>The <see cref="PackageVerification"/> result.</returns>
private PackageVerification GetPackageArchiveVerification(IPackageArchive packageArchive)
{
PackageVerification retVal;
try
{
PackageVerifier.Updated += PackageVerifierUpdated;
bool verification = PackageVerifier.VerifyPackage(packageArchive.FileName);
if (verification)
{
retVal = PackageVerification.Verified;
}
else
{
retVal = PackageVerification.Refuted;
}
}
catch (Exception ex)
{
logger.Debug($"Failed to verifiy Package Archive '{packageArchive.FQN}': {ex.Message}");
retVal = PackageVerification.Refuted;
}
finally
{
PackageVerifier.Updated -= PackageVerifierUpdated;
}
return(retVal);
}
/// <summary>
/// Initializes a new instance of the <see cref="PackageVerifierTests"/> class.
/// </summary>
public PackageVerifierTests()
{
Verifier = new PackageVerifier();
Uri codeBaseUri = new Uri(System.Reflection.Assembly.GetExecutingAssembly().CodeBase);
string codeBasePath = Uri.UnescapeDataString(codeBaseUri.AbsolutePath);
string dirPath = Path.GetDirectoryName(codeBasePath);
DataDirectory = Path.Combine(dirPath, "Data");
TempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(TempDirectory);
}
public void CreatePackageNoChecksum()
{
string manifest = Path.Combine(DataDirectory, "Manifest", "nochecksummanifest.json");
string package = Path.Combine(TempDirectory, "package.zip");
Exception ex = Record.Exception(() => Creator.CreatePackage(PayloadDirectory, manifest, package));
Assert.Null(ex);
bool verified = false;
ex = Record.Exception(() => verified = new PackageVerifier().VerifyPackage(package));
Assert.Null(ex);
Assert.True(verified);
}
public void CreatePackagePackageExistsOverwrite()
{
string manifest = Path.Combine(DataDirectory, "Manifest", "manifest.json");
string package = Path.Combine(TempDirectory, "package.zip");
File.WriteAllText(package, string.Empty);
Exception ex = Record.Exception(() => Creator.CreatePackage(PayloadDirectory, manifest, package, true));
Assert.Null(ex);
bool verified = false;
ex = Record.Exception(() => verified = new PackageVerifier().VerifyPackage(package));
Assert.Null(ex);
Assert.True(verified);
}
/// <summary>
/// Verifies the specified <paramref name="packageArchive"/> using the specified <paramref name="publicKey"/>.
/// </summary>
/// <param name="packageArchive">The <see cref="IPackageArchive"/> to verify.</param>
/// <param name="publicKey">The PGP Public Key with which to verify the package.</param>
/// <returns>
/// A Result containing the result of the operation and a value indicating whether the <see cref="IPackageArchive"/> is valid.
/// </returns>
public IResult <bool> VerifyPackageArchive(IPackageArchive packageArchive, string publicKey)
{
Guid guid = logger.EnterMethod(xLogger.Params(packageArchive, publicKey), true);
logger.Info($"Verifying Package '{packageArchive?.FQN}'...");
IResult <bool> retVal = new Result <bool>();
if (packageArchive == default(IPackageArchive))
{
retVal.AddError($"The specified Package Archive is null.");
}
else if (string.IsNullOrEmpty(packageArchive.FileName))
{
retVal.AddError($"The specified Package Archive contains a null or empty FileName.");
}
else if (!Platform.FileExists(packageArchive.FileName))
{
retVal.AddError($"The specified Package Archive file '{packageArchive.FileName}' can not be found.");
}
else
{
PackageVerifier verifier = new PackageVerifier();
verifier.Updated += (sender, e) =>
{
logger.Debug($" PackageVerifier: {e.Message}");
retVal.AddInfo(e.Message);
};
try
{
retVal.ReturnValue = verifier.VerifyPackage(packageArchive.FileName, publicKey);
}
catch (Exception ex)
{
logger.Exception(LogLevel.Debug, ex);
retVal.AddError(ex.Message);
}
}
retVal.LogResult(logger);
logger.ExitMethod(guid);
return(retVal);
}
public void CreateSignedPackage()
{
string manifest = Path.Combine(DataDirectory, "Manifest", "manifest.json");
string package = Path.Combine(TempDirectory, "signedpackage.zip");
string privateKeyFile = Path.Combine(DataDirectory, "Key", "openiiottest-private.asc");
string privateKey = File.ReadAllText(privateKeyFile);
string passphrase = File.ReadAllText(Path.Combine(DataDirectory, "Key", "openiiottest-passphrase.txt"));
string keybaseUsername = "******";
Exception ex = Record.Exception(() => Creator.CreatePackage(PayloadDirectory, manifest, package, true, privateKey, passphrase, keybaseUsername));
Assert.Null(ex);
bool verified = false;
ex = Record.Exception(() => verified = new PackageVerifier().VerifyPackage(package));
Assert.Null(ex);
Assert.True(verified);
}
/// <summary>
/// Processes the desired command with the arguments specified in the command line arguments from Main().
/// </summary>
/// <param name="args">
/// The optional command line arguments, used to override the arguments with which the application was started.
/// </param>
public static void Process(string args = "")
{
if (args != string.Empty)
{
Arguments.Populate(args);
}
string command = string.Empty;
try
{
if (Operands.Count > 1)
{
command = Operands[1].ToLower();
}
if (command == "manifest")
{
ManifestGenerator generator = new ManifestGenerator();
generator.Updated += Update;
PackageManifest manifest = generator.GenerateManifest(Directory, HashFiles, ManifestFile);
if (string.IsNullOrEmpty(ManifestFile) && manifest != default(PackageManifest))
{
Console.WriteLine(manifest.ToJson());
}
}
else if (command == "extract-manifest")
{
ManifestExtractor extractor = new ManifestExtractor();
extractor.Updated += Update;
PackageManifest manifest = extractor.ExtractManifest(PackageFile, ManifestFile);
if (string.IsNullOrEmpty(ManifestFile) && manifest != default(PackageManifest))
{
Console.WriteLine(manifest.ToJson());
}
}
else if (command == "package")
{
PackageCreator creator = new PackageCreator();
creator.Updated += Update;
string privateKey = string.Empty;
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
privateKey = File.ReadAllText(PrivateKeyFile);
}
creator.CreatePackage(Directory, ManifestFile, PackageFile, SignPackage, privateKey, Passphrase, KeybaseUsername);
}
else if (command == "extract-package")
{
PackageExtractor extractor = new PackageExtractor();
extractor.Updated += Update;
string publicKey = string.Empty;
if (!string.IsNullOrEmpty(PublicKeyFile))
{
publicKey = File.ReadAllText(PublicKeyFile);
}
extractor.ExtractPackage(PackageFile, Directory, publicKey, Overwrite, SkipVerification);
}
else if (command == "trust")
{
PackageTruster truster = new PackageTruster();
truster.Updated += Update;
truster.TrustPackage(PackageFile, File.ReadAllText(PrivateKeyFile), Passphrase);
}
else if (command == "verify")
{
PackageVerifier verifier = new PackageVerifier();
verifier.Updated += Update;
string publicKey = string.Empty;
if (!string.IsNullOrEmpty(PublicKeyFile))
{
publicKey = File.ReadAllText(PublicKeyFile);
}
verifier.VerifyPackage(PackageFile, publicKey);
}
else
{
HelpPrinter.PrintHelp(Operands.Count > 2 ? Operands[2] : default(string));
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
}
