コード例 #1
0
        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, Dictionary <string, object> providedParameters,
                                                 bool auth, ArrayParametersSerialization arraySerialization,
                                                 HttpMethodParameterPosition parameterPosition, out SortedDictionary <string, object> uriParameters, out SortedDictionary <string, object> bodyParameters, out Dictionary <string, string> headers)
        {
            var uriParam = new SortedDictionary <string, object>();

            bodyParameters = new();
            uriParameters  = new();
            headers        = new();
            if (parameterPosition == HttpMethodParameterPosition.InBody && method == HttpMethod.Post)
            {
                bodyParameters = new SortedDictionary <string, object>(providedParameters);
            }
            if (parameterPosition == HttpMethodParameterPosition.InUri && method == HttpMethod.Get)
            {
                uriParam = new SortedDictionary <string, object>(providedParameters);
            }

            if (auth)
            {
                if (uri.PathAndQuery.Contains("v3"))
                {
                    headers = AddAuthenticationToHeaders(uri.ToString(), method, providedParameters, auth, parameterPosition, arraySerialization);
                }
                else
                {
                    var uriAuthParam = AddAuthenticationToParameters(uri.ToString(), method, providedParameters, auth, parameterPosition, arraySerialization);
                    foreach (var p in uriAuthParam)
                    {
                        uriParam.Add(p.Key, p.Value);
                    }
                }
            }
            uriParameters = uriParam;
        }
コード例 #2
0
        public ThodexAuthenticationProvider(ApiCredentials credentials, ArrayParametersSerialization arraySerialization) : base(credentials)
        {
            if (credentials.Secret == null)
            {
                throw new ArgumentException("No valid API credentials provided. Key/Secret needed.");
            }

            this.arraySerialization = arraySerialization;
        }
コード例 #3
0
        public BtcTurkAuthenticationProvider(ApiCredentials credentials, ArrayParametersSerialization arraySerialization) : base(credentials)
        {
            if (credentials.Secret == null)
            {
                throw new ArgumentException("No valid API credentials provided. Key/Secret needed.");
            }

            encryptor = new HMACSHA256(Encoding.ASCII.GetBytes(credentials.Secret.GetString()));
            this.arraySerialization = arraySerialization;
        }
コード例 #4
0
        public OkexAuthenticationProvider(ApiCredentials credentials, string passPhrase, bool signPublicRequests, ArrayParametersSerialization arraySerialization) : base(credentials)
        {
            if (credentials == null || credentials.Secret == null)
            {
                throw new ArgumentException("No valid API credentials provided. Key/Secret needed.");
            }

            this.PassPhrase         = passPhrase.ToSecureString();
            this.encryptor          = new HMACSHA256(Encoding.ASCII.GetBytes(credentials.Secret.GetString()));
            this.signPublicRequests = signPublicRequests;
            this.arraySerialization = arraySerialization;
        }
コード例 #5
0
 /// <summary>
 /// Authenticate a request. Output parameters should include the providedParameters input
 /// </summary>
 /// <param name="apiClient">The Api client sending the request</param>
 /// <param name="uri">The uri for the request</param>
 /// <param name="method">The method of the request</param>
 /// <param name="providedParameters">The request parameters</param>
 /// <param name="auth">If the requests should be authenticated</param>
 /// <param name="arraySerialization">Array serialization type</param>
 /// <param name="parameterPosition">The position where the providedParameters should go</param>
 /// <param name="uriParameters">Parameters that need to be in the Uri of the request. Should include the provided parameters if they should go in the uri</param>
 /// <param name="bodyParameters">Parameters that need to be in the body of the request. Should include the provided parameters if they should go in the body</param>
 /// <param name="headers">The headers that should be send with the request</param>
 public abstract void AuthenticateRequest(
     RestApiClient apiClient,
     Uri uri,
     HttpMethod method,
     Dictionary <string, object> providedParameters,
     bool auth,
     ArrayParametersSerialization arraySerialization,
     HttpMethodParameterPosition parameterPosition,
     out SortedDictionary <string, object> uriParameters,
     out SortedDictionary <string, object> bodyParameters,
     out Dictionary <string, string> headers
     );
