internal void Open(string propertyName, bool requiredForForwardDirection, SecurityTokenProvider provider, TimeSpan timeout)
{
if (provider != null)
{
SecurityUtils.OpenTokenProviderIfRequiredAsync(provider, new TimeoutHelper(timeout).GetCancellationToken());
}
else
{
OnPropertySettingsError(propertyName, requiredForForwardDirection);
}
}
private async Task MergeSupportingTokenProvidersAsync(TimeSpan timeout)
{
if (ScopedSupportingTokenProviderSpecification.Count == 0)
{
_mergedSupportingTokenProvidersMap = null;
}
else
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
SecurityProtocolFactory.ExpectSupportingTokens = true;
_mergedSupportingTokenProvidersMap = new Dictionary <string, Collection <SupportingTokenProviderSpecification> >();
foreach (string action in ScopedSupportingTokenProviderSpecification.Keys)
{
ICollection <SupportingTokenProviderSpecification> scopedProviders = ScopedSupportingTokenProviderSpecification[action];
if (scopedProviders == null || scopedProviders.Count == 0)
{
continue;
}
Collection <SupportingTokenProviderSpecification> mergedProviders = new Collection <SupportingTokenProviderSpecification>();
foreach (SupportingTokenProviderSpecification spec in ChannelSupportingTokenProviderSpecification)
{
mergedProviders.Add(spec);
}
foreach (SupportingTokenProviderSpecification spec in scopedProviders)
{
await SecurityUtils.OpenTokenProviderIfRequiredAsync(spec.TokenProvider, timeoutHelper.GetCancellationToken());
if (spec.SecurityTokenAttachmentMode == SecurityTokenAttachmentMode.Endorsing || spec.SecurityTokenAttachmentMode == SecurityTokenAttachmentMode.SignedEndorsing)
{
if (spec.TokenParameters.RequireDerivedKeys && !spec.TokenParameters.HasAsymmetricKey)
{
SecurityProtocolFactory.ExpectKeyDerivation = true;
}
}
mergedProviders.Add(spec);
}
_mergedSupportingTokenProvidersMap.Add(action, mergedProviders);
}
}
}
public virtual async Task OnOpenAsync(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
if (SecurityProtocolFactory.ActAsInitiator)
{
ChannelSupportingTokenProviderSpecification = new Collection <SupportingTokenProviderSpecification>();
ScopedSupportingTokenProviderSpecification = new Dictionary <string, ICollection <SupportingTokenProviderSpecification> >();
AddSupportingTokenProviders(SecurityProtocolFactory.SecurityBindingElement.EndpointSupportingTokenParameters, false, (IList <SupportingTokenProviderSpecification>)ChannelSupportingTokenProviderSpecification);
AddSupportingTokenProviders(SecurityProtocolFactory.SecurityBindingElement.OptionalEndpointSupportingTokenParameters, true, (IList <SupportingTokenProviderSpecification>)ChannelSupportingTokenProviderSpecification);
foreach (string action in SecurityProtocolFactory.SecurityBindingElement.OperationSupportingTokenParameters.Keys)
{
Collection <SupportingTokenProviderSpecification> providerSpecList = new Collection <SupportingTokenProviderSpecification>();
AddSupportingTokenProviders(SecurityProtocolFactory.SecurityBindingElement.OperationSupportingTokenParameters[action], false, providerSpecList);
ScopedSupportingTokenProviderSpecification.Add(action, providerSpecList);
}
foreach (string action in SecurityProtocolFactory.SecurityBindingElement.OptionalOperationSupportingTokenParameters.Keys)
{
Collection <SupportingTokenProviderSpecification> providerSpecList;
ICollection <SupportingTokenProviderSpecification> existingList;
if (ScopedSupportingTokenProviderSpecification.TryGetValue(action, out existingList))
{
providerSpecList = ((Collection <SupportingTokenProviderSpecification>)existingList);
}
else
{
providerSpecList = new Collection <SupportingTokenProviderSpecification>();
ScopedSupportingTokenProviderSpecification.Add(action, providerSpecList);
}
AddSupportingTokenProviders(SecurityProtocolFactory.SecurityBindingElement.OptionalOperationSupportingTokenParameters[action], true, providerSpecList);
}
if (!ChannelSupportingTokenProviderSpecification.IsReadOnly)
{
if (ChannelSupportingTokenProviderSpecification.Count == 0)
{
ChannelSupportingTokenProviderSpecification = EmptyTokenProviders;
}
else
{
SecurityProtocolFactory.ExpectSupportingTokens = true;
foreach (SupportingTokenProviderSpecification tokenProviderSpec in ChannelSupportingTokenProviderSpecification)
{
SecurityUtils.OpenTokenProviderIfRequiredAsync(tokenProviderSpec.TokenProvider, timeoutHelper.GetCancellationToken());
if (tokenProviderSpec.SecurityTokenAttachmentMode == SecurityTokenAttachmentMode.Endorsing || tokenProviderSpec.SecurityTokenAttachmentMode == SecurityTokenAttachmentMode.SignedEndorsing)
{
if (tokenProviderSpec.TokenParameters.RequireDerivedKeys && !tokenProviderSpec.TokenParameters.HasAsymmetricKey)
{
SecurityProtocolFactory.ExpectKeyDerivation = true;
}
}
}
ChannelSupportingTokenProviderSpecification =
new ReadOnlyCollection <SupportingTokenProviderSpecification>((Collection <SupportingTokenProviderSpecification>)ChannelSupportingTokenProviderSpecification);
}
}
// create a merged map of the per operation supporting tokens
await MergeSupportingTokenProvidersAsync(timeoutHelper.RemainingTime());
}
}