1E SDK

This page contains a code example written in C# that demonstrates interactive authentication. This code sample should be adapted by the customer when writing their own integration software.

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

namespace InteractiveAuthenticationClient
{
    public class Program
    {
        private const string ApiRoot = "https://your.tachyon.server.address/api/";
        private const string RequestAuthenticationEndpoint = "Authentication/RequestAuthentication?ecpn={0}";
        private const string CheckAuthenticationStateEndpoint = "Authentication/CheckAuthenticationState";
        
        static void Main(string[] args)
        {
            Console.WriteLine("Creating authentication nonce...");
            // Prepare nonce
            var nonce = CreateNonce(); // original nonce, never supplied to any api
            var basedNonce = ToUrlSafeBase64(nonce); // base64 encoded nonce, used when retrieving a token
            var hashedNonce = CreateSha256(nonce); // hash of the original nonce, never supplied to any api
            var basedHashedNonce = ToUrlSafeBase64(hashedNonce); // base64 encoded has of the nonce, to be supplied in the original authentication request
            using (var client = new HttpClient())
            {
                var endpoint = ApiRoot + string.Format(RequestAuthenticationEndpoint, basedHashedNonce);
                Console.WriteLine($"Calling {endpoint} to initiate authentication");
                AuthRequestResponse obj = Get<AuthRequestResponse>(client, endpoint);
                if (obj != null)
                {
                    if (!string.IsNullOrEmpty(obj.AuthenticationUrl))
                    {
                        Console.WriteLine($"Received authentication URL {obj.AuthenticationUrl} and state {obj.State}. Opening web browser for the user to complete authentication process.");
                        OpenBrowser(obj.AuthenticationUrl);
                        string token = LoopForToken(obj.State, basedNonce);
                        if (token != null)
                        {
                            Console.WriteLine($"Token retrieved: {token}");
                        }
                        else
                        {
                            Console.WriteLine("Token could not be retrieved. Please try again.");
                        }
                    }
                }
            }
        }

        private static string LoopForToken(string objState, string basedNonce)
        {
            var continueLoop = true;
            string retVal = null;
            var endpoint = ApiRoot + CheckAuthenticationStateEndpoint;
            using (var client = new HttpClient())
            {
                while (continueLoop)
                {
                    var payload = new AuthenticationCheckRequestPayload
                    {
                        State = objState
                    };
                    var result = Post<AuthenticationEvent, AuthenticationCheckRequestPayload>(client, payload, endpoint);
                    if (result != null)
                    {
                        switch (result.Status)
                        {
                            case "AuthenticationResultNotAvailable":
                            {
                                // There's an issue with the request. Either the state is incorrect or you tried to retrieve the token incorrectly or it already has been redeemed.
                                // You will need to initiate new authentication request as you cannot continue with this one.
                                Console.WriteLine("Something went wrong during the authentication process. Please start a new authentication process.");
                                continueLoop = false;
                                break;
                            }
                            case "AuthenticationRequested":
                            {
                                Console.WriteLine("Authentication process is still in progress. Will try again in a few seconds.");
                                Thread.Sleep(2000);
                                // Authentication request is still being processed.
                                break;
                            }
                            case "AuthenticationSuccessful":
                            {
                                Console.WriteLine("Authentication process has finished. Retrieving token...");
                                // Authentication has been successful and token can be retrieved.
                                var payload2 = new AuthenticationCheckRequestPayload
                                {
                                    State = objState,
                                    Nonce = basedNonce
                                };
                                var result2 = Post<AuthenticationEvent, AuthenticationCheckRequestPayload>(client, payload2, endpoint);
                                if (result2 != null)
                                {
                                    retVal = result2.Data;
                                }
                                else
                                {
                                    Console.WriteLine("Failed to retrieve token.");
                                }

                                continueLoop = false;
                                break;
                            }
                        }
                    }
                    else
                    {
                        Console.WriteLine("Call to retrieve authentication request has failed.");
                        continueLoop = false;
                    }
                }
            }

            return retVal;
        }