コード例 #6
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(new Dictionary <string, string>());
            }

            if (Credentials.Key == null)
            {
                throw new ArgumentException("ApiKey/Secret needed");
            }

            var result = new Dictionary <string, string>();

            lock (locker)
                result.Add("Api-Key", Credentials.Key.GetString());
            result.Add("Api-Timestamp", Math.Round((DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds).ToString(CultureInfo.InvariantCulture));
            var jsonContent = "";

            if (method != HttpMethod.Get && method != HttpMethod.Delete)
            {
                jsonContent = JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
            }
            result.Add("Api-Content-Hash", ByteToString(encryptor.ComputeHash(Encoding.UTF8.GetBytes(jsonContent))).ToLower(CultureInfo.InvariantCulture));

            uri = WebUtility.UrlDecode(uri); // Sign needs the query parameters to not be encoded
            var sign = result["Api-Timestamp"] + uri + method + result["Api-Content-Hash"] + "";

            result.Add("Api-Signature", ByteToString(encryptorHmac.ComputeHash(Encoding.UTF8.GetBytes(sign))));
            return(result);
        }
コード例 #7
0
        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, Dictionary <string, object> providedParameters, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, out SortedDictionary <string, object> uriParameters, out SortedDictionary <string, object> bodyParameters, out Dictionary <string, string> headers)
        {
            uriParameters  = parameterPosition == HttpMethodParameterPosition.InUri ? new SortedDictionary <string, object>(providedParameters) : new SortedDictionary <string, object>();
            bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? new SortedDictionary <string, object>(providedParameters) : new SortedDictionary <string, object>();
            headers        = new Dictionary <string, string>();

            if (!auth)
            {
                return;
            }

            var parameters = parameterPosition == HttpMethodParameterPosition.InUri ? uriParameters: bodyParameters;

            parameters.Add("access_id", Credentials.Key !.GetString());
            parameters.Add("tonce", _nonceProvider.GetNonce());
            headers.Add("Authorization", SignMD5(uri.SetParameters(parameters).Query.Replace("?", "") + "&secret_key=" + Credentials.Secret !.GetString()));
        }
コード例 #8
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(new Dictionary <string, string>());
            }

            if (Credentials.Key == null)
            {
                throw new ArgumentException("ApiKey/Secret needed");
            }

            var nonce     = parameters.Single(n => n.Key == "nonce").Value;
            var paramList = parameters.OrderBy(o => o.Key != "nonce");
            var pars      = string.Join("&", paramList.Select(p => $"{p.Key}={p.Value}"));

            var result = new Dictionary <string, string> {
                { "API-Key", Credentials.Key.GetString() }
            };
            var np = nonce + pars;

            byte[] nonceParamsBytes;
            using (var sha = SHA256.Create())
                nonceParamsBytes = sha.ComputeHash(Encoding.UTF8.GetBytes(np));
            var pathBytes = Encoding.UTF8.GetBytes(uri.Split(new[] { ".com" }, StringSplitOptions.None)[1].Split('?')[0]);
            var allBytes  = pathBytes.Concat(nonceParamsBytes).ToArray();
            var sign      = encryptor.ComputeHash(allBytes);

            result.Add("API-Sign", Convert.ToBase64String(sign));
            return(result);
        }
コード例 #9
0
        public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(parameters);
            }

            parameters.Add("nonce", _nonceProvider.GetNonce());
            return(parameters);
        }
コード例 #10
0
        public Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(parameters);
            }
            if (uri.Contains("v2"))
            {
                parameters.Add("access_key", Credentials.Key.GetString());
                var n = Nonce;
                parameters.Add("tonce", n);

                parameters = parameters.OrderBy(p => p.Key).ToDictionary(k => k.Key, v => v.Value);

                var paramString = parameters.CreateParamString(false, ArrayParametersSerialization.MultipleValues);
                var signData    = method + "|";
                signData += uri + "|";
                signData += paramString;
                byte[] signBytes;
                lock (encryptLock)
                    signBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(signData));
                parameters.Add("signature", ByteArrayToString(signBytes));
            }

            return(parameters);
        }
