ShodanClient.cs

using Newtonsoft.Json;
using Shodan.Net.Models;
using Shodan.Net.Models.Options;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

namespace Shodan.Net
{
    public class ShodanClient : IShodanAsyncClient, IDisposable
    {
        private readonly string apikey;
        private const string BasePath = "https://api.shodan.io";
        private IRequstHandler RequestHandler = new RequestHandler();

        //todo error handle!!!

        public ShodanClient(string apikey)
        {
            if(string.IsNullOrWhiteSpace(apikey))
            {
                throw new ArgumentNullException(nameof(apikey));
            }
            this.apikey = apikey;
        }

        internal ShodanClient(string apikey, IRequstHandler requestHandler)
            : this(apikey)
        {
            RequestHandler = requestHandler;
        }

        public Task<Dictionary<string, string>> DnsLookupAsync(string hostnames)
        {
            if(string.IsNullOrWhiteSpace(hostnames))
            {
                throw new ArgumentNullException(hostnames);
            }
            var url = new Uri($"{BasePath}/dns/resolve?hostnames={hostnames}&key={this.apikey}");
            return RequestHandler.MakeRequestAsync<Dictionary<string, string>>(url);
        }

        public Task<SearchHostResults> SearchHosts(Action<QueryGenerator> query, Action<FacetGenerator> facet = null, int page = 1, bool minify = true)
        {
            if(query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
            var queryGenerator = new QueryGenerator();
            query.Invoke(queryGenerator);
            var queryResult = queryGenerator.Generate();
            var url = new UriBuilder($"{BasePath}/shodan/host/search")
            {
                Query = $"key={apikey}&query={queryResult}&minify={minify.ToString()}"
            };
            if(facet != null)
            {
                var facetGenerator = new FacetGenerator();
                facet.Invoke(facetGenerator);
                url.Query = $"{url.Query}&facets={facetGenerator.GenerateFacets()}";
            }
            if(page > 1)
            {
                url.Query = $"{url.Query}&page={page}";
            }
            return RequestHandler.MakeRequestAsync<SearchHostResults>(url.Uri);
        }

        public Task<SearchHostResults> SearchHostsCount(Action<QueryGenerator> query, Action<FacetGenerator> facet = null)
        {
            if(query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
            var queryGenObj = new QueryGenerator();
            query.Invoke(queryGenObj);

            var url = new UriBuilder($"{BasePath}/shodan/host/count")
            {
                Query = $"key={apikey}&query={queryGenObj.Generate()}"
            };
            if(facet != null)
            {
                var facetGenObj = new FacetGenerator();
                facet.Invoke(facetGenObj);

                url.Query = $"{url.Query}&facets={facetGenObj.GenerateFacets()}";
            }

            return RequestHandler.MakeRequestAsync<SearchHostResults>(url.Uri);
        }

        public Task<SearchTokens> SearchTokens(Action<QueryGenerator> query)
        {
            if(query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
            var queryObj = new QueryGenerator();
            query.Invoke(queryObj);
            var url = new Uri($"{BasePath}/shodan/host/search/tokens?key={apikey}&query={queryObj.Generate()}");
            return RequestHandler.MakeRequestAsync<SearchTokens>(url);
        }

        public async Task<double> Experimental_GetHoneyPotScoreAsync(string ip)
        {
            if(string.IsNullOrWhiteSpace(ip))
            {
                throw new ArgumentNullException(nameof(ip));
            }
            var url = new Uri($"{BasePath}/labs/honeyscore/{ip}?key={apikey}");
            var result = await RequestHandler.MakeRequestAsync<string>(url);
            double resultParsed;
            if(!double.TryParse(result, out resultParsed))
            {
                throw new ShodanException($"honeypot score returned with {result} failed to parse to double");
            }
            return resultParsed;
        }

        public Task<ApiStatus> GetApiStatusAsync()
        {
            var url = new Uri($"{BasePath}/api-info?key={apikey}");
            return RequestHandler.MakeRequestAsync<ApiStatus>(url);
        }

        public Task<Host> GetHostAsync(string Ip, bool history = false, bool minify = false)
        {
            if(string.IsNullOrWhiteSpace(Ip))
            {
                throw new ArgumentNullException(nameof(Ip));
            }
            var builder = new UriBuilder($"{BasePath}/shodan/host/{Ip}")
            {
                Query = $"key={this.apikey}&history={history.ToString()}&minify={minify.ToString()}"
            };

            return RequestHandler.MakeRequestAsync<Host>(builder.Uri);
        }

        public Task<string> GetMyIpAsync()
        {
            var url = new Uri($"{BasePath}/tools/myip?key={this.apikey}");
            return RequestHandler.MakeRequestAsync<string>(url);
        }

        public Task<List<int>> GetPortsAsync()
        {
            var builder = new Uri($"{BasePath}/shodan/ports?key={this.apikey}");
            return RequestHandler.MakeRequestAsync<List<int>>(builder);
        }

        public Task<Profile> GetProfileAsync()
        {
            var url = new Uri($"{BasePath}/account/profile?key={apikey}");
            return RequestHandler.MakeRequestAsync<Profile>(url);
        }

        public Task<Dictionary<string, string>> GetProtocolsAsync()
        {
            var url = new Uri($"{BasePath}/shodan/protocols?key={this.apikey}");
            return RequestHandler.MakeRequestAsync<Dictionary<string, string>>(url);
        }

        public Task<SearchQueries> GetQueriesAsync(int? page = null, SortOptions? sort = null, OrderOption? order = null)
        {
            var url = new UriBuilder($"{BasePath}/shodan/query")
            {
                Query = $"key={apikey}"
            };
            if(sort.HasValue)
            {
                var sortName = Enum.GetName(typeof(SortOptions), sort.Value);
                url.Query = $"{url.Query}&sort={sortName}";
            }
            if(order.HasValue)
            {
                var orderName = Enum.GetName(typeof(OrderOption), order.Value);
                url.Query = $"{url.Query}&order={orderName}";
            }
            return RequestHandler.MakeRequestAsync<SearchQueries>(url.Uri);
        }

        public Task<SearchQueries> SearchQueriesAsync(string query, int? page = null)
        {
            if(string.IsNullOrWhiteSpace(query))
            {
                throw new ArgumentNullException(query);
            }
            var url = new UriBuilder($"{BasePath}/shodan/query/search")
            {
                Query = $"key={apikey}&query={query}"
            };
            if(page != null)
            {
                url.Query = $"{url.Query}&page={page}";
            }
            return RequestHandler.MakeRequestAsync<SearchQueries>(url.Uri);
        }

        public Task<ScanStatus> GetScanStatusAsync(string id)
        {
            if(string.IsNullOrWhiteSpace(id))
            {
                throw new ArgumentNullException(nameof(id));
            }
            var url = new Uri($"{BasePath}/shodan/scan/{id}");
            return RequestHandler.MakeRequestAsync<ScanStatus>(url);
        }

        public Task<Dictionary<string, string>> GetServicesAsync()
        {
            var url = new Uri($"{BasePath}/shodan/services?key={this.apikey}");
            return RequestHandler.MakeRequestAsync<Dictionary<string, string>>(url);
        }

        public Task<TagResult> GetTagsAsync(int size = 10)
        {
            var url = new UriBuilder($"{BasePath}/shodan/query/tags")
            {
                Query = $"key={apikey}&size={size}"
            };
            return RequestHandler.MakeRequestAsync<TagResult>(url.Uri);
        }

        public Task<ScanPortResult> RequestInternetPortScanAsync(int port, string protocol)
        {
            var url = new Uri($"{BasePath}/shodan/scan/internet?key={this.apikey}");
            using(var data = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>() {
                new KeyValuePair<string, string>("port", port.ToString()),
                new KeyValuePair<string, string>("protocol", protocol)
            }))
            {
                return RequestHandler.MakeRequestAsync<ScanPortResult>(url, data, RequestType.POST);
            }
        }

        public Task<ScanResult> RequstScanAsync(string ips)
        {
            if(string.IsNullOrWhiteSpace(ips))
            {
                throw new ArgumentNullException(nameof(ips));
            }
            if(!ips.Split(',').Any())
            {
                throw new ArgumentOutOfRangeException($"{ips} must have one valid record");
            }
            var url = new Uri($"{BasePath}/shodan/scan?key={this.apikey}");
            using(var data = new FormUrlEncodedContent(new KeyValuePair<string, string>[] { new KeyValuePair<string, string>("ips", ips) }))
            {
                return RequestHandler.MakeRequestAsync<ScanResult>(url, data, RequestType.POST);
            }
        }

        public Task<Dictionary<string, List<string>>> ReverseLookupAsync(string ips)
        {
            if(string.IsNullOrWhiteSpace(ips))
            {
                throw new ArgumentNullException(ips);
            }
            var url = new Uri($"{BasePath}/dns/reverse?ips={ips}&key={this.apikey}");
            return RequestHandler.MakeRequestAsync<Dictionary<string, List<string>>>(url);
        }

        #region IDisposable Support

        private bool disposedValue = false; // To detect redundant calls

        protected virtual void Dispose(bool disposing)
        {
            if(!disposedValue)
            {
                if(disposing)
                {
                    RequestHandler.Dispose();
                }

                disposedValue = true;
            }
        }

        // This code added to correctly implement the disposable pattern.
        public void Dispose()
        {
            // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
            Dispose(true);
            // TODO: uncomment the following line if the finalizer is overridden above.
            // GC.SuppressFinalize(this);
        }

        #endregion IDisposable Support
    }
}