        private static byte[] CreateSha256(byte[] buffer)
        {
            using (var sha256 = new SHA256CryptoServiceProvider())
            {
                return sha256.ComputeHash(buffer);
            }
        }

        private static byte[] CreateNonce()
        {
            byte[] nonce = new byte[32];
            Random rand = new Random();
            rand.NextBytes(nonce);
            return nonce;
        }

        private static string ToUrlSafeBase64(byte[] arg)
        {
            var Base64PadCharacter = '=';
            var Base64Character62 = '+';
            var Base64Character63 = '/';
            var Base64UrlCharacter62 = '-';
            var Base64UrlCharacter63 = '_';

            var s = Convert.ToBase64String(arg);
            s = s.Split(Base64PadCharacter)[0]; // RemoveAccount any trailing padding
            s = s.Replace(Base64Character62, Base64UrlCharacter62); // 62nd char of encoding
            s = s.Replace(Base64Character63, Base64UrlCharacter63); // 63rd char of encoding

            return s;
        }

        public static void OpenBrowser(string url)
        {
            try
            {
                Process.Start(url);
            }
            catch
            {
                // hack because of this: https://github.com/dotnet/corefx/issues/10361
                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                {
                    url = url.Replace("&", "^&");
                    Process.Start(new ProcessStartInfo("cmd", $"/c start {url}") { CreateNoWindow = true });
                }
                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
                {
                    Process.Start("xdg-open", url);
                }
                else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                {
                    Process.Start("open", url);
                }
                else
                {
                    throw;
                }
            }
        }

        private static T Get<T>(HttpClient client, string url)
        {
            var result = client.GetAsync(url).Result;
            if (result.IsSuccessStatusCode)
            {
                var data = result.Content.ReadAsStringAsync().Result;
                if (!string.IsNullOrEmpty(data))
                {
                    T obj = JsonSerializer.Deserialize<T>(data);
                    if (obj != null)
                    {
                        return obj;
                    }
                }
            }

            return default;
        }

        private static TOut Post<TOut, TIn>(HttpClient client, TIn payload, string url)
        {
            var stream = new MemoryStream();
            JsonSerializer.Serialize(stream, payload);
            stream.Seek(0, SeekOrigin.Begin);
            var reader = new StreamReader(stream);
            var serializedPayload = reader.ReadToEnd();
            reader.Close();
            stream.Close();
            var content = new StringContent(serializedPayload, Encoding.UTF8, "application/json");
            var result = client.PostAsync(url, content).Result;
            if (result.IsSuccessStatusCode)
            {
                var data = result.Content.ReadAsStringAsync().Result;
                if (!string.IsNullOrEmpty(data))
                {
                    TOut obj = JsonSerializer.Deserialize<TOut>(data);
                    if (obj != null)
                    {
                        return obj;
                    }
                }
            }

            return default;
        }

        private static string Post<TIn>(HttpClient client, TIn payload, string url)
        {
            var stream = new MemoryStream();
            JsonSerializer.Serialize(stream, payload);
            stream.Seek(0, SeekOrigin.Begin);
            var reader = new StreamReader(stream);
            var serializedPayload = reader.ReadToEnd();
            reader.Close();
            stream.Close();
            var content = new StringContent(serializedPayload, Encoding.UTF8, "application/json");
            var result = client.PostAsync(url, content).Result;
            if (result.IsSuccessStatusCode)
            {
                return result.Content.ReadAsStringAsync().Result;
            }

            return default;
        }

        private class AuthRequestResponse
        {
            public string AuthenticationUrl { get; set; }
            public string State { get; set; }
        }

        private class AuthenticationCheckRequestPayload
        {
            public string State { get; set; }
            public string? Nonce { get; set; }
        }

        private class AuthenticationEvent
        {
            public string Status { get; set; }

            public string Data { get; set; }
        }
    }
}