コード例 #11
0
        public override void AuthenticateRequest(RestApiClient apiClient, Uri uri, HttpMethod method, Dictionary <string, object> providedParameters, bool auth, ArrayParametersSerialization arraySerialization, HttpMethodParameterPosition parameterPosition, out SortedDictionary <string, object> uriParameters, out SortedDictionary <string, object> bodyParameters, out Dictionary <string, string> headers)
        {
            uriParameters  = parameterPosition == HttpMethodParameterPosition.InUri ? new SortedDictionary <string, object>(providedParameters) : new SortedDictionary <string, object>();
            bodyParameters = parameterPosition == HttpMethodParameterPosition.InBody ? new SortedDictionary <string, object>(providedParameters) : new SortedDictionary <string, object>();
            headers        = new Dictionary <string, string>();

            if (!auth)
            {
                return;
            }

            // Auth requests are always POST
            if (uri.AbsolutePath.Contains("v1"))
            {
                bodyParameters.Add("request", uri.AbsolutePath);
                bodyParameters.Add("nonce", _nonceProvider.GetNonce().ToString());

                var signature  = JsonConvert.SerializeObject(bodyParameters);
                var payload    = Convert.ToBase64String(Encoding.ASCII.GetBytes(signature));
                var signedData = Sign(payload);

                headers.Add("X-BFX-APIKEY", Credentials.Key !.GetString());
                headers.Add("X-BFX-PAYLOAD", payload);
                headers.Add("X-BFX-SIGNATURE", signedData.ToLower(CultureInfo.InvariantCulture));
            }
            else if (uri.AbsolutePath.Contains("v2"))
            {
                var json       = JsonConvert.SerializeObject(bodyParameters);
                var n          = _nonceProvider.GetNonce().ToString();
                var signature  = $"/api{uri.AbsolutePath}{n}{json}";
                var signedData = SignHMACSHA384(signature);

                headers.Add("bfx-apikey", Credentials.Key !.GetString());
                headers.Add("bfx-nonce", n);
                headers.Add("bfx-signature", signedData.ToLower(CultureInfo.InvariantCulture));
            }
        }
コード例 #12
0
        //Create hmac signature with secretKey as a key and sign request "method+timestamp+url+body"
        //Like as basic authorization add header "Authorization: HS256 " + base64(publicKey+":"+timestamp+":"+signature hex encoded)
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameters, ArrayParametersSerialization arrayParametersSerialization)
        {
            // var time = TimeStamp;

            //if (!signed)
            //    return new Dictionary<string, string>();
            //var result = new Dictionary<string, string>();
            //string additionalData = String.Empty;
            //if (parameters != null && parameters.Any() && method != HttpMethod.Delete && method != HttpMethod.Get)
            //{
            //    additionalData = JsonConvert.SerializeObject(parameters.ToDictionary(p => p.Key, p => p.Value));
            //}
            //var dataToSign = CreateAuthPayload(method, time, uri.Split(new[] { ".com" }, StringSplitOptions.None)[1],  additionalData);
            //var signedData = Sign(dataToSign);
            //var b64 = Base64Encode($"{Credentials.Key.GetString()}:{time}:{signedData}");
            //result.Add("Authorization", $"HS256 {b64}");
            //return result;
            if (!signed)
            {
                return(new Dictionary <string, string>());
            }

            if (Credentials.Key == null)
            {
                throw new ArgumentException("ApiKey/Secret needed");
            }

            if (Credentials.Secret == null)
            {
                throw new ArgumentException("ApiKey/Secret needed");
            }

            var result = new Dictionary <string, string>();

            var encoded = Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(Credentials.Key.GetString() + ":" + Credentials.Secret.GetString()));

            result.Add("Authorization", "Basic " + encoded);

            return(result);
        }
コード例 #13
0
 public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameters, ArrayParametersSerialization arraySerialization)
 {
     return(base.AddAuthenticationToParameters(uri, method, parameters, signed, postParameters, arraySerialization));
 }
