Firehose and OBO Support

apiClientDotNet/Authentication/AuthEndpointConstants.cs

@@ -15,5 +15,15 @@ public class AuthEndpointConstants
         public static String SESSIONAPPAUTH = "/sessionauth/v1/app/authenticate";
         public static String OBOUSERAUTH = "/sessionauth/v1/app/user/{uid}/authenticate";
         public static String OBOUSERAUTHUSERNAME = "/sessionauth/v1/app/username/{username}/authenticate";
+        public const string HttpsPrefix = "https://";
+        public const string SessionAuthPath = "/sessionauth/v1/authenticate";
+        public const string KeyAuthPath = "/keyauth/v1/authenticate";
+        public const string LogoutPath = "/sessionauth/v1/logout";
+        public const string RsaSessionAuthPath = "/login/pubkey/authenticate";
+        public const string RsaKeyManagerAuthPath = "/relay/pubkey/authenticate";
+        public const string OBOAppSessionAuthPath = "/sessionauth/v1/app/authenticate";
+        public const string OBOAppSessionRSAAuthPath = "/login/pubkey/app/authenticate";
+        public const string OboUserAuthByIdPath = "/login/pubkey/app/user/{uid}/authenticate";
+        public const string OboUserAuthByUsernamePath = "/login/pubkey/app/username/{username}/authenticate";
     }
 }

apiClientDotNet/Authentication/SymAuthBase.cs

