/// <summary>
/// Validates active licenses of the licensee. See NetLicensingAPI for details:
/// https://www.labs64.de/confluence/display/NLICPUB/Licensee+Services#LicenseeServices-Validatelicensee
/// </summary>
public static ValidationResult validate(Context context, String number, ValidationParameters validationParameters)
{
Dictionary <String, String> parameters = new Dictionary <String, String> ();
if (!String.IsNullOrEmpty(validationParameters.getProductNumber()))
{
parameters.Add(Constants.Product.PRODUCT_NUMBER, validationParameters.getProductNumber());
}
if (!String.IsNullOrEmpty(validationParameters.getLicenseeName()))
{
parameters.Add(Constants.Licensee.PROP_LICENSEE_NAME, validationParameters.getLicenseeName());
}
if (!String.IsNullOrEmpty(validationParameters.getLicenseeSecret()))
{
parameters.Add(Constants.Licensee.PROP_LICENSEE_SECRET, validationParameters.getLicenseeSecret());
}
int pmIndex = 0;
foreach (KeyValuePair <String, Dictionary <String, String> > productModuleValidationParams in validationParameters.getParameters())
{
parameters.Add(Constants.ProductModule.PRODUCT_MODULE_NUMBER + pmIndex, productModuleValidationParams.Key);
foreach (KeyValuePair <String, String> param in productModuleValidationParams.Value)
{
parameters.Add(param.Key + pmIndex, param.Value);
}
pmIndex++;
}
netlicensing output = NetLicensingAPI.request(context, NetLicensingAPI.Method.POST, Constants.Licensee.ENDPOINT_PATH + "/" + number + "/" + Constants.Licensee.ENDPOINT_PATH_VALIDATE, parameters);
return(new ValidationResult(output));
}
/// <summary>
/// Validates active licenses of the licensee. See NetLicensingAPI for details:
/// https://netlicensing.io/wiki/licensee-services#validate-licensee
/// </summary>
public static ValidationResult validate(Context context, String number, ValidationParameters validationParameters)
{
Dictionary <String, String> parameters = new Dictionary <String, String> ();
if (!String.IsNullOrEmpty(validationParameters.getProductNumber()))
{
parameters.Add(Constants.Product.PRODUCT_NUMBER, validationParameters.getProductNumber());
}
if (!String.IsNullOrEmpty(validationParameters.getLicenseeName()))
{
parameters.Add(Constants.Licensee.PROP_LICENSEE_NAME, validationParameters.getLicenseeName());
}
#pragma warning disable 0618
// This section is only left to verify backwards compatibility.
// Don't use LicenseeSecret, use Node-Locked licensing model instead.
if (!String.IsNullOrEmpty(validationParameters.getLicenseeSecret()))
{
parameters.Add(Constants.Licensee.PROP_LICENSEE_SECRET, validationParameters.getLicenseeSecret());
}
#pragma warning restore 0618
int pmIndex = 0;
foreach (KeyValuePair <String, Dictionary <String, String> > productModuleValidationParams in validationParameters.getParameters())
{
parameters.Add(Constants.ProductModule.PRODUCT_MODULE_NUMBER + pmIndex, productModuleValidationParams.Key);
foreach (KeyValuePair <String, String> param in productModuleValidationParams.Value)
{
parameters.Add(param.Key + pmIndex, param.Value);
}
pmIndex++;
}
netlicensing output = NetLicensingAPI.request(context, NetLicensingAPI.Method.POST, Constants.Licensee.ENDPOINT_PATH + "/" + number + "/" + Constants.Licensee.ENDPOINT_PATH_VALIDATE, parameters);
return(new ValidationResult(output));
}
public ModelClientValidationCompareStringsRule(string errorMessage, string otherProperty, bool ignoreCase)
{
ErrorMessage = errorMessage; //The error message to display when invalid. Note we used FormatErrorMessage above to ensure this matches the server-side result.
ValidationType = "comparestrings"; //Choose a unique name for your validator on the client side. This doesn't map to anything on the server side.
ValidationParameters.Add("otherprop", otherProperty); //Pass the name of the property to compare to
ValidationParameters.Add("ignorecase", ignoreCase.ToString().ToLower()); //And whether to ignore casing
}
public CompareSendDateTimeWithNowValidationRule(int compareMinutes, DateTimeCompareTo compareState, string errorMessage)
{
ErrorMessage = errorMessage;
ValidationParameters.Add("compareminutes", compareMinutes);
ValidationParameters.Add("comparestate", compareState.ToString());
ValidationType = "comparesenddatetimewithnow";
}
static string CheckForErrorsGuitarHero3(Song song, ValidationParameters validationParams, ref bool hasErrors)
{
const int SECTION_LIMIT = 100;
StringBuilder sb = new StringBuilder();
sb.AppendLine("Guitar Hero 3 validation report: ");
bool hasErrorsLocal = false;
// Check that we haven't exceeded the section count in GH3
if (song.sections.Count > 100)
{
hasErrorsLocal |= true;
sb.AppendFormat("\tSection count has exceeded limit of {0} sections\n", SECTION_LIMIT);
sb.AppendFormat("\tAffected sections:\n");
for (int i = SECTION_LIMIT; i < song.sections.Count; ++i)
{
Section section = song.sections[i];
sb.AppendFormat("\t\tPosition = {0}, Title = {1}\n", section.tick, section.title);
}
}
if (!hasErrorsLocal)
{
sb.AppendLine("\tNo errors detected");
}
hasErrors |= hasErrorsLocal;
return(sb.ToString());
}
public DateOfBirthClientValidationRule(string errorMessage, long min, long max)
{
ErrorMessage = errorMessage;
ValidationType = "dateofbirth";
ValidationParameters.Add("min", min.ToString());
ValidationParameters.Add("max", max.ToString());
}
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
{
if (TraceEventSession.IsElevated() != true)
{
yield return(new ValidationError(true, "Must be elevated (Admin) to use Hardware Counters to use ETW Kernel Session."));
}
var availableCpuCounters = TraceEventProfileSources.GetInfo();
foreach (var benchmark in validationParameters.Benchmarks
.Where(benchmark => !benchmark.Job.Diagnoser.HardwareCounters.IsNullOrEmpty()))
{
foreach (var hardwareCounter in benchmark.Job.Diagnoser.HardwareCounters)
{
if (!EtwTranslations.TryGetValue(hardwareCounter, out var counterName))
{
yield return(new ValidationError(true, $"Counter {hardwareCounter} not recognized. Please make sure that you are using counter supported on Windows", benchmark));
}
if (!availableCpuCounters.ContainsKey(counterName))
{
yield return(new ValidationError(true, $"The counter {counterName} is not available. Please make sure you are Windows 8+ without Hyper-V", benchmark));
}
}
}
}
public static void CheckValidationResult(TestContext ctx, ValidationParameters parameters,
X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
{
if (parameters.ExpectedExtraStore != null && ctx.Expect(chain, Is.Not.Null, "chain"))
{
if (ctx.Expect(chain.ChainPolicy, Is.Not.Null, "chain.ChainPolicy") &&
ctx.Expect(chain.ChainPolicy.ExtraStore, Is.Not.Null, "ChainPolicy.ExtraStore") &&
ctx.Expect(chain.ChainPolicy.ExtraStore.Count, Is.EqualTo(parameters.ExpectedExtraStore.Count), "ChainPolicy.ExtraStore.Count"))
{
for (int i = 0; i < parameters.ExpectedExtraStore.Count; i++)
{
ExpectCertificate(ctx, chain.ChainPolicy.ExtraStore[i], parameters.ExpectedExtraStore[i], string.Format("ExtraStore[{0}]", i));
}
}
}
if (parameters.ExpectSuccess)
{
ctx.Assert(errors, Is.EqualTo(SslPolicyErrors.None), "expecting success");
}
else
{
ctx.Assert(errors, Is.Not.EqualTo(SslPolicyErrors.None), "expecting failure");
}
}
public ReadOnlyMemory <byte> EncodeSpecial()
{
using (var writer = new AsnWriter(AsnEncodingRules.DER))
{
var tag = Asn1Tag.Sequence;
writer.PushSequence(tag);
writer.WriteKeyParameterInteger(P.Span);
writer.WriteKeyParameterInteger(G.Span);
writer.WriteKeyParameterInteger(Q.Span);
if (Asn1Extension.HasValue(J))
{
writer.WriteKeyParameterInteger(J.Value.Span);
}
if (Asn1Extension.HasValue(ValidationParameters))
{
ValidationParameters?.Encode(writer);
}
writer.PopSequence(tag);
return(writer.EncodeAsMemory());
}
}
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
{
if (!RuntimeInformation.IsWindows())
{
yield return(new ValidationError(true, $"{GetType().Name} is supported only on Windows"));
}
}
public ModelClientValidationMinAgeRule(string errorMessage, int ageInYears)
{
ErrorMessage = errorMessage;
// Validation Type and Parameters must be lowercase
ValidationType = "minage";
ValidationParameters.Add("ageinyears", ageInYears);
}
public StringLenghtWarningValidationRule(int maximumLength, string errorMessage)
{
ErrorMessage = errorMessage;
ValidationType = "stringlengthwarning";
ValidationParameters.Add("maximumlength", maximumLength);
ValidationParameters.Add("ignorewarningsfield", "IgnoreWarnings");
}
public ModelClientValidationRequiredIfRule(string errorMessage, string otherProperty, Comparison comparison, object value)
{
ErrorMessage = errorMessage;
ValidationType = "requiredif";
ValidationParameters.Add("other", otherProperty);
ValidationParameters.Add("comp", comparison.ToString().ToLower());
ValidationParameters.Add("value", value.ToString().ToLower());
}
public ModelClientValidationRequiredIfRule(string errorMessage, string dependentProperty, RequiredIfComparison comparison, object value, bool allowMultiple)
{
ErrorMessage = errorMessage;
ValidationType = "requiredif";
ValidationParameters.Add("dependentprop", dependentProperty);
ValidationParameters.Add("comparison", comparison.ToString().ToLower());
ValidationParameters.Add("value", value.ToString());
ValidationParameters.Add("allowmultiple", allowMultiple.ToString().ToLower());
}
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
{
var byDescriptor = validationParameters.Benchmarks.GroupBy(benchmark => (benchmark.Descriptor, benchmark.Job)); // descriptor = type + method
return(byDescriptor.Where(benchmarkCase => benchmarkCase.Count() > Limit).Select(group =>
new ValidationError(
isCritical: true,
message: $"{group.Key.Descriptor.Type.Name}.{group.Key.Descriptor.WorkloadMethod.Name} has {group.Count()} test cases. It MUST NOT have more than {Limit} test cases. We don't have inifinite amount of time to run all the benchmarks!!",
benchmarkCase: group.First())));
}
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
=> validationParameters.Benchmarks
.Where(benchmark => !benchmark.Descriptor.Categories.Any(category => category == Categories.CoreFX || category == Categories.CoreCLR || category == Categories.ThirdParty))
.Select(benchmark => benchmark.Descriptor.GetFilterName())
.Distinct()
.Select(benchmarkId =>
new ValidationError(
isCritical: TreatsWarningsAsErrors,
$"{benchmarkId} does not belong to one of the mandatory categories: {Categories.CoreCLR}, {Categories.CoreFX}, {Categories.ThirdParty}. Use [BenchmarkCategory(Categories.$)]")
);
public RequiredIfValidationRule(string errorMessage, string reqVal,
string otherProperties, string otherValues, int count)
{
string tmp = count == 0 ? "" : Char.ConvertFromUtf32(96 + count);
ErrorMessage = errorMessage;
ValidationType = "requiredif" + tmp;
ValidationParameters.Add("reqval", reqVal);
ValidationParameters.Add("others", otherProperties);
ValidationParameters.Add("values", otherValues);
}
public MainWindow()
{
InitializeComponent();
Binding binding = new Binding();
binding.Source = slider2;
binding.Path = new PropertyPath(Slider.ValueProperty);
ValidationParameters validationParams = (ValidationParameters)Resources["validationParams1"];
BindingOperations.SetBinding(validationParams, ValidationParameters.NumberCombineToProperty, binding);
}
public ModelClientValidationSelectOneRule
(string errorMessage, string[] strProperties)
{
ErrorMessage = errorMessage;
ValidationType = "mycustomvalidation";
for (int intIndex = 0; intIndex < strProperties.Length; intIndex++)
{
ValidationParameters.Add("otherproperty" +
intIndex.ToString(), strProperties[intIndex]);
}
}
/// <summary>Validates the specified benchmarks (cleans per-run slots).</summary>
/// <param name="validationParameters">The validation parameters.</param>
/// <returns>Enumerable of validation errors.</returns>
IEnumerable <ValidationError> IValidator.Validate(ValidationParameters validationParameters)
{
foreach (var pair in _stateSlots.ToArray())
{
if (pair.Key.ClearBeforeEachRun)
{
_stateSlots.TryRemove(pair.Key, out var _);
}
}
return(Enumerable.Empty <ValidationError>());
}
/// <summary>
/// Creates a TokenValidationParameters that supports multiple key validation and validates the issuer claim.
/// </summary>
public static TokenValidationParameters CreateParameters(this ValidationParameters @this, params SecurityKey[] securityKeys)
=> new TokenValidationParameters
{
ValidateLifetime = @this.ValidateLifetime,
ValidateAudience = !string.IsNullOrEmpty(@this.ValidAudience),
ValidAudience = @this.ValidAudience,
ValidateIssuer = !string.IsNullOrEmpty(@this.ValidIssuer),
ValidIssuer = @this.ValidIssuer,
ValidateIssuerSigningKey = !string.IsNullOrEmpty(@this.ValidIssuer),
RequireSignedTokens = true,
IssuerSigningKeys = securityKeys
};
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
{
foreach (var benchmark in validationParameters.Benchmarks)
{
var runtime = benchmark.Job.ResolveValue(EnvironmentMode.RuntimeCharacteristic, EnvironmentResolver.Instance);
if (runtime.RuntimeMoniker < RuntimeMoniker.NetCoreApp30)
{
yield return(new ValidationError(true, $"{nameof(EventPipeProfiler)} supports only .NET Core 3.0+", benchmark));
}
}
}
public CustomModelClientValidationRule(
string errorMessage,
string pastOnlyValidateType,
params KeyValuePair <string, object>[] args)
{
ValidationType = pastOnlyValidateType;
ErrorMessage = errorMessage;
if (args != null && args.Length > 0)
{
foreach (var item in args)
{
ValidationParameters.Add(item.Key, item.Value);
}
}
}
public void DuplicatedArgumentsAreDetected(Type typeWithBenchmarks, bool shouldReportError)
{
var benchmarksForType = BenchmarkConverter.TypeToBenchmarks(typeWithBenchmarks);
var validationParameters = new ValidationParameters(benchmarksForType.BenchmarksCases, benchmarksForType.Config);
var validationErrors = new UniqueArgumentsValidator().Validate(validationParameters);
if (shouldReportError)
{
Assert.NotEmpty(validationErrors);
}
else
{
Assert.Empty(validationErrors);
}
}
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
{
foreach (var benchmark in validationParameters.Benchmarks)
{
if (!RuntimeInformation.IsWindows() && !ShouldUseMonoDisassembler(benchmark))
{
yield return(new ValidationError(false, "No Disassembler support, only Mono is supported for non-Windows OS", benchmark));
}
if (benchmark.Job.Infrastructure.HasValue(InfrastructureMode.ToolchainCharacteristic) &&
benchmark.Job.Infrastructure.Toolchain is InProcessToolchain)
{
yield return(new ValidationError(true, "InProcessToolchain has no DisassemblyDiagnoser support", benchmark));
}
}
}
// TODO: check for diagnosers that cannot be run in-process?
/// <summary>Proofs that benchmarks' jobs match the environment.</summary>
/// <param name="validationParameters">The validation parameters.</param>
/// <returns>Enumerable of validation errors.</returns>
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
{
var result = new List <ValidationError>();
var targets = validationParameters.Benchmarks.Select(b => b.Target).Distinct();
foreach (var target in targets)
{
if (!string.IsNullOrEmpty(target.AdditionalLogic))
{
result.Add(
new ValidationError(
false,
$"Target {target} has {nameof(target.AdditionalLogic)} filled. AdditionalLogic is not supported by in-process toolchain."));
}
}
foreach (var job in validationParameters.Config.GetJobs())
{
foreach (var characteristic in job.GetCharacteristicsWithValues())
{
Func <Job, Characteristic, string> validationRule;
if (_validationRules.TryGetValue(characteristic, out validationRule))
{
var message = validationRule(job, characteristic);
if (!string.IsNullOrEmpty(message))
{
result.Add(
new ValidationError(
TreatsWarningsAsErrors,
$"Job {job}, {characteristic.FullId} {message}"));
}
}
#if DEBUG
else if (characteristic.IsPresentableCharacteristic())
{
result.Add(
new ValidationError(
false,
$"Job {job}, {characteristic.FullId}: no validation rule specified."));
}
#endif
}
}
return(result.ToArray());
}
public IEnumerable <ValidationError> Validate(ValidationParameters validationParameters)
{
var currentPlatform = RuntimeInformation.GetCurrentPlatform();
if (currentPlatform != Platform.X64 && currentPlatform != Platform.X86)
{
yield return(new ValidationError(true, $"{currentPlatform} is not supported (Iced library limitation)"));
yield break;
}
foreach (var benchmark in validationParameters.Benchmarks)
{
if (benchmark.Job.Infrastructure.TryGetToolchain(out var toolchain) && toolchain is InProcessNoEmitToolchain)
{
yield return(new ValidationError(true, "InProcessToolchain has no DisassemblyDiagnoser support", benchmark));
}
public void updateLicensingInfo()
{
errorInfo = "";
try
{
ValidationParameters validationParameters = new ValidationParameters();
validationParameters.setProductNumber(productNumber);
ValidationResult validationResult = LicenseeService.validate(netLicensingContext, licenseeNumber, validationParameters);
if (!validationResult.getValidations().ContainsKey(module1.name))
{
throw new NetLicensingException("Product Module '" + module1.name + "' is missing");
}
else
{
module1.update(validationResult.getValidations()[module1.name]);
}
if (!validationResult.getValidations().ContainsKey(module2.name))
{
throw new NetLicensingException("Product Module '" + module2.name + "' is missing");
}
else
{
module2.update(validationResult.getValidations()[module2.name]);
}
}
catch (NetLicensingException e)
{
module1.reset();
module2.reset();
errorInfo = "NetLicensing error during validation: " + e.Message;
}
catch (Exception e)
{
module1.reset();
module2.reset();
errorInfo = "Error during validation: " + e.ToString();
}
catch
{
module1.reset();
module2.reset();
errorInfo = "Unknown error during validation";
}
}
public static IEnumerable <ValidationError> Validate(ValidationParameters validationParameters, bool mandatory)
{
if (!RuntimeInformation.IsWindows())
{
yield return(new ValidationError(true, "Hardware Counters and EtwProfiler are supported only on Windows"));
yield break;
}
if (!validationParameters.Config.GetHardwareCounters().Any() && mandatory)
{
yield return(new ValidationError(true, "No Hardware Counters defined, probably a bug"));
yield break;
}
if (TraceEventSession.IsElevated() != true)
{
yield return(new ValidationError(true, "Must be elevated (Admin) to use ETW Kernel Session (required for Hardware Counters and EtwProfiler)."));
}
var availableCpuCounters = TraceEventProfileSources.GetInfo();
foreach (var hardwareCounter in validationParameters.Config.GetHardwareCounters())
{
if (!EtwTranslations.TryGetValue(hardwareCounter, out var counterName))
{
yield return(new ValidationError(true, $"Counter {hardwareCounter} not recognized. Please make sure that you are using counter available on your machine. You can get the list of available counters by running `tracelog.exe -profilesources Help`"));
}
if (!availableCpuCounters.ContainsKey(counterName))
{
yield return(new ValidationError(true, $"The counter {counterName} is not available. Please make sure you are Windows 8+ without Hyper-V"));
}
}
foreach (var benchmark in validationParameters.Benchmarks)
{
if (benchmark.Job.Infrastructure.HasValue(InfrastructureMode.ToolchainCharacteristic) &&
(benchmark.Job.Infrastructure.Toolchain is InProcessToolchain || benchmark.Job.Infrastructure.Toolchain is InProcessEmitToolchain))
{
yield return(new ValidationError(true, "Hardware Counters are not supported for InProcessToolchain.", benchmark));
}
}
}
public void ReadAndValidateSymmetric_ValidTokenAndInvalidAudience_ShouldThrowSecurityTokenInvalidAudienceException()
{
// GIVEN a valid JWT reader, JWT and and invalid audience
var jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb21lLWNsYWltLWludCI6MTIzNDU2LCJzb21lLWNsYWltLWJvb2wiOmZhbHNlLCJzb21lLWNsYWltLWFycmF5IjpbIml0ZW0xIiwiaXRlbTIiXSwiZXhwIjoyNTM0MDIzMDA4MDAsImlzcyI6InNvbWUtaXNzdWVyIiwiYXVkIjoic29tZS1hdWRpZW5jZSJ9.jGjRCItE2n42ZUu7h4GzH-oT8n1Y5wjzs73NYQUcmJk";
var sut = new JWTReader();
var issuer = "some-issuer";
var audience = "some-other-audience";
var sharedKey = "b7vUtYUvmR46ifoddrccuWCHeRMfm2qw";
var validationParameters = new ValidationParameters {
ValidIssuer = issuer, ValidAudience = audience, ValidateLifetime = false
};
// WHEN reading and validating it
Action act = () => sut.ReadAndValidateSymmetric(jwt, validationParameters, sharedKey);
// THEN it should throw SecurityTokenInvalidAudienceException
act.Should().Throw <SecurityTokenInvalidAudienceException>();
}