コード例 #14
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(new Dictionary <string, string>());
            }

            var result = new Dictionary <string, string>();

            lock (locker)
            {
                parameters.Add("nonce", nonce);
                result.Add("Key", Credentials.Key.GetString());
                var lDataToSign  = ConstructDataToSign(parameters);
                var lSignedValue = ByteToString(encryptor.ComputeHash(Encoding.UTF8.GetBytes(lDataToSign)));
                result.Add("Sign", lSignedValue);
            }
            return(result);
        }
コード例 #15
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameters, ArrayParametersSerialization arrayParametersSerialization)
        {
            var _nonce = Util.Util.GetMillisecondsFromEpochStart();

            if (!signed)
            {
                return(new Dictionary <string, string>());
            }
            var result = new Dictionary <string, string>();

            result.Add("FTX-KEY", Credentials.Key.GetString());
            result.Add("FTX-TS", _nonce.ToString());
            string additionalData = String.Empty;

            if (parameters != null && parameters.Any() && method != HttpMethod.Delete && method != HttpMethod.Get)
            {
                additionalData = JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
            }
            var dataToSign = CreateAuthPayload(method, uri.Split(new[] { ".com" }, StringSplitOptions.None)[1], _nonce, additionalData);
            var signedData = Sign(dataToSign);

            result.Add("FTX-SIGN", signedData);
            result.AddOptionalParameter("FTX-SUBACCOUNT", SubAccount);
            return(result);
        }
コード例 #16
0
        protected virtual IRequest BtcTurkConstructRequest(Uri uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postPosition, ArrayParametersSerialization arraySerialization, int requestId)
        {
            if (parameters == null)
            {
                parameters = new Dictionary <string, object>();
            }

            var uriString = uri.ToString();

            if (authProvider != null)
            {
                parameters = authProvider.AddAuthenticationToParameters(uriString, method, parameters, signed, postPosition, arraySerialization);
            }

            if ((method == HttpMethod.Get || method == HttpMethod.Delete || postParametersPosition == PostParameters.InUri) && parameters?.Any() == true)
            {
                uriString += "?" + parameters.CreateParamString(true, ArrayParametersSerialization.MultipleValues);
            }

            if (method == HttpMethod.Post && signed)
            {
                var uriParamNames = new[] { "AccessKeyId", "SignatureMethod", "SignatureVersion", "Timestamp", "Signature" };
                var uriParams     = parameters.Where(p => uriParamNames.Contains(p.Key)).ToDictionary(k => k.Key, k => k.Value);
                uriString += "?" + uriParams.CreateParamString(true, ArrayParametersSerialization.MultipleValues);
                parameters = parameters.Where(p => !uriParamNames.Contains(p.Key)).ToDictionary(k => k.Key, k => k.Value);
            }

            var request     = RequestFactory.Create(method, uriString, requestId);
            var contentType = requestBodyFormat == RequestBodyFormat.Json ? Constants.JsonContentHeader : Constants.FormContentHeader;

            request.Accept = Constants.JsonContentHeader;

            var headers = new Dictionary <string, string>();

            if (authProvider != null)
            {
                headers = authProvider.AddAuthenticationToHeaders(uriString, method, parameters !, signed, postPosition, arraySerialization);
            }

            foreach (var header in headers)
            {
                request.AddHeader(header.Key, header.Value);
            }

            if ((method == HttpMethod.Post || method == HttpMethod.Put) && postParametersPosition != PostParameters.InUri)
            {
                if (parameters?.Any() == true)
                {
                    WriteParamBody(request, parameters, contentType);
                }
                else
                {
                    request.SetContent("{}", contentType);
                }
            }

            return(request);
        }
コード例 #17
0
 protected override IRequest ConstructRequest(Uri uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postPosition, ArrayParametersSerialization arraySerialization, int requestId)
 {
     return(this.BtcTurkConstructRequest(uri, method, parameters, signed, postPosition, arraySerialization, requestId));
 }