@@ -0,0 +1,160 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Security.Cryptography.X509Certificates;
+using apiClientDotNet.Models;
+using apiClientDotNet.Utils;
+
+namespace apiClientDotNet.Authentication
+{
+    public abstract class SymAuthBase : ISymAuth
+    {
+        protected string SessionToken;
+        protected string KeyManagerToken;
+        protected SymConfig SymConfig;
+        private HttpClient SessionAuthClient;
+        private HttpClient KeyAuthClient;
+        private HttpClient CertificateSessionAuthClient;
+        private HttpClient CertificateKeyAuthClient;
+        private HttpClient CertificateOBOSessionAuthClient;
+
+        protected HttpClient GetCertificateSessionAuthClient() {
+            if (CertificateSessionAuthClient == null) {
+                if (SymConfig.botCertPath != "" && SymConfig.botCertName != "") {
+                    string botCertificatePath = SymConfig.botCertPath + SymConfig.botCertName;
+                    if (!File.Exists(botCertificatePath) && File.Exists(botCertificatePath + ".p12")) {
+                        botCertificatePath = botCertificatePath + ".p12";
+                    }
+                    else  {
+                        throw new FileNotFoundException("File not found: " + botCertificatePath);
+                    }
+                    CertificateSessionAuthClient = CreateHttpClient(SymConfig.sessionAuthHost, SymConfig.sessionAuthPort, SymConfig.sessionProxyURL, SymConfig.sessionProxyUsername, SymConfig.sessionProxyPassword, botCertificatePath, SymConfig.botCertPassword);
+                }
+                else {
+                    throw new MissingFieldException("botCertPath and botCertName not specified");
+                }
+            }
+            return CertificateSessionAuthClient;
+        }
+
+        protected HttpClient GetSessionAuthClient() {
+            if (SessionAuthClient == null) {
+                SessionAuthClient = CreateHttpClient(SymConfig.podHost, SymConfig.podPort, SymConfig.podProxyURL, SymConfig.podProxyUsername, SymConfig.podProxyPassword, null, null);
+            }
+            return SessionAuthClient;
+        }
+
+        protected HttpClient GetCertificateKeyAuthClient(){
+            if (CertificateKeyAuthClient == null) {
+                if (SymConfig.botCertPath != "" && SymConfig.botCertName != "") {
+                    string botCertificatePath = SymConfig.botCertPath + SymConfig.botCertName;
+                    if (!File.Exists(botCertificatePath) && File.Exists(botCertificatePath + ".p12")) {
+                        botCertificatePath = botCertificatePath + ".p12";
+                    }
+                    else  {
+                        throw new FileNotFoundException("File not found: " + botCertificatePath);
+                    }
+                    CertificateKeyAuthClient = CreateHttpClient(SymConfig.keyAuthHost, SymConfig.keyAuthPort, SymConfig.keyManagerProxyURL, SymConfig.keyManagerProxyUsername, SymConfig.keyManagerProxyPassword, botCertificatePath, SymConfig.botCertPassword);
+                }
+                else {
+                    throw new MissingFieldException("botCertPath and botCertName not specified");
+                }
+            }
+            return CertificateKeyAuthClient;
+        }
+
+        protected HttpClient GetKeyAuthClient() {
+            if (KeyAuthClient == null) {
+                KeyAuthClient = CreateHttpClient(SymConfig.keyAuthHost, SymConfig.keyAuthPort, SymConfig.keyManagerProxyURL, SymConfig.keyManagerProxyUsername, SymConfig.keyManagerProxyPassword, null, null);
+            }
+            return KeyAuthClient;
+        }
+
+        protected HttpClient GetCertificateOBOSessionAuthClient(){
+            if (CertificateOBOSessionAuthClient == null) {
+                if (SymConfig.appCertPath != "" && SymConfig.appCertName != "") {
+                    string appCertificatePath = SymConfig.appCertPath + SymConfig.appCertName;
+                    if (!File.Exists(appCertificatePath) && File.Exists(appCertificatePath + ".p12")) {
+                        appCertificatePath = SymConfig.appCertPath + SymConfig.appCertName + ".p12";
+                    }
+                    else  {
+                        throw new FileNotFoundException("File not found: " + appCertificatePath);
+                    }
+                    CertificateOBOSessionAuthClient = CreateHttpClient(SymConfig.sessionAuthHost, SymConfig.sessionAuthPort, SymConfig.sessionProxyURL, SymConfig.sessionProxyUsername, SymConfig.sessionProxyPassword, appCertificatePath, SymConfig.appCertPassword);
+                }
+                else {
+                    throw new MissingFieldException("appCertPath and appCertName not specified");
+                }
+            }
+            return CertificateOBOSessionAuthClient;
+        }
+
+        protected HttpClient GetOBOSessionAuthClient() {
+            return GetSessionAuthClient();
+        }
+
+        private HttpClient CreateHttpClient(string authUrl, int authPort, string proxyUrl, string proxyUsername, string proxyPassword, string certificatePath, string certificatePassword) {
+            var requestHandler = new HttpClientHandler();
+            if (!string.IsNullOrEmpty(proxyUrl)) {
+                requestHandler.Proxy = RequestProxyBuilder.CreateWebProxy(proxyUrl, proxyUsername, proxyPassword);
+            }
+            else if (!string.IsNullOrEmpty(SymConfig.proxyURL)) {
+                requestHandler.Proxy = RequestProxyBuilder.CreateWebProxy(SymConfig.proxyURL, SymConfig.proxyUsername, SymConfig.proxyPassword);
+            }
+            if (certificatePath != null) {
+                var certificate = File.ReadAllBytes(certificatePath);
+                requestHandler.ClientCertificates.Add(new X509Certificate2(certificate, certificatePassword));
+            }
+            var httpClient = new HttpClient(requestHandler);
+            httpClient.BaseAddress = new UriBuilder("https", authUrl, authPort).Uri;
+            return httpClient;
+        }
+
+        public virtual string GetSessionToken() 
+        {
+            return SessionToken;
+        }
+
+        public string getSessionToken(){
+            return GetSessionToken();
+        }
+
+        public virtual void SetSessionToken(string sessionToken) 
+        {
+            SessionToken = sessionToken;
+        }
+
+        public void setSessionToken(string sessionToken){
+            SetSessionToken(sessionToken);
+        }
+
+        public abstract void Authenticate();
+        public void authenticate(){
+            Authenticate();
+        }
+        public abstract void SessionAuthenticate();
+        public void sessionAuthenticate(){
+            SessionAuthenticate();
+        }
+        public abstract void KeyManagerAuthenticate();
+        public void kmAuthenticate(){
+            KeyManagerAuthenticate();
+        }
+        public abstract string GetKeyManagerToken();
+        public string getKmToken(){
+            return GetKeyManagerToken();
+        }
+        public abstract void SetKeyManagerToken(string kmToken);
+        public void setKmToken(string kmToken){
+            SetKeyManagerToken (kmToken);
+        }
+        public abstract void Logout();
+        public void logout(){
+            Logout();
+        }
+
+        public SymConfig GetSymConfig() {
+            return SymConfig;
+        }
+    }
+}

apiClientDotNet/Authentication/SymOBOAuth.cs

@@ -1,57 +1,32 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using apiClientDotNet.Models;
-using Newtonsoft.Json.Linq;
-using apiClientDotNet.Utils;
-using System.Net;
+using System.Net.Http;
+using Newtonsoft.Json;
 
