/// <summary> Loads, displays, saves and returns an alias configuration. </summary>
/// <remarks> Any changes to the alias list are saved even if the form is cancelled. </remarks>
public static AliasConfiguration Execute()
{
AliasConfiguration configuration = AliasManager.LoadConfiguration();
Execute(configuration);
return(configuration);
}
/// <summary>
/// Called when the message has been received,
/// after it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnReceiving()
{
var extraData = ((IMessage)this).ExtraData;
this.PreferredPolicies.Clear();
string[] preferredPolicies = this.preferredPoliciesString.Split(' ');
foreach (string policy in preferredPolicies)
{
if (policy.Length > 0)
{
this.PreferredPolicies.Add(policy);
}
}
this.PreferredAuthLevelTypes.Clear();
AliasManager authLevelAliases = PapeUtilities.FindIncomingAliases(extraData);
string preferredAuthLevelAliases;
if (extraData.TryGetValue(Constants.RequestParameters.PreferredAuthLevelTypes, out preferredAuthLevelAliases))
{
foreach (string authLevelAlias in preferredAuthLevelAliases.Split(' '))
{
if (authLevelAlias.Length == 0)
{
continue;
}
this.PreferredAuthLevelTypes.Add(authLevelAliases.ResolveAlias(authLevelAlias));
}
}
}
/// <summary>
/// Called when the message is about to be transmitted,
/// before it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnSending()
{
var fields = ((IMessage)this).ExtraData;
fields.Clear();
List <string> requiredAliases = new List <string>(), optionalAliases = new List <string>();
AliasManager aliasManager = new AliasManager();
foreach (var att in this.attributes)
{
string alias = aliasManager.GetAlias(att.TypeUri);
// define the alias<->typeUri mapping
fields.Add("type." + alias, att.TypeUri);
// set how many values the relying party wants max
fields.Add("count." + alias, att.Count.ToString(CultureInfo.InvariantCulture));
if (att.IsRequired)
{
requiredAliases.Add(alias);
}
else
{
optionalAliases.Add(alias);
}
}
// Set optional/required lists
this.OptionalAliases = optionalAliases.Count > 0 ? string.Join(",", optionalAliases.ToArray()) : null;
this.RequiredAliases = requiredAliases.Count > 0 ? string.Join(",", requiredAliases.ToArray()) : null;
}
/// <summary>
/// Serializes a set of attribute values to a dictionary of fields to send in the message.
/// </summary>
/// <param name="fields">The dictionary to fill with serialized attributes.</param>
/// <param name="attributes">The attributes.</param>
internal static void SerializeAttributes(IDictionary <string, string> fields, IEnumerable <AttributeValues> attributes)
{
Contract.Requires <ArgumentNullException>(fields != null);
Contract.Requires <ArgumentNullException>(attributes != null);
AliasManager aliasManager = new AliasManager();
foreach (var att in attributes)
{
string alias = aliasManager.GetAlias(att.TypeUri);
fields.Add("type." + alias, att.TypeUri);
if (att.Values == null)
{
continue;
}
if (att.Values.Count != 1)
{
fields.Add("count." + alias, att.Values.Count.ToString(CultureInfo.InvariantCulture));
for (int i = 0; i < att.Values.Count; i++)
{
fields.Add(string.Format(CultureInfo.InvariantCulture, "value.{0}.{1}", alias, i + 1), att.Values[i]);
}
}
else
{
fields.Add("value." + alias, att.Values[0]);
}
}
}
IDictionary <string, string> IExtensionRequest.Serialize(DotNetOpenId.RelyingParty.IAuthenticationRequest authenticationRequest)
{
var fields = new Dictionary <string, string>();
if (MaximumAuthenticationAge.HasValue)
{
fields.Add(Constants.RequestParameters.MaxAuthAge,
MaximumAuthenticationAge.Value.TotalSeconds.ToString(CultureInfo.InvariantCulture));
}
// Even if empty, this parameter is required as part of the request message.
fields.Add(Constants.RequestParameters.PreferredAuthPolicies, SerializePolicies(PreferredPolicies));
if (PreferredAuthLevelTypes.Count > 0)
{
AliasManager authLevelAliases = new AliasManager();
authLevelAliases.AssignAliases(PreferredAuthLevelTypes, Constants.AuthenticationLevels.PreferredTypeUriToAliasMap);
// Add a definition for each Auth Level Type alias.
foreach (string alias in authLevelAliases.Aliases)
{
fields.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, authLevelAliases.ResolveAlias(alias));
}
// Now use the aliases for those type URIs to list a preferred order.
fields.Add(Constants.RequestParameters.PreferredAuthLevelTypes, SerializeAuthLevels(PreferredAuthLevelTypes, authLevelAliases));
}
return(fields);
}
IDictionary<string, string> IExtensionRequest.Serialize(RelyingParty.IAuthenticationRequest authenticationRequest) {
var fields = new Dictionary<string, string> {
{ "mode", Mode },
};
if (UpdateUrl != null)
fields.Add("update_url", UpdateUrl.AbsoluteUri);
List<string> requiredAliases = new List<string>(), optionalAliases = new List<string>();
AliasManager aliasManager = new AliasManager();
foreach (var att in attributesRequested) {
string alias = aliasManager.GetAlias(att.TypeUri);
// define the alias<->typeUri mapping
fields.Add("type." + alias, att.TypeUri);
// set how many values the relying party wants max
fields.Add("count." + alias, att.Count.ToString(CultureInfo.InvariantCulture));
if (att.IsRequired)
requiredAliases.Add(alias);
else
optionalAliases.Add(alias);
}
// Set optional/required lists
if (optionalAliases.Count > 0)
fields.Add("if_available", string.Join(",", optionalAliases.ToArray()));
if (requiredAliases.Count > 0)
fields.Add("required", string.Join(",", requiredAliases.ToArray()));
return fields;
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlSelectStatement" /> class.
/// </summary>
public SqlSelectStatement( )
{
WithClause = new SqlWithClause( );
AliasManager = new AliasManager( );
CurrentCte = new Stack <SqlCte>( );
References = new ReferenceManager();
}
/// <summary>
/// Called when the message is about to be transmitted,
/// before it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnSending()
{
var extraData = ((IMessage)this).ExtraData;
extraData.Clear();
this.actualPoliciesString = SerializePolicies(this.ActualPolicies);
if (this.AssuranceLevels.Count > 0)
{
AliasManager aliases = new AliasManager();
aliases.AssignAliases(this.AssuranceLevels.Keys, Constants.AssuranceLevels.PreferredTypeUriToAliasMap);
// Add a definition for each Auth Level Type alias.
foreach (string alias in aliases.Aliases)
{
extraData.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, aliases.ResolveAlias(alias));
}
// Now use the aliases for those type URIs to list the individual values.
foreach (var pair in this.AssuranceLevels)
{
extraData.Add(AuthLevelAliasPrefix + aliases.GetAlias(pair.Key), pair.Value);
}
}
}
IDictionary <string, string> IExtensionResponse.Serialize(DotNetOpenId.Provider.IRequest authenticationRequest)
{
var fields = new Dictionary <string, string>();
fields.Add(Constants.ResponseParameters.AuthPolicies, SerializePolicies(ActualPolicies));
if (AuthenticationTimeUtc.HasValue)
{
fields.Add(Constants.ResponseParameters.AuthTime, AuthenticationTimeUtc.Value.ToUniversalTime().ToString(PermissibleDateTimeFormats[0], CultureInfo.InvariantCulture));
}
if (AssuranceLevels.Count > 0)
{
AliasManager aliases = new AliasManager();
aliases.AssignAliases(AssuranceLevels.Keys, Constants.AuthenticationLevels.PreferredTypeUriToAliasMap);
// Add a definition for each Auth Level Type alias.
foreach (string alias in aliases.Aliases)
{
fields.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, aliases.ResolveAlias(alias));
}
// Now use the aliases for those type URIs to list the individual values.
foreach (var pair in AssuranceLevels)
{
fields.Add(Constants.ResponseParameters.AuthLevelAliasPrefix + aliases.GetAlias(pair.Key), pair.Value);
}
}
return(fields);
}
/// <summary>
/// Called when the message has been received,
/// after it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnReceiving()
{
var extraData = ((IMessage)this).ExtraData;
this.ActualPolicies.Clear();
string[] actualPolicies = this.actualPoliciesString.Split(' ');
foreach (string policy in actualPolicies)
{
if (policy.Length > 0 && policy != AuthenticationPolicies.None)
{
this.ActualPolicies.Add(policy);
}
}
this.AssuranceLevels.Clear();
AliasManager authLevelAliases = PapeUtilities.FindIncomingAliases(extraData);
foreach (string authLevelAlias in authLevelAliases.Aliases)
{
string authValue;
if (extraData.TryGetValue(AuthLevelAliasPrefix + authLevelAlias, out authValue))
{
string authLevelType = authLevelAliases.ResolveAlias(authLevelAlias);
this.AssuranceLevels[authLevelType] = authValue;
}
}
}
// the other way to do this, is to index addresses per alias when the item is aliased
public Address GetAddress_(string text)
{
if (text.Length == Address.ENCODED_SIZE)
{
return(new Address(text));
}
IAliased item;
if (!AliasManager.TryGetByAlias(text, out item))
{
return(null);
}
var declaration = item.GetObject <TxAddressDeclaration>();
if (declaration != null)
{
return(declaration.Address);
}
var wallet = item.GetObject <PrivateKeyNotWallet>();
if (wallet != null)
{
return(wallet.Address);
}
return(null);
}
public Alias()
{
_aliasManager = new AliasManager()
{
FileName = Path.Combine(ShellHelper.GetApplicationDataDirectory(Program.APP_NAME), "alias.txt")
};
_aliasManager.Load();
}
public Alias()
{
_aliasManager = new AliasManager
{
FileName = Path.Combine(ApplicationHelper.GetApplicationDataDirectory("cv4pve-botgram"), "alias.txt")
};
_aliasManager.Load();
}
public ActionResult PrepareCheckOut()
{
OrderVM final = Check.GenerateOrderVM(Order);
User user = registry.FindUserByName(System.Web.HttpContext.Current.User.Identity.Name);
TempData["aliases"] = AliasManager.FindAliasesForUser(user.UserName);
return(RedirectToAction("Index", "Alias"));
}
public bool SetActiveKey(string alias)
{
if (!AliasManager.TryGetByAlias(alias, out Aliased <PrivateKeyNotWallet> wallet))
{
return(false);
}
active = wallet;
return(true);
}
public SchemaBrowser()
{
InitializeComponent();
_searchBox = new TextBoxDelayHandler(tbSearch, 300);
_searchBox.DelayedTextChanged += tbSearch_TextChanged;
_aliasManager = new AliasManager(new Options().Folder);
_diagramBuilder = new DbDiagramBuilder();
}
bool IExtensionResponse.Deserialize(IDictionary <string, string> fields, DotNetOpenId.RelyingParty.IAuthenticationResponse response, string typeUri)
{
if (fields == null)
{
return(false);
}
if (!fields.ContainsKey(Constants.ResponseParameters.AuthPolicies))
{
return(false);
}
ActualPolicies.Clear();
string[] actualPolicies = fields[Constants.ResponseParameters.AuthPolicies].Split(' ');
foreach (string policy in actualPolicies)
{
if (policy.Length > 0 && policy != AuthenticationPolicies.None)
{
ActualPolicies.Add(policy);
}
}
AuthenticationTimeUtc = null;
string authTime;
if (fields.TryGetValue(Constants.ResponseParameters.AuthTime, out authTime))
{
DateTime authDateTime;
if (DateTime.TryParse(authTime, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out authDateTime) &&
authDateTime.Kind == DateTimeKind.Utc) // may be unspecified per our option above
{
AuthenticationTimeUtc = authDateTime;
}
else
{
Logger.ErrorFormat("Invalid format for {0} parameter: {1}",
Constants.ResponseParameters.AuthTime, authTime);
}
}
AssuranceLevels.Clear();
AliasManager authLevelAliases = PolicyRequest.FindIncomingAliases(fields);
foreach (string authLevelAlias in authLevelAliases.Aliases)
{
string authValue;
if (fields.TryGetValue(Constants.ResponseParameters.AuthLevelAliasPrefix + authLevelAlias, out authValue))
{
string authLevelType = authLevelAliases.ResolveAlias(authLevelAlias);
AssuranceLevels[authLevelType] = authValue;
}
}
return(true);
}
private static void CreateCommandFromAlias(TextWriter output,
CommandLineApplication parent,
PveClient client,
ClassApi classApiRoot,
AliasManager aliasManager,
bool onlyResult)
{
foreach (var item in aliasManager.Alias)
{
parent.Command(item.Names[0], cmd =>
{
foreach (var name in item.Names)
{
cmd.AddName(name);
}
cmd.Description = item.Description;
cmd.ShowInHelpText = false;
cmd.ExtendedHelpText = Environment.NewLine + "Alias command: " + item.Command;
//create argument
foreach (var arg in StringHelper.GetArgumentTags(item.Command))
{
cmd.Argument(arg, arg, false).IsRequired();
}
cmd.OnExecute(() =>
{
var title = item.Description;
var command = item.Command;
//replace value into argument
foreach (var arg in cmd.Arguments)
{
title += $" {arg.Name}: {arg.Value}";
command = command.Replace(StringHelper.CreateArgumentTag(arg.Name), arg.Value);
}
if (!onlyResult)
{
output.WriteLine(title);
output.WriteLine("Command: " + command);
}
ParseLine(output,
command,
client,
classApiRoot,
aliasManager,
onlyResult);
});
});
}
}
public bool ImportPrivateKey(string label, PrivateKeyNotWallet key)
{
var aliased = AliasManager.SetAlias(label, key);
var address = key.Address.Encoded;
if (wallets.ContainsKey(label))
{
return(false);
}
wallets.Add(address, aliased);
AddressListener.Listen(key.Address);
return(true);
}
/// <summary>
/// Deserializes attribute values from an incoming set of message data.
/// </summary>
/// <param name="fields">The data coming in with the message.</param>
/// <returns>The attribute values found in the message.</returns>
internal static IEnumerable <AttributeValues> DeserializeAttributes(IDictionary <string, string> fields)
{
AliasManager aliasManager = ParseAliases(fields);
foreach (string alias in aliasManager.Aliases)
{
AttributeValues att = new AttributeValues(aliasManager.ResolveAlias(alias));
int count = 1;
bool countSent = false;
string countString;
if (fields.TryGetValue("count." + alias, out countString))
{
if (!int.TryParse(countString, out count) || count < 0)
{
Logger.OpenId.ErrorFormat("Failed to parse count.{0} value to a non-negative integer.", alias);
continue;
}
countSent = true;
}
if (countSent)
{
for (int i = 1; i <= count; i++)
{
string value;
if (fields.TryGetValue(string.Format(CultureInfo.InvariantCulture, "value.{0}.{1}", alias, i), out value))
{
att.Values.Add(value);
}
else
{
Logger.OpenId.ErrorFormat("Missing value for attribute '{0}'.", att.TypeUri);
continue;
}
}
}
else
{
string value;
if (fields.TryGetValue("value." + alias, out value))
{
att.Values.Add(value);
}
else
{
Logger.OpenId.ErrorFormat("Missing value for attribute '{0}'.", att.TypeUri);
continue;
}
}
yield return(att);
}
}
/// <summary>
/// Helper method to create a new transient SQL table, not yet attached to anything.
/// </summary>
/// <param name="name">The physical SQL table name</param>
/// <param name="aliasPrefix">A suggested table alias</param>
/// <returns>The SQL table</returns>
public SqlTable CreateTable(string name, string aliasPrefix)
{
// Note: name can be empty for aggregate table
var table = new SqlTable
{
Name = name,
TableAlias = AliasManager.CreateAlias(aliasPrefix),
ParentQuery = this,
References = FullStatement.References,
AllowAccessToAllResources = FullStatement.AllowAccessToAllResources,
DenyAccessToAllResources = FullStatement.DenyAccessToAllResources
};
return(table);
}
/// <summary>
/// Looks at the incoming fields and figures out what the aliases and name spaces for auth level types are.
/// </summary>
/// <param name="fields">The incoming message data in which to discover TypeURIs and aliases.</param>
/// <returns>The <see cref="AliasManager"/> initialized with the given data.</returns>
internal static AliasManager FindIncomingAliases(IDictionary<string, string> fields) {
AliasManager aliasManager = new AliasManager();
foreach (var pair in fields) {
if (!pair.Key.StartsWith(Constants.AuthLevelNamespaceDeclarationPrefix, StringComparison.Ordinal)) {
continue;
}
string alias = pair.Key.Substring(Constants.AuthLevelNamespaceDeclarationPrefix.Length);
aliasManager.SetAlias(alias, pair.Value);
}
aliasManager.SetPreferredAliasesWhereNotSet(Constants.AssuranceLevels.PreferredTypeUriToAliasMap);
return aliasManager;
}
/// <summary>
/// Looks at the incoming fields and figures out what the aliases and name spaces for auth level types are.
/// </summary>
/// <param name="fields">The incoming message data in which to discover TypeURIs and aliases.</param>
/// <returns>The <see cref="AliasManager"/> initialized with the given data.</returns>
internal static AliasManager FindIncomingAliases(IDictionary<string, string> fields) {
AliasManager aliasManager = new AliasManager();
foreach (var pair in fields) {
if (!pair.Key.StartsWith(Constants.AuthLevelNamespaceDeclarationPrefix, StringComparison.Ordinal)) {
continue;
}
string alias = pair.Key.Substring(Constants.AuthLevelNamespaceDeclarationPrefix.Length);
aliasManager.SetAlias(alias, pair.Value);
}
aliasManager.SetPreferredAliasesWhereNotSet(Constants.AssuranceLevels.PreferredTypeUriToAliasMap);
return aliasManager;
}
internal static void SerializeAttributes(Dictionary<string, string> fields, IEnumerable<AttributeValues> attributes) {
Debug.Assert(fields != null && attributes != null);
AliasManager aliasManager = new AliasManager();
foreach (var att in attributes) {
string alias = aliasManager.GetAlias(att.TypeUri);
fields.Add("type." + alias, att.TypeUri);
if (att.Values == null) continue;
if (att.Values.Count != 1) {
fields.Add("count." + alias, att.Values.Count.ToString(CultureInfo.InvariantCulture));
for (int i = 0; i < att.Values.Count; i++) {
fields.Add(string.Format(CultureInfo.InvariantCulture, "value.{0}.{1}", alias, i + 1), att.Values[i]);
}
} else {
fields.Add("value." + alias, att.Values[0]);
}
}
}
bool IExtensionRequest.Deserialize(IDictionary <string, string> fields, DotNetOpenId.Provider.IRequest request, string typeUri)
{
if (fields == null)
{
return(false);
}
if (!fields.ContainsKey(Constants.RequestParameters.PreferredAuthPolicies))
{
return(false);
}
string maxAuthAge;
MaximumAuthenticationAge = fields.TryGetValue(Constants.RequestParameters.MaxAuthAge, out maxAuthAge) ?
TimeSpan.FromSeconds(double.Parse(maxAuthAge, CultureInfo.InvariantCulture)) : (TimeSpan?)null;
PreferredPolicies.Clear();
string[] preferredPolicies = fields[Constants.RequestParameters.PreferredAuthPolicies].Split(' ');
foreach (string policy in preferredPolicies)
{
if (policy.Length > 0)
{
PreferredPolicies.Add(policy);
}
}
PreferredAuthLevelTypes.Clear();
AliasManager authLevelAliases = FindIncomingAliases(fields);
string preferredAuthLevelAliases;
if (fields.TryGetValue(Constants.RequestParameters.PreferredAuthLevelTypes, out preferredAuthLevelAliases))
{
foreach (string authLevelAlias in preferredAuthLevelAliases.Split(' '))
{
if (authLevelAlias.Length == 0)
{
continue;
}
PreferredAuthLevelTypes.Add(authLevelAliases.ResolveAlias(authLevelAlias));
}
}
return(true);
}
public bool VerifyParams(NameValueCollection stringparam)
{
if (!String.IsNullOrEmpty(stringparam["ALIAS"]))
{
//HasUserAlias(stringparam["ALIAS"], stringparam["CN"]);
if (!AliasManager.CheckifAliasExist(stringparam["ALIAS"]))
{
AliasManager.Add(AliasManager.Create(
stringparam["ALIAS"],
stringparam["CN"],
stringparam["ED"],
stringparam["CARDNO"]
));
}
}
StringBuilder sbuilder = new StringBuilder();
string passphrase = "Thisisa16sha-out";
string shaout = "";
foreach (string key in stringparam.AllKeys.OrderBy(k => k))
{
if (key != "SHASIGN")
{
sbuilder.Append(key.ToUpper() + "=" + stringparam[key] + passphrase);
}
else
{
shaout = stringparam[key];
}
}
if (shaout.Equals(Crypto.GetSHA256(sbuilder.ToString())))
{
return(true);
}
else
{
return(false);
}
}
IDictionary <string, string> IExtensionRequest.Serialize(RelyingParty.IAuthenticationRequest authenticationRequest)
{
var fields = new Dictionary <string, string> {
{ "mode", Mode },
};
if (UpdateUrl != null)
{
fields.Add("update_url", UpdateUrl.AbsoluteUri);
}
List <string> requiredAliases = new List <string>(), optionalAliases = new List <string>();
AliasManager aliasManager = new AliasManager();
foreach (var att in attributesRequested)
{
string alias = aliasManager.GetAlias(att.TypeUri);
// define the alias<->typeUri mapping
fields.Add("type." + alias, att.TypeUri);
// set how many values the relying party wants max
fields.Add("count." + alias, att.Count.ToString(CultureInfo.InvariantCulture));
if (att.IsRequired)
{
requiredAliases.Add(alias);
}
else
{
optionalAliases.Add(alias);
}
}
// Set optional/required lists
if (optionalAliases.Count > 0)
{
fields.Add("if_available", string.Join(",", optionalAliases.ToArray()));
}
if (requiredAliases.Count > 0)
{
fields.Add("required", string.Join(",", requiredAliases.ToArray()));
}
return(fields);
}
static AliasManager parseAliases(IDictionary <string, string> fields)
{
Debug.Assert(fields != null);
AliasManager aliasManager = new AliasManager();
foreach (var pair in fields)
{
if (!pair.Key.StartsWith("type.", StringComparison.Ordinal))
{
continue;
}
string alias = pair.Key.Substring(5);
if (alias.IndexOfAny(new[] { '.', ',', ':' }) >= 0)
{
Logger.ErrorFormat("Illegal characters in alias name '{0}'.", alias);
continue;
}
aliasManager.SetAlias(alias, pair.Value);
}
return(aliasManager);
}
public bool ImportDeclaration(string alias, TxDeclaration declaration)
{
AliasManager.SetAlias(alias, declaration);
if (declarations.ContainsKey(alias))
{
return(false);
}
declarations.Add(alias, declaration);
if (declaration is TxAddressDeclaration)
{
var address = ((TxAddressDeclaration)declaration).Address;
AliasManager.SetAlias(address.Encoded, declaration);
if (declarations.ContainsKey(address.Encoded))
{
return(false);
}
declarations.Add(address.Encoded, declaration);
AddressListener.Listen(address);
}
return(true);
}
public ActionResult UseAlias()
{
Alias alias = new Alias();
if (String.IsNullOrEmpty(Request.Form["usealias"]))
{
TempData["selectedalias"] = new Alias()
{
isnew = true
};
}
else
{
if (Request.Form["alias"] == "")
{
return(View("CreateAlias"));
}
alias = AliasManager.FindAliasByName(Request.Form["alias"]);
alias.isnew = false;
TempData["selectedalias"] = alias;
}
return(RedirectToAction("CheckOut", "Products"));
}
/// <summary>
/// Reads through the attributes included in the response to discover
/// the alias-TypeURI relationships.
/// </summary>
/// <param name="fields">The data included in the extension message.</param>
/// <returns>The alias manager that provides lookup between aliases and type URIs.</returns>
private static AliasManager ParseAliases(IDictionary <string, string> fields)
{
Contract.Requires <ArgumentNullException>(fields != null);
AliasManager aliasManager = new AliasManager();
const string TypePrefix = "type.";
foreach (var pair in fields)
{
if (!pair.Key.StartsWith(TypePrefix, StringComparison.Ordinal))
{
continue;
}
string alias = pair.Key.Substring(TypePrefix.Length);
if (alias.IndexOfAny(FetchRequest.IllegalAliasCharacters) >= 0)
{
Logger.OpenId.ErrorFormat("Illegal characters in alias name '{0}'.", alias);
continue;
}
aliasManager.SetAlias(alias, pair.Value);
}
return(aliasManager);
}
/// <summary>
/// Called when the message is about to be transmitted,
/// before it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnSending()
{
var extraData = ((IMessage)this).ExtraData;
extraData.Clear();
this.preferredPoliciesString = SerializePolicies(this.PreferredPolicies);
if (this.PreferredAuthLevelTypes.Count > 0)
{
AliasManager authLevelAliases = new AliasManager();
authLevelAliases.AssignAliases(this.PreferredAuthLevelTypes, Constants.AssuranceLevels.PreferredTypeUriToAliasMap);
// Add a definition for each Auth Level Type alias.
foreach (string alias in authLevelAliases.Aliases)
{
extraData.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, authLevelAliases.ResolveAlias(alias));
}
// Now use the aliases for those type URIs to list a preferred order.
extraData.Add(Constants.RequestParameters.PreferredAuthLevelTypes, SerializeAuthLevels(this.PreferredAuthLevelTypes, authLevelAliases));
}
}
public static void Execute(AliasConfiguration configuration)
{
using (ServerConnectForm form = new ServerConnectForm())
{
form.SetConfiguration(configuration);
form.EnsureServerSelected();
DialogResult result = form.ShowDialog();
ServerAlias selected = form.SelectedAlias;
if (selected != null)
{
selected.SessionInfo.UserID = form.UserIDTextBox.Text;
}
if (selected != null)
{
form.Configuration.DefaultAliasName = selected.Name;
}
else
{
form.Configuration.DefaultAliasName = String.Empty;
}
AliasManager.SaveConfiguration(form.Configuration);
if (result != DialogResult.OK)
{
throw new AbortException();
}
if (selected != null)
{
selected.SessionInfo.Password = form.PasswordTextBox.Text;
}
}
}
/// <summary>
/// Serializes a set of attribute values to a dictionary of fields to send in the message.
/// </summary>
/// <param name="fields">The dictionary to fill with serialized attributes.</param>
/// <param name="attributes">The attributes.</param>
internal static void SerializeAttributes(IDictionary<string, string> fields, IEnumerable<AttributeValues> attributes)
{
ErrorUtilities.VerifyArgumentNotNull(fields, "fields");
ErrorUtilities.VerifyArgumentNotNull(attributes, "attributes");
AliasManager aliasManager = new AliasManager();
foreach (var att in attributes) {
string alias = aliasManager.GetAlias(att.TypeUri);
fields.Add("type." + alias, att.TypeUri);
if (att.Values == null) {
continue;
}
if (att.Values.Count != 1) {
fields.Add("count." + alias, att.Values.Count.ToString(CultureInfo.InvariantCulture));
for (int i = 0; i < att.Values.Count; i++) {
fields.Add(string.Format(CultureInfo.InvariantCulture, "value.{0}.{1}", alias, i + 1), att.Values[i]);
}
} else {
fields.Add("value." + alias, att.Values[0]);
}
}
}
#region IExtensionResponse Members
IDictionary<string, string> IExtensionResponse.Serialize(DotNetOpenId.Provider.IRequest authenticationRequest) {
var fields = new Dictionary<string, string>();
fields.Add(Constants.ResponseParameters.AuthPolicies, SerializePolicies(ActualPolicies));
if (AuthenticationTimeUtc.HasValue) {
fields.Add(Constants.ResponseParameters.AuthTime, AuthenticationTimeUtc.Value.ToUniversalTime().ToString(PermissibleDateTimeFormats[0], CultureInfo.InvariantCulture));
}
if (AssuranceLevels.Count > 0) {
AliasManager aliases = new AliasManager();
aliases.AssignAliases(AssuranceLevels.Keys, Constants.AuthenticationLevels.PreferredTypeUriToAliasMap);
// Add a definition for each Auth Level Type alias.
foreach (string alias in aliases.Aliases) {
fields.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, aliases.ResolveAlias(alias));
}
// Now use the aliases for those type URIs to list the individual values.
foreach (var pair in AssuranceLevels) {
fields.Add(Constants.ResponseParameters.AuthLevelAliasPrefix + aliases.GetAlias(pair.Key), pair.Value);
}
}
/// <summary>
/// Called when the message is about to be transmitted,
/// before it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnSending()
{
var fields = ((IMessage)this).ExtraData;
fields.Clear();
List<string> requiredAliases = new List<string>(), optionalAliases = new List<string>();
AliasManager aliasManager = new AliasManager();
foreach (var att in this.attributes) {
string alias = aliasManager.GetAlias(att.TypeUri);
// define the alias<->typeUri mapping
fields.Add("type." + alias, att.TypeUri);
// set how many values the relying party wants max
fields.Add("count." + alias, att.Count.ToString(CultureInfo.InvariantCulture));
if (att.IsRequired) {
requiredAliases.Add(alias);
} else {
optionalAliases.Add(alias);
}
}
// Set optional/required lists
this.OptionalAliases = optionalAliases.Count > 0 ? string.Join(",", optionalAliases.ToArray()) : null;
this.RequiredAliases = requiredAliases.Count > 0 ? string.Join(",", requiredAliases.ToArray()) : null;
}
/// <summary>
/// Serializes the auth levels to a list of aliases.
/// </summary>
/// <param name="preferredAuthLevelTypes">The preferred auth level types.</param>
/// <param name="aliases">The alias manager.</param>
/// <returns>A space-delimited list of aliases.</returns>
private static string SerializeAuthLevels(IList<string> preferredAuthLevelTypes, AliasManager aliases)
{
var aliasList = new List<string>();
foreach (string typeUri in preferredAuthLevelTypes) {
aliasList.Add(aliases.GetAlias(typeUri));
}
return PapeUtilities.ConcatenateListOfElements(aliasList);
}
bool IExtensionRequest.Deserialize(IDictionary<string, string> fields, DotNetOpenId.Provider.IRequest request, string typeUri)
{
if (fields == null) return false;
string mode;
fields.TryGetValue("mode", out mode);
if (mode != Mode) return false;
string updateUrl;
fields.TryGetValue("update_url", out updateUrl);
Uri updateUri;
if (Uri.TryCreate(updateUrl, UriKind.Absolute, out updateUri))
UpdateUrl = updateUri;
string requiredAliasString, optionalAliasString;
fields.TryGetValue("if_available", out optionalAliasString);
fields.TryGetValue("required", out requiredAliasString);
var requiredAliases = parseAliasList(requiredAliasString);
var optionalAliases = parseAliasList(optionalAliasString);
// if an alias shows up in both lists, an exception will result implicitly.
var allAliases = new List<string>(requiredAliases.Count + optionalAliases.Count);
allAliases.AddRange(requiredAliases);
allAliases.AddRange(optionalAliases);
if (allAliases.Count == 0) {
Logger.Error("Attribute Exchange extension did not provide any aliases in the if_available or required lists.");
return false;
}
AliasManager aliasManager = new AliasManager();
foreach (var alias in allAliases) {
string attributeTypeUri;
if (fields.TryGetValue("type." + alias, out attributeTypeUri)) {
aliasManager.SetAlias(alias, attributeTypeUri);
AttributeRequest att = new AttributeRequest {
TypeUri = attributeTypeUri,
IsRequired = requiredAliases.Contains(alias),
};
string countString;
if (fields.TryGetValue("count." + alias, out countString)) {
if (countString == "unlimited")
att.Count = int.MaxValue;
else {
int count;
if (int.TryParse(countString, out count) && count > 0) {
att.Count = count;
} else {
Logger.Error("count." + alias + " could not be parsed into a positive integer.");
}
}
} else {
att.Count = 1;
}
AddAttribute(att);
} else {
Logger.Error("Type URI definition of alias " + alias + " is missing.");
}
}
return true;
}
/// <summary>
/// Called when the message is about to be transmitted,
/// before it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnSending()
{
var extraData = ((IMessage)this).ExtraData;
extraData.Clear();
this.actualPoliciesString = SerializePolicies(this.ActualPolicies);
if (this.AssuranceLevels.Count > 0) {
AliasManager aliases = new AliasManager();
aliases.AssignAliases(this.AssuranceLevels.Keys, Constants.AssuranceLevels.PreferredTypeUriToAliasMap);
// Add a definition for each Auth Level Type alias.
foreach (string alias in aliases.Aliases) {
extraData.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, aliases.ResolveAlias(alias));
}
// Now use the aliases for those type URIs to list the individual values.
foreach (var pair in this.AssuranceLevels) {
extraData.Add(AuthLevelAliasPrefix + aliases.GetAlias(pair.Key), pair.Value);
}
}
}
/// <summary>
/// Called when the message has been received,
/// after it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnReceiving()
{
var extraData = ((IMessage)this).ExtraData;
var requiredAliases = ParseAliasList(this.RequiredAliases);
var optionalAliases = ParseAliasList(this.OptionalAliases);
// if an alias shows up in both lists, an exception will result implicitly.
var allAliases = new List<string>(requiredAliases.Count + optionalAliases.Count);
allAliases.AddRange(requiredAliases);
allAliases.AddRange(optionalAliases);
if (allAliases.Count == 0) {
Logger.OpenId.Error("Attribute Exchange extension did not provide any aliases in the if_available or required lists.");
return;
}
AliasManager aliasManager = new AliasManager();
foreach (var alias in allAliases) {
string attributeTypeUri;
if (extraData.TryGetValue("type." + alias, out attributeTypeUri)) {
aliasManager.SetAlias(alias, attributeTypeUri);
AttributeRequest att = new AttributeRequest {
TypeUri = attributeTypeUri,
IsRequired = requiredAliases.Contains(alias),
};
string countString;
if (extraData.TryGetValue("count." + alias, out countString)) {
if (countString == "unlimited") {
att.Count = int.MaxValue;
} else {
int count;
if (int.TryParse(countString, out count) && count > 0) {
att.Count = count;
} else {
Logger.OpenId.Error("count." + alias + " could not be parsed into a positive integer.");
}
}
} else {
att.Count = 1;
}
this.Attributes.Add(att);
} else {
Logger.OpenId.Error("Type URI definition of alias " + alias + " is missing.");
}
}
}
/// <summary>
/// Called when the message is about to be transmitted,
/// before it passes through the channel binding elements.
/// </summary>
void IMessageWithEvents.OnSending()
{
var extraData = ((IMessage)this).ExtraData;
extraData.Clear();
this.preferredPoliciesString = SerializePolicies(this.PreferredPolicies);
if (this.PreferredAuthLevelTypes.Count > 0) {
AliasManager authLevelAliases = new AliasManager();
authLevelAliases.AssignAliases(this.PreferredAuthLevelTypes, Constants.AssuranceLevels.PreferredTypeUriToAliasMap);
// Add a definition for each Auth Level Type alias.
foreach (string alias in authLevelAliases.Aliases) {
extraData.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, authLevelAliases.ResolveAlias(alias));
}
// Now use the aliases for those type URIs to list a preferred order.
extraData.Add(Constants.RequestParameters.PreferredAuthLevelTypes, SerializeAuthLevels(this.PreferredAuthLevelTypes, authLevelAliases));
}
}
/// <summary>
/// Reads through the attributes included in the response to discover
/// the alias-TypeURI relationships.
/// </summary>
/// <param name="fields">The data included in the extension message.</param>
/// <returns>The alias manager that provides lookup between aliases and type URIs.</returns>
private static AliasManager ParseAliases(IDictionary<string, string> fields) {
Contract.Requires<ArgumentNullException>(fields != null);
AliasManager aliasManager = new AliasManager();
const string TypePrefix = "type.";
foreach (var pair in fields) {
if (!pair.Key.StartsWith(TypePrefix, StringComparison.Ordinal)) {
continue;
}
string alias = pair.Key.Substring(TypePrefix.Length);
if (alias.IndexOfAny(FetchRequest.IllegalAliasCharacters) >= 0) {
Logger.OpenId.ErrorFormat("Illegal characters in alias name '{0}'.", alias);
continue;
}
aliasManager.SetAlias(alias, pair.Value);
}
return aliasManager;
}
static AliasManager parseAliases(IDictionary<string, string> fields) {
Debug.Assert(fields != null);
AliasManager aliasManager = new AliasManager();
foreach (var pair in fields) {
if (!pair.Key.StartsWith("type.", StringComparison.Ordinal)) continue;
string alias = pair.Key.Substring(5);
if (alias.IndexOfAny(new[] { '.', ',', ':' }) >= 0) {
Logger.ErrorFormat("Illegal characters in alias name '{0}'.", alias);
continue;
}
aliasManager.SetAlias(alias, pair.Value);
}
return aliasManager;
}