コード例 #18
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(new Dictionary <string, string>());
            }
            if (Credentials.Key == null)
            {
                throw new ArgumentException("No valid API credentials provided. Key/Secret needed.");
            }

            var query = CreateParamOrderedString(parameters, true, arraySerialization);

            return(new Dictionary <string, string> {
                { "Api-Key", Credentials.Key.GetString() },
                { "Sign", ByteToString(encryptor.ComputeHash(Encoding.UTF8.GetBytes(query))) }
            });
        }
コード例 #19
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(new Dictionary <string, string>());
            }

            var result = new Dictionary <string, string>();

            lock (locker)
                result.Add("apisign", ByteToString(encryptor.ComputeHash(Encoding.UTF8.GetBytes(uri))));
            return(result);
        }
コード例 #20
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri,
                                                                               HttpMethod method, Dictionary <string, object> parameters, bool signed,
                                                                               PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(new Dictionary <string, string>());
            }

            if (ExanteCredentials.ApplicationId is null ||
                ExanteCredentials.ClientId is null ||
                ExanteCredentials.SharedKey is null)
            {
                throw new ArgumentException("No valid API credentials");
            }

            var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(ExanteCredentials.SharedKey));
            var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
            var payload     = new JwtPayload(ExanteCredentials.ClientId,
                                             null,
                                             new[]
            {
                new Claim(JwtRegisteredClaimNames.Sub, ExanteCredentials.ApplicationId),
                new Claim(JwtRegisteredClaimNames.Iss, ExanteCredentials.ClientId),
            },
                                             new Dictionary <string, object> {
                { JwtRegisteredClaimNames.Aud, tokenPermissions }
            },
                                             null,
                                             DateTime.UtcNow.AddHours(1),
                                             DateTime.UtcNow
                                             );
            var securityToken = new JwtSecurityToken(new JwtHeader(credentials), payload);
            var token         = new JwtSecurityTokenHandler().WriteToken(securityToken);

            return(new Dictionary <string, string>
            {
                { "Authorization", $"Bearer {token}" }
            });
        }
コード例 #21
0
        public Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(new Dictionary <string, string>());
            }

            var result = new Dictionary <string, string>();

            if (uri.Contains("v3"))
            {
                var json = JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
                if (string.IsNullOrEmpty(json) && method == HttpMethod.Post)
                {
                    json = "{}";
                }
                var n          = Nonce;
                var signature  = $"{uri.Split(new[] { ".io" }, StringSplitOptions.None)[1]}{n}{json}";
                var signedData = SignV3(signature);

                result.Add("kun-apikey", Credentials.Key.GetString());
                result.Add("kun-nonce", n);
                result.Add("kun-signature", signedData.ToLower());
            }

            return(result);
        }
コード例 #22
0
        public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed && !signPublicRequests)
            {
                return(parameters);
            }

            if (Credentials.Key == null)
            {
                throw new ArgumentException("ApiKey/secret not provided");
            }

            var uriObj         = new Uri(uri);
            var signParameters = new Dictionary <string, object>
            {
                { "AccessKeyId", Credentials.Key.GetString() },
                { "SignatureMethod", "HmacSHA256" },
                { "SignatureVersion", 2 }
            };

            if (!parameters.ContainsKey("Timestamp") || method != HttpMethod.Get)
            {
                signParameters.Add("Timestamp", DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss"));
            }

            if (method == HttpMethod.Get)
            {
                foreach (var kvp in parameters)
                {
                    signParameters.Add(kvp.Key, kvp.Value);
                }
            }

            signParameters = signParameters.OrderBy(kv => Encoding.UTF8.GetBytes(WebUtility.UrlEncode(kv.Key)), new ByteOrderComparer()).ToDictionary(k => k.Key, k => k.Value);

            var paramString = signParameters.CreateParamString(true, ArrayParametersSerialization.MultipleValues);

            signParameters = signParameters.OrderBy(kv => kv.Key).ToDictionary(k => k.Key, k => k.Value);

            var absolutePath = uriObj.AbsolutePath;

            if (absolutePath.StartsWith("/api"))
            {
                // Russian api has /api prefix which shouldn't be part of the signature
                absolutePath = absolutePath.Substring(4);
            }

            var signData = method + "\n";

            signData += uriObj.Host + "\n";
            signData += absolutePath + "\n";
            signData += paramString;
            byte[] signBytes;
            lock (encryptLock)
                signBytes = encryptor.ComputeHash(Encoding.UTF8.GetBytes(signData));
            signParameters.Add("Signature", Convert.ToBase64String(signBytes));

            if (method != HttpMethod.Get)
            {
                foreach (var kvp in parameters)
                {
                    signParameters.Add(kvp.Key, kvp.Value);
                }
            }

            return(signParameters);
        }