-namespace apiClientDotNet.Authentication
+
+namespace apiClientDotNet.Authentication 
 {
 
-    public class SymOBOAuth 
+    public class SymOBOAuth : SymOBOAuthBase
     {
-        AuthTokens authTokens;
-        private String sessionToken;
-        private String kmToken;
-        private SymConfig symConfig;
-
-        public SymOBOAuth(SymConfig config)
-        {
-            symConfig = config;
-            authTokens = new AuthTokens();
-        }
-
-        public SymOBOUserAuth getUserAuth(String username)
+
+        public SymOBOAuth(SymConfig config) 
         {
-            SymOBOUserAuth userAuth = new SymOBOUserAuth(symConfig, username, this);
-            userAuth.authenticate();
-            authTokens.sessionToken = userAuth.getSessionToken();
-            sessionToken = userAuth.getSessionToken();
-            return userAuth;
+            SymConfig = config;
         }
 
-        public SymOBOUserAuth getUserAuth(long uid)
+        public override void SessionAuthenticate() 
         {
-            SymOBOUserAuth userAuth = new SymOBOUserAuth(symConfig,
-                    uid, this);
-            userAuth.authenticate();
-            return userAuth;
+            var response = GetCertificateOBOSessionAuthClient().PostAsync(AuthEndpointConstants.OBOAppSessionAuthPath, null).Result;
+            if (response.IsSuccessStatusCode)
+            {
+                var result = response.Content.ReadAsStringAsync().Result;
+                SessionToken = JsonConvert.DeserializeObject<Token>(result).token;
+            }
+            else 
+            {
+                SessionToken = null;
+            }
         }
-
-        public void sessionAppAuthenticate()
-        {
-            RestRequestHandler restRequestHandler = new RestRequestHandler();
-            string url = "https://" + symConfig.sessionAuthHost + ":" + symConfig.sessionAuthPort + AuthEndpointConstants.SESSIONAPPAUTH;
-            HttpWebResponse resp = restRequestHandler.executeRequest(null, url, true, WebRequestMethods.Http.Post, symConfig, false);
-            string body = restRequestHandler.ReadResponse(resp);
-            resp.Close();
-            JObject o = JObject.Parse(body);
-            authTokens.sessionToken = (string)o["token"];
-            sessionToken = authTokens.sessionToken;
-            symConfig.authTokens = authTokens;
-        }
-
-
     }
 }

apiClientDotNet/Authentication/SymOBOAuthBase.cs

@@ -0,0 +1,50 @@
+using System;
+using apiClientDotNet.Models;
+using System.Net.Http;
+using Newtonsoft.Json;
+
+
+namespace apiClientDotNet.Authentication 
+{
+
+    public abstract class SymOBOAuthBase : SymAuthBase
+    {
+        public string AppSessionToken
+        { 
+            get { return SessionToken; }
+            set { SessionToken = value; }
+        }
+
+        public SymOBOUserAuth GetUserAuth(string username) 
+        {
+            SymOBOUserAuth userAuth = new SymOBOUserAuth(username, this);
+            userAuth.Authenticate();
+            return userAuth;
+        }
+
+        public SymOBOUserAuth GetUserAuth(long uid) 
+        {
+            SymOBOUserAuth userAuth = new SymOBOUserAuth(uid, this);
+            userAuth.Authenticate();
+            return userAuth;
+        }
+
+        public override void Authenticate()
+        {
+            SessionAuthenticate();
+        }
+
+        public override void KeyManagerAuthenticate() {}
+        public override string GetKeyManagerToken()
+        {
+            return null;
+        }
+
+        public override void SetKeyManagerToken(string kmToken) {}
+
+        public override void Logout()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

apiClientDotNet/Authentication/SymOBORSAAuth.cs

@@ -0,0 +1,36 @@
+using System.Net.Http;
+using Newtonsoft.Json;
+using apiClientDotNet.Utils;
+using apiClientDotNet.Models;
+
+namespace apiClientDotNet.Authentication 
+{
+
+    public class SymOBORSAAuth : SymOBOAuthBase
+    {
+
+        public SymOBORSAAuth(SymConfig config) 
+        {
+            SymConfig = config;
+        }
+
+        public override void SessionAuthenticate() 
+        {
+            JWTHandler jwtHandler = new JWTHandler();
+            var token = new 
+            {
+                token = jwtHandler.generateJWT(SymConfig.appId, SymConfig.appPrivateKeyPath + SymConfig.appPrivateKeyName)
+            };
+            var response = GetSessionAuthClient().PostAsync(AuthEndpointConstants.OBOAppSessionRSAAuthPath, new StringContent(JsonConvert.SerializeObject(token))).Result;
+            if (response.IsSuccessStatusCode)
+            {
+                var result = response.Content.ReadAsStringAsync().Result;
+                SessionToken = JsonConvert.DeserializeObject<Token>(result).token;
+            }
+            else 
+            {
+                SessionToken = null;
+            }
+        }
+    }
+}