private static void ReadPackageJsonFile(string item)
{
dynamic o1 = JObject.Parse(File.ReadAllText(item));
IList <JToken> jsonDevDep = o1["devDependencies"];
if (jsonDevDep != null)
{
foreach (var jToken in jsonDevDep)
{
var p = (JProperty)jToken;
FactoryPackages.AddPackage(new NugetPackage {
Name = p.Name, Version = p.Value.ToString(), UniqueName = "devDependencies", PackageType = PackageType.Npm
});
}
}
IList <JToken> jsonDep = o1["dependencies"];
if (jsonDep != null)
{
foreach (var jToken in jsonDep)
{
var p = (JProperty)jToken;
FactoryPackages.AddPackage(new NugetPackage {
Name = p.Name, Version = p.Value.ToString(), UniqueName = "dependencies", PackageType = PackageType.Npm
});
}
}
}
public static async Task <List <OssIndexResponse> > CheckOSSPackage()
{
List <OssIndexResponse> objResponse = null;
foreach (var package in FactoryPackages.GetPackages())
{
objResponse = new List <OssIndexResponse>();
string packageManager = string.Empty;
switch (package.PackageType)
{
case PackageType.Npm:
packageManager = "npm";
break;
case PackageType.Nuget:
packageManager = "nuget";
break;
default:
break;
}
if (packageManager != String.Empty)
{
objResponse = await CheckVulnerabilityOnPackage(package, packageManager);
}
}
return(objResponse);
}
private static void SavePackagesToDisc()
{
if (!Directory.Exists("testresults"))
{
Directory.CreateDirectory("testresults");
}
using (StreamWriter file = File.CreateText(@"testresults\allPackages.json"))
{
Console.WriteLine($"Saving result to json {file.ToString()}");
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(file, FactoryPackages.GetPackages());
//If this is used by Azure DevOps or TFS it will upload result to release
Console.WriteLine($"##vso[task.uploadfile]{Path.GetFullPath("testresults/allPackages.json")}");
}
}
public static async Task GetNugetPackageInformation()
{
IPackage pack;
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository("https://packages.nuget.org/api/v2");
await Task.Run(() =>
{
foreach (var item in FactoryPackages.GetPackages().FindAll(o => o.PackageType == PackageType.Nuget))
{
pack = repo.FindPackage(item.Name, SemanticVersion.Parse(item.Version));
item.NugetExtendedPackageInformation = pack;
Console.WriteLine("Get Nuget Extended Package Information on " + item.Name + " " + item.Version);
}
});
}
static void Main(string[] args)
{
PathToSearch = ConfigurationManager.AppSettings["SourceCodePath"];
SaveJsonPath = ConfigurationManager.AppSettings["SaveJsonPath"];
Console.WriteLine($"Searching directory: {PathToSearch}");
Console.WriteLine($"Saving result to: {SaveJsonPath}");
RunAsync().GetAwaiter().GetResult();
Console.WriteLine($"Found {FactoryPackages.GetPackages().Count} packages");
//var obj = JsonConvert.SerializeObject(FactoryPackages.GetPackages(), new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto });
//File.WriteAllText(SaveJsonPath, obj);
SavePackagesToDisc();
foreach (var item in FactoryPackages.GetPackages().OrderBy(x => x.Name))
{
Console.WriteLine(item.PackageType + "|" + item.Name + " " + item.Version + "|" + item.UniqueName);
}
}
private static async Task SearchNugetPackageReferences(string file)
{
await Task.Run(() =>
{
XmlDocument xDoc = new XmlDocument();
using (var fs = new FileStream(file, FileMode.Open, FileAccess.Read))
{
xDoc.Load(fs);
// Load Xml
var nodes = xDoc.GetElementsByTagName("PackageReference");
foreach (XmlNode node in nodes)
{
if (node.Attributes != null && (node.Attributes["Version"] != null || node.Attributes["version"] != null))
{
string packageVersion;
if (node.Attributes["Version"] == null)
{
packageVersion = node.Attributes["version"].Value;
}
else
{
packageVersion = node.Attributes["Version"].Value;
}
PackageMagic package = new NugetPackage {
Name = node.Attributes["Include"].Value, Version = packageVersion, UniqueName = "PackageReference", PackageType = PackageType.Nuget
};
FactoryPackages.AddPackage(package);
}
else
{
//Console.WriteLine(file + "No version found in PackageReference");
}
}
}
});
}
public static async Task SearchForPackagesConfig(string projectDirectory)
{
Console.WriteLine($"Searching for Packages Config in {projectDirectory}");
await Task.Run(() =>
{
string[] packagesConfig = Directory.GetFiles(projectDirectory, "packages.config", SearchOption.AllDirectories);
Console.WriteLine($"Found {packagesConfig.Count()} packages.config files");
foreach (var packConfig in packagesConfig)
{
var directoryName = Path.GetDirectoryName(packConfig);
string foundCsProjFile = "";
if (directoryName != null)
{
string[] proj = Directory.GetFiles(directoryName, patternPackagesConfig, SearchOption.TopDirectoryOnly);
if (proj.Length > 0)
{
foundCsProjFile = proj[0];
}
else
{
foundCsProjFile = "No csProj file found " + packConfig;
}
}
var file = new PackageReferenceFile(packConfig);
foreach (PackageReference packageReference in file.GetPackageReferences())
{
PackageMagic package = new NugetPackage {
Name = packageReference.Id, Version = packageReference.Version.ToNormalizedString(), UniqueName = "PackageConfig", PackageType = PackageType.Nuget
};
FactoryPackages.AddPackage(package);
}
}
});
}
public static async Task <JObject> RunNpmView()
{
JObject output = null;
try
{
foreach (var package in FactoryPackages.GetPackages().FindAll(o => o.PackageType == PackageType.Npm))
{
var packageToCheck = $"{package.Name}@{package.Version}";
//return output;
var psiNpmRunDist = new ProcessStartInfo
{
FileName = NpmPath,
Arguments = $"view {packageToCheck}",
RedirectStandardInput = true,
UseShellExecute = false,
RedirectStandardOutput = true,
StandardOutputEncoding = Encoding.UTF8
};
await Task.Run(() =>
{
var pNpmRunDist = Process.Start(psiNpmRunDist);
if (pNpmRunDist != null)
{
try
{
output = JObject.Parse(pNpmRunDist.StandardOutput.ReadToEnd());
}
catch (Exception)
{
output = null;
}
pNpmRunDist.StandardInput.WriteLine("npm run view & exit");
pNpmRunDist.WaitForExit();
}
});
}
}
catch (Exception e)
{
output = null;
}
try
{
dynamic outputDynamic = output;
var license = output.GetValue("license");
//var licenses = output.GetValue("licenses");
//if (licenses != null)
//{
if (license == null)
{
foreach (var item in output)
{
if (item.Key.ToLower() == "licenses")
{
foreach (JObject val in item.Value.Children())
{
foreach (var d in val)
{
Console.WriteLine($"{d.Key} {d.Value.ToString()}");
}
}
}
}
}
// Utils.LogMessages(licenses.First.ToString());
//}
}
catch (Exception ex)
{
}
return(output);
}
public static async Task RunNpmViewCheckLicense()
{
JObject output = null;
string license = String.Empty;
await Task.Run(() =>
{
foreach (var package in FactoryPackages.GetPackages().FindAll(o => o.PackageType == PackageType.Npm))
{
try
{
var packageToCheck = $"{package.Name}@{package.Version}";
//return output;
var psiNpmRunDist = new ProcessStartInfo
{
FileName = NpmPath,
Arguments = $"view {packageToCheck}",
RedirectStandardInput = true,
UseShellExecute = false,
RedirectStandardOutput = true,
StandardOutputEncoding = Encoding.UTF8
};
var pNpmRunDist = Process.Start(psiNpmRunDist);
if (pNpmRunDist != null)
{
try
{
output = JObject.Parse(pNpmRunDist.StandardOutput.ReadToEnd());
}
catch (Exception)
{
output = null;
}
pNpmRunDist.StandardInput.WriteLine("npm run view & exit");
pNpmRunDist.WaitForExit();
}
}
catch (Exception e)
{
output = null;
}
try
{
JToken licenseToken = output.GetValue("license");
if (licenseToken != null)
{
license = licenseToken.ToString();
}
if (license == null)
{
foreach (var item in output)
{
if (item.Key.ToLower() == "licenses")
{
foreach (JObject val in item.Value.Children())
{
foreach (var d in val)
{
if (d.Key == "type")
{
license = d.Value.ToString();
break;
}
}
}
}
}
}
}
catch (Exception ex)
{
}
if (license != null)
{
Console.WriteLine("Npm licensetype " + license);
package.LicenseType = license;
}
}
});
//return license;
}