コード例 #23
0
 public BinanceAuthenticationProvider(ApiCredentials credentials, ArrayParametersSerialization arraySerialization) : base(credentials)
 {
     encryptor = new HMACSHA256(Encoding.ASCII.GetBytes(credentials.Secret.GetString()));
     this.arraySerialization = arraySerialization;
 }
コード例 #24
0
        /// <summary>
        /// Create a query string of the specified parameters
        /// </summary>
        /// <param name="parameters">The parameters to use</param>
        /// <param name="urlEncodeValues">Whether or not the values should be url encoded</param>
        /// <param name="serializationType">How to serialize array parameters</param>
        /// <returns></returns>
        private static string CreateParamOrderedString(Dictionary <string, object> parameters, bool urlEncodeValues, ArrayParametersSerialization serializationType)
        {
            var uriString = "";

            foreach (var entry in parameters.OrderBy(kp => kp.Key).ToList())
            {
                if (entry.Value.GetType().IsArray)
                {
                    if (serializationType == ArrayParametersSerialization.Array)
                    {
                        uriString += $"{string.Join("&", ((object[])(urlEncodeValues ? Uri.EscapeDataString(entry.Value.ToString()) : entry.Value)).Select(v => $"{entry.Key}[]={v}"))}&";
                    }
                    else
                    {
                        var array = (Array)entry.Value;
                        uriString += string.Join("&", array.OfType <object>().Select(a => $"{entry.Key}={Uri.EscapeDataString(a.ToString())}"));
                        uriString += "&";
                    }
                }
                else
                {
                    uriString += $"{entry.Key}={(urlEncodeValues ? Uri.EscapeDataString(entry.Value.ToString()) : entry.Value)}";
                    uriString += "&";
                }
            }
            uriString = uriString.TrimEnd('&');
            return(uriString);
        }
コード例 #25
0
        /// <summary>
        /// Create a query string of the specified parameters
        /// </summary>
        /// <param name="parameters">The parameters to use</param>
        /// <param name="urlEncodeValues">Whether or not the values should be url encoded</param>
        /// <param name="serializationType">How to serialize array parameters</param>
        /// <returns></returns>
        public static string CreateParamString(this Dictionary <string, object> parameters, bool urlEncodeValues, ArrayParametersSerialization serializationType)
        {
            var uriString        = "";
            var arraysParameters = parameters.Where(p => p.Value.GetType().IsArray).ToList();

            foreach (var arrayEntry in arraysParameters)
            {
                if (serializationType == ArrayParametersSerialization.Array)
                {
                    uriString += $"{string.Join("&", ((object[])(urlEncodeValues ? WebUtility.UrlEncode(arrayEntry.Value.ToString()) : arrayEntry.Value)).Select(v => $"{arrayEntry.Key}[]={v}"))}&";
                }
                else
                {
                    var array = (Array)arrayEntry.Value;
                    uriString += string.Join("&", array.OfType <object>().Select(a => $"{arrayEntry.Key}={WebUtility.UrlEncode(a.ToString())}"));
                    uriString += "&";
                }
            }

            uriString += $"{string.Join("&", parameters.Where(p => !p.Value.GetType().IsArray).Select(s => $"{s.Key}={(urlEncodeValues ? WebUtility.UrlEncode(s.Value.ToString()) : s.Value)}"))}";
            uriString  = uriString.TrimEnd('&');
            return(uriString);
        }
