private static DropboxClientConfig GetConfig()
{
return(new DropboxClientConfig
{
HttpClient = ProxyTools.CreateHttpClient()
});
}
public static ACD.AmazonDrive GetApi()
{
var api = new ACD.AmazonDrive(AmazonDriveClientId, AmazonDriveClientSecret)
{
Proxy = ProxyTools.GetProxy()
};
return(api);
}
internal async Task <AccountSession> ProcessCachedAccountSessionAsync(AccountSession accountSession)
{
using (var httpProvider = new HttpProvider(ProxyTools.CreateHttpClientHandler(), true))
{
var processedAccountSession = await this.ProcessCachedAccountSessionAsync(accountSession, httpProvider).ConfigureAwait(false);
return(processedAccountSession);
}
}
private static HttpClient GetHttpClient(string accessToken)
{
var httpClient = ProxyTools.CreateHttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
httpClient.DefaultRequestHeaders.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
httpClient.DefaultRequestHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
return(httpClient);
}
private HttpClient GetClient()
{
var client = ProxyTools.CreateHttpClient();
client.DefaultRequestHeaders.Add("X-Auth-Token", _credentials.Token);
client.DefaultRequestHeaders.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
client.DefaultRequestHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
return(client);
}
public static DropboxClient GetApi(string accessToken)
{
var config = new DropboxClientConfig
{
HttpClient = ProxyTools.CreateHttpClient()
};
var api = new DropboxClient(accessToken, config);
return(api);
}
public static async Task <IGraphServiceClient> GetApi(AccountSession accountSession)
{
var authProvider = new OneDriveAuthenticationProvider(
OneDriveClientId,
OneDriveClientSecret);
await authProvider.AuthenticateByAccountSessionAsync(accountSession);
var httpProvider = new HttpProvider(ProxyTools.CreateHttpClientHandler(), true);
var api = new GraphServiceClient(ApiUrl, authProvider, httpProvider);
return(api);
}
public static async Task <OAuth2Token> ProcessCodeFlowAsync(string code)
{
if (string.IsNullOrEmpty(code))
{
throw new ArgumentNullException("code");
}
var httpClient = ProxyTools.CreateHttpClient();
try
{
var parameters = new Dictionary <string, string>
{
{ "code", code },
{ "grant_type", "authorization_code" },
{ "client_id", HubiCClientId },
{ "client_secret", HubiCClientSecret }
};
if (!string.IsNullOrEmpty(RedirectUri))
{
parameters["redirect_uri"] = RedirectUri;
}
var content = new FormUrlEncodedContent(parameters);
var response = await httpClient.PostAsync(TokenUri, content);
var raw = await response.Content.ReadAsStringAsync();
var json = JObject.Parse(raw);
return(new OAuth2Token(
json["access_token"].ToString(),
json["token_type"].ToString(),
json["expires_in"].Value <int>(),
json["refresh_token"].ToString()));
}
finally
{
httpClient.Dispose();
}
}
public static async Task <IGraphServiceClient> GetApi(AccountConfiguration account)
{
if (Cache.ContainsKey(account.Id))
{
return(Cache[account.Id]);
}
var authProvider = new OneDriveAuthenticationProvider(
OneDriveClientId,
OneDriveClientSecret);
await authProvider.AuthenticateByRefreshTokenAsync(account.Secret);
var httpProvider = new HttpProvider(ProxyTools.CreateHttpClientHandler(), true);
var api = new GraphServiceClient(ApiUrl, authProvider, httpProvider);
Cache.Add(account.Id, api);
return(api);
}
public static async Task <IGraphServiceClient> GetApi(AccountConfiguration account)
{
if (Cache.ContainsKey(account.Id))
{
return(Cache[account.Id]);
}
var authProvider = new OneDriveAuthenticationProvider(CreateOidcFlow(), account.Secret);
var httpProvider = new HttpProvider(ProxyTools.CreateHttpClientHandler(), true)
{
OverallTimeout = Timeout.InfiniteTimeSpan
};
var api = new GraphServiceClient(authProvider, httpProvider);
Cache.Add(account.Id, api);
return(api);
}
private void OnFormLoad(object sender, EventArgs e)
{
GlobalWindowManager.AddWindow(this);
this.Icon = PluginResources.Icon_OneDrive_16x16;
if (_isUpgraded)
{
this.Text = "KeeAnywhere upgraded";
BannerFactory.CreateBannerEx(this, m_bannerImage,
PluginResources.KeeAnywhere_48x48, "KeeAnywhere has been upgraded",
"Please check changelog and adjust your settings if needed.");
}
else
{
this.Text = "KeeAnywhere Changelog";
BannerFactory.CreateBannerEx(this, m_bannerImage,
PluginResources.KeeAnywhere_48x48, "KeeAnywhere Changelog",
"See detailed changes for each version.");
}
var wc = new WebClient {
Proxy = ProxyTools.GetProxy()
};
var version = this.GetVersionTag();
var url = string.Format("https://raw.githubusercontent.com/Kyrodan/KeeAnywhere/{0}/CHANGELOG.md", version);
try
{
var markdown = wc.DownloadString(url);
var html = CommonMark.CommonMarkConverter.Convert(markdown);
m_browser.DocumentText = html;
}
catch
{
//Ignore
}
m_btnOpenSettings.Visible = _isUpgraded;
}
private static void ApplyProxy(ClientConfig config)
{
var proxyAddress = KeePass.Program.Config.Integration.ProxyAddress;
var proxyPort = KeePass.Program.Config.Integration.ProxyPort;
var proxyType = KeePass.Program.Config.Integration.ProxyType;
if (proxyType == ProxyServerType.Manual)
{
if (!string.IsNullOrEmpty(proxyAddress))
{
config.ProxyHost = proxyAddress;
}
if (!string.IsNullOrEmpty(proxyPort))
{
config.ProxyPort = int.Parse(proxyPort);
}
config.ProxyCredentials = ProxyTools.GetKeePassProxyCredentials();
}
else if (proxyType == ProxyServerType.System)
{
if (config.RegionEndpoint == null)
{
return;
}
var systemProxy = System.Net.WebRequest.DefaultWebProxy;
var endpoint = config.RegionEndpoint.GetEndpointForService("s3");
var uri = new Uri("https://" + endpoint.Hostname);
if (systemProxy.IsBypassed(uri))
{
return;
}
var proxyHost = systemProxy.GetProxy(uri);
config.ProxyHost = proxyHost.Host;
config.ProxyPort = proxyHost.Port;
config.ProxyCredentials = systemProxy.Credentials;
}
}
public async Task <bool> Claim(Uri uri, string documentTitle)
{
var authenticationResponseValues = UrlHelper.GetQueryOptions(uri);
OAuthErrorHandler.ThrowIfError(authenticationResponseValues);
string code;
if (authenticationResponseValues != null && authenticationResponseValues.TryGetValue("code", out code))
{
using (var httpProvider = new HttpProvider(ProxyTools.CreateHttpClientHandler(), true))
{
_accountSession =
await
_oAuthHelper.RedeemAuthorizationCodeAsync(code, OneDriveHelper.OneDriveClientId,
OneDriveHelper.OneDriveClientSecret, this.RedirectionUrl.ToString(), OneDriveHelper.Scopes,
httpProvider).ConfigureAwait(false);
}
}
return(_accountSession != null);
}
private OidcClientOptions CreateBaseOptions()
{
var scopes = string.Join(" ", m_scopes);
var options = new OidcClientOptions
{
Authority = m_authority, ///.well-known/openid-configuration
ClientId = m_clientId,
ClientSecret = m_clientSecret,
Scope = scopes,
Flow = OidcClientOptions.AuthenticationFlow.AuthorizationCode,
ResponseMode = OidcClientOptions.AuthorizeResponseMode.FormPost,
RefreshTokenInnerHttpHandler = ProxyTools.CreateHttpClientHandler(),
BackchannelHandler = ProxyTools.CreateHttpClientHandler(),
LoadProfile = false
};
options.Policy.Discovery.ValidateEndpoints = false;
options.Policy.Discovery.ValidateIssuerName = false;
return(options);
}
//public async Task<AccountConfiguration> CreateAccount()
//{
// var type = _isAccessRestricted ? StorageType.DropboxRestricted : StorageType.Dropbox;
// var clientId = _isAccessRestricted ? DropboxHelper.DropboxAppFolderOnlyClientId : DropboxHelper.DropboxFullAccessClientId;
// var clientSecret = _isAccessRestricted ? DropboxHelper.DropboxAppFolderOnlyClientSecret : DropboxHelper.DropboxFullAccessClientSecret;
// string[] scopes =
// {
// "account_info.read",
// "files.metadata.write",
// "files.metadata.read",
// "files.content.write",
// "files.content.read"
// };
// var flow = new OidcFlow(type, clientId, clientSecret, scopes, 50001, 50005);
// return await flow.AuthorizeOauth2Async("https://www.dropbox.com/oauth2/authorize", "https://api.dropboxapi.com/oauth2/token");
//}
public async Task <AccountConfiguration> CreateAccount()
{
var f = new OidcWaitForm();
f.InitEx(_isAccessRestricted ? StorageType.DropboxRestricted : StorageType.Dropbox);
f.Show();
var clientId = _isAccessRestricted ? DropboxHelper.DropboxAppFolderOnlyClientId : DropboxHelper.DropboxFullAccessClientId;
var clientSecret = _isAccessRestricted ? DropboxHelper.DropboxAppFolderOnlyClientSecret : DropboxHelper.DropboxFullAccessClientSecret;
string[] scopes =
{
"account_info.read",
"files.metadata.write",
"files.metadata.read",
"files.content.write",
"files.content.read"
};
var ports = Enumerable.Range(49306, 10)
.Concat(Enumerable.Range(49996, 10))
.Concat(Enumerable.Range(63900, 10));
var browser = new OidcSystemBrowser(ports);
var redirectUri = browser.RedirectUri;
var state = Guid.NewGuid().ToString("N");
var codeVerifier = db.DropboxOAuth2Helper.GeneratePKCECodeVerifier();
var codeChallenge = db.DropboxOAuth2Helper.GeneratePKCECodeChallenge(codeVerifier);
var uri = db.DropboxOAuth2Helper.GetAuthorizeUri(db.OAuthResponseType.Code, clientId, redirectUri, state, false, false, null, false, db.TokenAccessType.Offline, scopes, db.IncludeGrantedScopes.None, codeChallenge);
var query = await browser.GetQueryStringAsync(uri.ToString(), f.CancellationToken);
var resultState = query["state"];
if (state != resultState)
{
throw new Exception("MiM-Attack?");
}
var code = query["code"];
var response = await db.DropboxOAuth2Helper.ProcessCodeFlowAsync(code, clientId, null, redirectUri, ProxyTools.CreateHttpClient(), codeVerifier);
var api = DropboxHelper.GetApi(response.AccessToken);
var owner = await api.Users.GetCurrentAccountAsync();
var account = new AccountConfiguration()
{
Id = owner.AccountId,
Name = owner.Name.DisplayName,
Type = _isAccessRestricted ? StorageType.DropboxRestricted : StorageType.Dropbox,
Secret = response.RefreshToken,
};
f.Close();
return(account);
}
