public void can_log_failed_authentication()
{
var providerId = Guid.NewGuid();
const string providerName = "TestProvider";
const string ipAddress = "127.0.0.1";
var provider = new ExternalProvider(
providerId,
providerName,
_command);
provider.NotAuthenticatedInvalidCredentials(ipAddress);
var events = provider.TakeEvents();
Assert.Collection(
events,
e => Assert.IsType <ExternalProviderMsgs.ProviderCreated>(e),
e =>
{
if (e is ExternalProviderMsgs.AuthenticationFailedInvalidCredentials failed)
{
Assert.Equal(providerId, failed.ProviderId);
Assert.Equal(ipAddress, failed.HostIPAddress);
}
else
{
throw new Exception("wrong event.");
}
});
}
public void can_add_external_provider()
{
var providerId = Guid.NewGuid();
const string providerName = "TestProvider";
var provider = new ExternalProvider(
providerId,
providerName,
_command);
var events = provider.TakeEvents();
Assert.Collection(
events,
e =>
{
if (e is ExternalProviderMsgs.ProviderCreated created)
{
Assert.Equal(providerId, created.ProviderId);
Assert.Equal(providerName, created.ProviderName);
}
else
{
throw new Exception("wrong event.");
}
});
}
private static bool HandlerArgs(string[] args)
{
bool endApp = false;
if (args.Length > 0)
{
Log.Notice("Program CLI", "App started as CLI with " + args.Length + " args");
for (int i = 0; i < args.Length; i++)
{
switch (args[i])
{
case "--set-status":
i++;
if (i > args.Length)
{
throw new Exception("New status not found");
}
string status = args[i];
endApp = true;
ExternalProvider.WriteStatusFile(status);
break;
}
}
}
return(endApp);
}
private dynamic AuthorizeByExternalProvider(ProviderAndAccessToken model, ExternalProvider externalProvider)
{
IKernel kernel = Infrastructure.DependencyResolver.GetKernel();
IOauthProvider oauthProvider = kernel.Get <IOauthProvider>(externalProvider.ToString());
try
{
dynamic userData = oauthProvider.Authorize(model);
userData.userName = userData.userData.userName.Replace(" ", "");
if (!userData.userName.ToString().Contains("@")) //google already adds @gmail.com to returned data so this should be optional.
{
userData.userName = userData.userName + "@" + externalProvider.ToString() + ".com";
}
return(userData);
}
catch (Exception ex)
{
HttpContent contentPost = new StringContent("Facebook : " + ex.Message, Encoding.UTF8, "application/text");
var msg = new HttpResponseMessage(HttpStatusCode.Unauthorized)
{
Content = contentPost
};
throw new HttpResponseException(msg);
}
}
private void SetKindName(ExternalProvider provider)
{
var hanlderType = _serializer.DeserializeType(provider.SerializedHandlerType);
var optionsType = hanlderType.GetAuthenticationSchemeOptionsType();
provider.KindName = optionsType.Name.Replace("Options", "");
}
public static ExternalProvider GetExternalProviderImpl(string service)
{
ExternalProvider externalProviderImpl = null;
if (GetGXServices() != null)
{
GXService providerService = GetGXServices().Get(service);
if (providerService != null)
{
try
{
string typeFullName = providerService.ClassName;
GXLogging.Debug(log, "Loading storage provider:", typeFullName);
#if !NETCORE
Type type = Type.GetType(typeFullName, true, true);
#else
Type type = new AssemblyLoader(FileUtil.GetStartupDirectory()).GetType(typeFullName);
#endif
externalProviderImpl = (ExternalProvider)Activator.CreateInstance(type);
}
catch (Exception e)
{
GXLogging.Error(log, "Couldn´t connect to external storage provider.", e.Message, e);
throw e;
}
}
}
return(externalProviderImpl);
}
public GxExternalFileInfo(string storageObjectFullname, ExternalProvider provider, GxFileType fileType)
{
storageObjectFullname = storageObjectFullname != null?storageObjectFullname.Replace('\\', '/') : storageObjectFullname;
_name = storageObjectFullname;
_provider = provider;
Uri result;
if (Uri.TryCreate(storageObjectFullname, UriKind.Absolute, out result) && result.IsAbsoluteUri)
{
_url = storageObjectFullname;
}
else
{
if (fileType.HasFlag(GxFileType.Attribute)) //Attributes multimedia consider Storage Provider Folder
{
_url = provider.GetBaseURL() + storageObjectFullname;
_name = _url.Replace(provider.StorageUri, string.Empty);
if (_name.StartsWith("/"))
{
_name = _name.Substring(1, _name.Length - 1);
}
}
}
_fileTypeAtt = fileType;
}
public GxExternalFileInfo(string storageObjectFullname, string url, ExternalProvider provider, GxFileType fileType = GxFileType.Public)
{
_name = storageObjectFullname;
_provider = provider;
_url = url;
_fileTypeAtt = fileType;
}
public ExternalAccount(ExternalProvider provider, string name, string externalId, Guid profileId)
{
Provider = provider;
Name = name;
ExternalId = externalId;
UserProfileId = profileId;
}
public async Task <ExternalProvider> UpdateAsync(ExternalProvider entity, CancellationToken cancellationToken = default)
{
await _manager.UpdateAsync(CreateSchemeDefinition(entity), cancellationToken).ConfigureAwait(false);
await _providerClient.ProviderUpdatedAsync(entity.Id, cancellationToken).ConfigureAwait(false);
return(entity);
}
public static ExternalProvider GetExternalProvider()
{
if (externalProvider == null)
{
externalProvider = GetExternalProviderImpl(GXServices.STORAGE_SERVICE);
}
return(externalProvider);
}
public WsFederationOptionsValidator(ExternalProvider _, IStringLocalizer localizer)
{
RuleFor(m => m.MetadataAddress).NotEmpty().WithMessage(localizer["Metadata address is required."]);
RuleFor(m => m.MetadataAddress).Uri().WithMessage(localizer["Metadata address must be a valid uri."]);
RuleFor(m => m.MetadataAddress).Must((options, value) => !options.RequireHttpsMetadata || value.ToUpperInvariant().StartsWith("HTTPS"))
.WithMessage(localizer["Metadata address must be a valid HTTPS url when 'required https metadata is true'."]);
RuleFor(m => m.Wtrealm).NotEmpty().WithMessage(localizer["Wtrealm is required."]);
}
protected void SignInWith(ExternalProvider provider)
{
if (!string.IsNullOrEmpty(ReturnUrl))
{
ReturnUrl = Uri.EscapeDataString(ReturnUrl);
}
navigationManager.NavigateTo($"{navigationManager.BaseUri}api/externalauth/challenge/{provider.AuthenticationScheme}/{ReturnUrl}", true);
}
public ExternalProviderCredentials(ExternalProvider type, string consumerKey, string consumerSecret)
{
if (string.IsNullOrWhiteSpace(consumerKey)) throw new ArgumentNullException("consumerKey");
if (string.IsNullOrWhiteSpace(consumerSecret)) throw new ArgumentNullException("consumerSecret");
Type = type;
ConsumerKey = consumerKey;
ConsumerSecret = consumerSecret;
}
public OAuthOptionsValidator(ExternalProvider _, IStringLocalizer localizer)
{
RuleFor(m => m.ClientId).NotEmpty().WithMessage(localizer["Client Id is required."]);
RuleFor(m => m.AuthorizationEndpoint).NotEmpty().WithMessage(localizer["Authorization endpoint is required."]);
RuleFor(m => m.AuthorizationEndpoint).Uri().WithMessage(localizer["Authorization endpoint must be a valid uri."]);
RuleFor(m => m.TokenEndpoint).NotEmpty().WithMessage(localizer["Token endpoint is required."]);
RuleFor(m => m.TokenEndpoint).Uri().WithMessage(localizer["Token endpoint must be a valid uri."]);
RuleFor(m => m.UserInformationEndpoint).NotEmpty().WithMessage(localizer["User information endpoint is required."]);
RuleFor(m => m.UserInformationEndpoint).Uri().WithMessage(localizer["User information endpoint must be a valid uri."]);
}
private TSchemeDefinition FromEntity(ExternalProvider entity)
{
var hanlderType = _serializer.DeserializeType(entity.SerializedHandlerType);
return(new TSchemeDefinition
{
Scheme = entity.Id,
DisplayName = entity.DisplayName,
HandlerType = hanlderType,
Options = _serializer.DeserializeOptions(entity.SerializedOptions, hanlderType.GetAuthenticationSchemeOptionsType())
});
}
private SchemeDefinition CreateSchemeDefinition(ExternalProvider entity)
{
var handlerType = _serializer.DeserializeType(entity.SerializedHandlerType);
return(new()
{
DisplayName = entity.DisplayName,
HandlerType = handlerType,
Options = _serializer.DeserializeOptions(entity.SerializedOptions, handlerType.GetAuthenticationSchemeOptionsType()),
Scheme = entity.Id
});
}
public async Task Subscribe_should_subcribe_to_hub_events()
{
var waitHandle = new ManualResetEvent(false);
var configuration = new Dictionary <string, string>
{
["ApiAuthentication:Authority"] = "http://localhost",
["SignalR:HubUrl"] = "http://localhost/providerhub",
["SignalR:UseMessagePack"] = "false"
};
TestServer server = null;
server = TestUtils.CreateTestServer(services =>
{
services.RemoveAll <HubHttpMessageHandlerAccessor>();
services.AddTransient(p => new HubHttpMessageHandlerAccessor {
Handler = new MockHttpMessageHandler(waitHandle, server.CreateHandler())
});
services.RemoveAll <HttpClient>();
services.AddTransient(p => server.CreateClient());
services.RemoveAll <HttpClientHandler>();
services.AddTransient <HttpClientHandler>(p => new MockHttpClientHandler(p.GetRequiredService <HttpClient>()));
}, configuration);
server.CreateWebSocketClient();
Assert.True(waitHandle.WaitOne(5000));
var provider = server.Host.Services;
var store = provider.GetRequiredService <IAdminStore <ExternalProvider> >();
var serializer = provider.GetRequiredService <IAuthenticationSchemeOptionsSerializer>();
var extProvider = new ExternalProvider
{
DisplayName = "Google",
Id = "google",
KindName = "Google",
SerializedHandlerType = serializer.SerializeType(typeof(GoogleHandler)),
SerializedOptions = serializer.SerializeOptions(new GoogleOptions(), typeof(GoogleOptions))
};
provider.GetRequiredService <IConfiguration>()["SignalR:HubUrl"] = null;
await store.CreateAsync(extProvider).ConfigureAwait(false);
await store.UpdateAsync(extProvider).ConfigureAwait(false);
await store.DeleteAsync("google").ConfigureAwait(false);
await Task.Delay(1000).ConfigureAwait(false);
}
public static void Start()
{
Log.Debug("App", "App is starting");
ExternalProvider.RegisterHost();
Started = true;
FirstTime = true;
Waiting = false;
Stopping = false;
Aborting = false;
InitStatus = null;
LastSong = null;
Task t = Task.Run(Run);
}
public IHttpActionResult ExternalLogin(string provider, string error = null)
{
if (error != null)
{
return(BadRequest(Uri.EscapeDataString(error)));
}
if (!User.Identity.IsAuthenticated)
{
return(new ExternalAuthenticationChallengeResult(provider, this));
}
string redirectUri;
bool isValidUri = CommonValidations.TryParseRedirectUri(Request, out redirectUri);
if (isValidUri == false)
{
if (string.IsNullOrEmpty(redirectUri))
{
return(BadRequest("Invalid redirect URI(redirect_uri)."));
}
return(BadRequest(redirectUri));
}
try
{
ExternalData externalLoginData = new ExternalData(User.Identity as ClaimsIdentity);
if (externalLoginData == null)
{
return(InternalServerError());
}
if (externalLoginData.LoginProvider != provider)
{
ExternalProvider.SignOut(Request, DefaultAuthenticationTypes.ExternalCookie);
return(new ExternalAuthenticationChallengeResult(provider, this));
}
externalLoginData.LocalBearerToken = GenerateLocalAccessTokenResponse(User.Identity as ClaimsIdentity);
redirectUri = ExternalProvider.GetCompleteRedirectUri(redirectUri, externalLoginData);
return(Redirect(redirectUri));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public static object Resolve(Type type, ConstructorArgument[] parameters = null)
{
IKernel provider = null;
if ((bool)InternalProvider.CanResolve(type))
{
provider = InternalProvider;
}
else if ((bool)ExternalProvider.CanResolve(type))
{
provider = ExternalProvider;
}
return(Resolve(provider, type, parameters));
}
public static T Resolve <T>(ConstructorArgument[] parameters = null)
{
IKernel provider = null;
if (InternalProvider.CanResolve <T>())
{
provider = InternalProvider;
}
else if ((ExternalProvider != null) && (ExternalProvider.CanResolve <T>()))
{
provider = ExternalProvider;
}
return((T)(Resolve(provider, typeof(T), parameters)));
}
public ExternalProviderCredentials(ExternalProvider type, string consumerKey, string consumerSecret)
{
if (string.IsNullOrWhiteSpace(consumerKey))
{
throw new ArgumentNullException("consumerKey");
}
if (string.IsNullOrWhiteSpace(consumerSecret))
{
throw new ArgumentNullException("consumerSecret");
}
Type = type;
ConsumerKey = consumerKey;
ConsumerSecret = consumerSecret;
}
public static ExternalProvider GetExternalProviderFromUrl(string url, out string objectName)
{
objectName = null;
ExternalProvider provider = ServiceFactory.GetExternalProvider();
if (provider != null)
{
if (provider.GetObjectNameFromURL(url, out objectName))
{
var questionMarkIndex = objectName.IndexOf(QUESTION_MARK);
objectName = questionMarkIndex >= 0 ? objectName.Substring(0, questionMarkIndex): objectName.Substring(0);
return(provider);
}
}
return(null);
}
public async Task <IActionResult> SignIn([FromBody] ExternalProvider provider)
{
if (provider == null || string.IsNullOrWhiteSpace(provider.Name))
{
return(BadRequest());
}
if (!await HttpContext.IsProviderSupportedAsync(provider.Name))
{
return(BadRequest());
}
return(Challenge(new AuthenticationProperties {
RedirectUri = "/"
}, provider.Name));
}
public GoogleOptionsValidator(ExternalProvider _, IStringLocalizer localizer)
{
RuleFor(m => m.ClientId).NotEmpty().WithMessage(localizer["Client Id is required."]);
RuleFor(m => m.ClientSecret).NotEmpty().WithMessage(localizer["Client Secret is required."]);
}
public FacebookOptionsValidator(ExternalProvider _)
{
RuleFor(m => m.AppId).NotEmpty().WithMessage("Client Id is required.");
RuleFor(m => m.AppSecret).NotEmpty().WithMessage("Client Secret is required.");
}
public async Task <ServiceResult <ConnectionDetail> > GetConnection(Guid userId, ExternalProvider provider)
{
var result = new ServiceResult <ConnectionDetail>();
var connection = await context.ExternalAccount.FirstOrDefaultAsync(ea => ea.UserProfileId.Equals(userId) && ea.Provider.Equals(provider));
if (connection == null)
{
result.Error = Shared.ErrorKey.UserProfile.ExternalAccountNotFound;
return(result);
}
result.Succeed(AutoMapper.Mapper.Map <ConnectionDetail>(connection));
return(result);
}
public WrapProvider(ExternalProvider provider)
{
Id = provider.Id;
DisplayName = provider.DisplayName;
KindName = provider.KindName;
}
public bool TryGetExternalAccount(ExternalProvider provider, out ExternalAccount account)
{
account = this.ExternalAccounts.FirstOrDefault(ea => ea.Provider == provider);
return(account != null);
}
public ExternalAccount GetExternalAccount(ExternalProvider provider)
{
return(this.ExternalAccounts.FirstOrDefault(ea => ea.Provider == provider));
}
public SocialProvider this[ExternalProvider type]
{
get { return (SocialProvider) BaseGet(type); }
}