コード例 #26
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed && !signPublicRequests)
            {
                return(new Dictionary <string, string>());
            }

            if (Credentials == null || Credentials.Key == null || this.PassPhrase == null)
            {
                throw new ArgumentException("No valid API credentials provided. Key/Secret/PassPhrase needed.");
            }

            var time     = (DateTime.UtcNow.ToUnixTimeMilliSeconds() / 1000.0m).ToString(CultureInfo.InvariantCulture);
            var signtext = time + method.Method.ToUpper() + uri.Replace("https://www.okex.com", "").Trim('?');

            if (method == HttpMethod.Post)
            {
                var bodyString = JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
                signtext = signtext + bodyString;
            }

            var signature = OkexAuthenticationProvider.Base64Encode(encryptor.ComputeHash(Encoding.UTF8.GetBytes(signtext)));

            return(new Dictionary <string, string> {
                { "OK-ACCESS-KEY", Credentials.Key.GetString() },
                { "OK-ACCESS-SIGN", signature },
                { "OK-ACCESS-TIMESTAMP", time },
                { "OK-ACCESS-PASSPHRASE", this.PassPhrase.GetString() },
            });
        }
コード例 #27
0
        public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, HttpMethodParameterPosition parameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed && !signPublicRequests)
            {
                return(parameters);
            }

            return(SignRequest(uri, method, parameters,
                               "AccessKeyId", "SignatureMethod", "SignatureVersion", "Timestamp", "Signature", 2));
        }
コード例 #28
0
        public override Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (Credentials.Key == null)
            {
                throw new ArgumentException("ApiKey/Secret needed");
            }

            var result = new Dictionary <string, string>();

            if (!signed)
            {
                return(result);
            }

            if (uri.Contains("v1"))
            {
                var signature = JsonConvert.SerializeObject(parameters);

                var payload    = Convert.ToBase64String(Encoding.ASCII.GetBytes(signature));
                var signedData = Sign(payload);

                result.Add("X-BFX-APIKEY", Credentials.Key.GetString());
                result.Add("X-BFX-PAYLOAD", payload);
                result.Add("X-BFX-SIGNATURE", signedData.ToLower(CultureInfo.InvariantCulture));
            }
            else if (uri.Contains("v2"))
            {
                var json       = JsonConvert.SerializeObject(parameters.OrderBy(p => p.Key).ToDictionary(p => p.Key, p => p.Value));
                var n          = BitfinexSocketClient.Nonce;
                var signature  = $"/api{uri.Split(new[] { ".com" }, StringSplitOptions.None)[1]}{n}{json}";
                var signedData = Sign(signature);

                result.Add("bfx-apikey", Credentials.Key.GetString());
                result.Add("bfx-nonce", n);
                result.Add("bfx-signature", signedData.ToLower(CultureInfo.InvariantCulture));
            }

            return(result);
        }
コード例 #29
0
 /// <summary>
 /// Add authentication to the header dictionary
 /// </summary>
 /// <param name="uri"></param>
 /// <param name="method"></param>
 /// <param name="parameters"></param>
 /// <param name="signed"></param>
 /// <param name="postParameterPosition"></param>
 /// <param name="arraySerialization"></param>
 /// <returns></returns>
 public virtual Dictionary <string, string> AddAuthenticationToHeaders(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed,
                                                                       PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
 {
     return(new Dictionary <string, string>());
 }
コード例 #30
0
        public override Dictionary <string, object> AddAuthenticationToParameters(string uri, HttpMethod method, Dictionary <string, object> parameters, bool signed, PostParameters postParameterPosition, ArrayParametersSerialization arraySerialization)
        {
            if (!signed)
            {
                return(parameters);
            }

            if (uri.Contains("v1"))
            {
                parameters.Add("request", uri.Split(new[] { ".com" }, StringSplitOptions.None)[1]);
                parameters.Add("nonce", BitfinexSocketClient.Nonce);
            }
            else if (uri.Contains("v2"))
            {
                // Nothing
            }

            return(parameters);
        }