Pistitium.Payloader 1.0.4

Pistitium.Payloader

Pistitium.Payloader Provides a framework to:

• Create Payloads via different Operation chains.
• Derive your own operation chain from BaseOperationChain
  • Create your own operations by Implementing IPayloadOperation
• Use already define operation chains:
  • HandshakeOnlyChain
    • UrlSafeBase64EncodingOperation
    • HandshakeOperation
  • HandshakeEncryptionChain
    • EncryptionOperation
    • UrlSafeBase64EncodingOperation
    • HandshakeOperation
    • MachineIdentityOperation
  • PasswordHashEncryptionChain
    • EncryptionOperation
    • UrlSafeBase64EncodingOperation
    • PasswordHashOperation
• Use already defined Handler
  • FilePayloadHandler
    • Constructor takes in a BaseOperationChain derive class, this could be your own or one the defined above.
• Create your own Payload Handlers
• Use Cryptomizer class to Encrypt and Decrypt (uses System.Security.Criptography)
• Use class RandomIdGenerator to generate different variations of random IDs
• Use class Token
  • Handshake: Generates Handshake Token
  • Registration: Generates Registration Token

Installation

Install via Visual Studio Manage Nuget Packages... or download:

https://www.nuget.org/packages/Pistitium.Payloader

.NET CLI
> dotnet add package Pistitium.Payloader --version 1.0.X

Usage

///////////////////////////////////////////////////////////
// Sample of how to Create and Decompose a Payload
///////////////////////////////////////////////////////////

using Pistitium.Payloader;
using Pistitium.Payloader.Chain;
using Pistitium.Payloader.Helper;

namespace Pistitiumizer.Tester
{
    internal class PayloaderTester : IPistitiumTester
    {        
        readonly HandshakeEncryptionChain handshakeEncryptionChain = new();        

        private Payload GeneratePayload()
        {
            Console.WriteLine("Inside: private void PayloaderTester.GeneratePayload()");
            Console.WriteLine();

            string password = "$m-Mr{d6g9)Fkv%E49"; // for testing purpose only
            string data = "Have you ever danced with the devil by the pale moon light?";
            string machineId = "00280009AEDBFBFFA452D15806E9BFEBF8A4";

            string ivSalt = StringHelper.Reverse(password);

            Payload payload = new(data)
            {
                CipherKey = new CryptoKey(password, ivSalt),
                MachineID = machineId
            };

            try
            {
                Console.WriteLine("Generating a Payload using the following password and plain data:");
                Console.WriteLine(string.Format("Password: {0}", password));
                Console.WriteLine(string.Format("Data: {0}", data));
                Console.WriteLine();

                Payload.Generate(payload, handshakeEncryptionChain);

                Console.WriteLine(payload.ToString());
                Console.WriteLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

            return payload;
        }

        private void DecomposePayload(Payload payload)
        {
            Console.WriteLine("Inside: private void PayloaderTester.DecomposePayload(Payload payload)");
            Console.WriteLine();

            try
            {
                if (payload != null)
                {
                    Payload.Decompose(payload, handshakeEncryptionChain);

                    Console.WriteLine("Decomposing payload:");
                    Console.WriteLine();

                    Console.WriteLine(payload.ToString());
                    Console.WriteLine();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }            
        }

        public void VerifyToken()
        {
            Console.WriteLine("Inside PayloaderTester.VerifyToken()");
            Console.WriteLine();

            try
            {
                string transientId = "4132623341653434353643326537614544413542";
                string testHandshakeToken = "XZL33YCT67";
                string testRegistrationToken = "TYC6654XKJ";

                if (Token.Handshake(transientId).Equals(testHandshakeToken))
                {
                    Console.WriteLine(string.Format("   Handshake Token: {0} VERIFIED for Transient ID: {1}", testHandshakeToken, transientId));
                }
                else
                {
                    Console.WriteLine(string.Format("   Handshake Token: {0} FAILED for Transient ID: {1}", testHandshakeToken, transientId));
                }

                if (Token.Registration(transientId).Equals(testRegistrationToken))
                {
                    Console.WriteLine(string.Format("Registration Token: {0} VERIFIED for Transient ID: {1}", testRegistrationToken, transientId));
                }
                else
                {
                    Console.WriteLine(string.Format("Registration Token: {0} FAILED for Transient ID: {1}", testRegistrationToken, transientId));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

            Console.WriteLine();
        }

        public void GenerateToken()
        {
            Console.WriteLine("Inside PayloaderTester.GenerateToken()");
            Console.WriteLine();

            try
            {
                for (int i = 0; i < 10; i++)
                {
                    string transientId = RandomIdGenerator.TransientID(true);
                    Console.WriteLine(string.Format("Transient ID: {0}", transientId));
                    Console.WriteLine(string.Format("Handshake Token: {0}", Token.Handshake(transientId)));
                    Console.WriteLine(string.Format("Registration Token: {0}", Token.Registration(transientId)));
                    Console.WriteLine();
                }                
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }

        public void Run()
        {
            Console.WriteLine("Inside PayloaderTester.Run()");
            Console.WriteLine();

            Payload payload = GeneratePayload();
            DecomposePayload(payload);

            VerifyToken();
            GenerateToken();
        }
    }
}

///////////////////////////////////////////////////////////
// Output of the above Sample Code
///////////////////////////////////////////////////////////

Inside PayloaderTester.Run()

Inside: private void PayloaderTester.GeneratePayload()

Generating a Payload using the following password and plain data:
Password: $m-Mr{d6g9)Fkv%E49
Data: Have you ever danced with the devil by the pale moon light?

Token: KKV63DFP56
TransientID: 4163324442323037616642443339376261646261
MachineID: 00280009AEDBFBFFA452D15806E9BFEBF8A4
Data: 00280009AEDBFBFFA452D15806E9BFEBF8A4|KKV63DFP56|Yy1VRk5xOUJNNUZ5WkphR3Z1WE1tbjdfc01TY2hnaGI4aHY3a01DUW1LRjBIZjBDV29KWGpWZVoyeERuTXNUVjJTZXhNQWNpamtvMzBGV3lDQzBselEuLg..|4163324442323037616642443339376261646261

Inside: private void PayloaderTester.DecomposePayload(Payload payload)

Decomposing payload:

Token: KKV63DFP56
TransientID: 4163324442323037616642443339376261646261
MachineID: 00280009AEDBFBFFA452D15806E9BFEBF8A4
Data: Have you ever danced with the devil by the pale moon light?

///////////////////////////////////////////////////////////
// Loading Payload from file using class FilePayloadHandler
///////////////////////////////////////////////////////////

using Pistitium.Payloader;

if (!string.IsNullOrEmpty(storedPassword))
{
    FilePayloadHandler payloadFileHandler = new FilePayloadHandler(new PasswordHashEncryptionChain());

    if (payloadFileHandler.LoadFile(acctFilePath, storedPassword))
    {
        SettingsHandler.Instance.SetDocumentPassword(storedPassword);
        docHashedPassword = payloadFileHandler.Result.Token;

        XmlDocument doc = new XmlDocument();
        doc.LoadXml(payloadFileHandler.Result.Data);
        XmlNode node = doc.DocumentElement.SelectSingleNode("account");

        while (null != node)
        {
            Account acct = new Account(node);

            Accounts.Add(acct);

            node = node.NextSibling;
        }
    }
}

////////////////////////////////////////////////////////
// Saving Payload to file using class FilePayloadHandler
////////////////////////////////////////////////////////
if (!string.IsNullOrEmpty(storedPassword))
{
    XmlDocument doc = new XmlDocument();
    XmlElement docElement = doc.CreateElement("accounts");
    doc.AppendChild(docElement);

    foreach (Account acct in Accounts)
    {
        acct.Save(doc);
    }

    string docPlain = doc.DocumentElement.OuterXml;

    string acctFilePath = DataPocket.Instance.GetParameter(SettingsHandler.KeyDocPath);

    if (string.IsNullOrEmpty(acctFilePath))
    {
        acctFilePath = SettingsHandler.Instance.SelectDocument();
    }

    if (!string.IsNullOrEmpty(acctFilePath))
    {
        FilePayloadHandler payloadFileHandler = new FilePayloadHandler(new PasswordHashEncryptionChain());
        success = payloadFileHandler.SaveData(acctFilePath, doc.DocumentElement.OuterXml, storedPassword);

        if (success)
        {
            docHashedPassword = payloadFileHandler.Result.Token;
        }
    }
}

///////////////////////////
// Using Cryptomizer Class
///////////////////////////
string plaintext = "Have you ever dance with the devil by the moon light!";

CryptoKey cryptoKey = new CryptoKey("TheFarOffM00n");

// Encrypt the string to base64 string.
string encryptedBase64 = Cryptomizer.EncryptToBase64String(plaintext, cryptoKey);

// Encrypt the string to UrlSafeBase64 string
string encryptedUrlSafeBase64 = Cryptomizer.EncryptToUrlSafeBase64String(plaintext, cryptoKey);

// Decrypt to Base64 string.
string decryptedBase64 = Cryptomizer.DecryptFromBase64String(encryptedBase64, cryptoKey);

// Decrypt Url Safe Base64 string.
string decryptedUrlSafeBase64 = Cryptomizer.DecryptFromUrlSafeBase64String(encryptedUrlSafeBase64, cryptoKey);

//Display the original data and the decrypted data.
Console.WriteLine("Plain Text:   {0}", plaintext);
Console.WriteLine("Encrypted base64 Encoded: {0}", encryptedBase64);
Console.WriteLine("Encrypted Url Safe Base64 Encoded: {0}", encryptedUrlSafeBase64);
Console.WriteLine("Decrypted from Base64: {0}", decryptedBase64);
Console.WriteLine("Decrypted from Url Safe Base64: {0}", decryptedUrlSafeBase64);
                
///////////////////////////////////////////////////////////
// Sample of how to Create and verify Token
///////////////////////////////////////////////////////////

using Pistitium.Payloader;

namespace Pistitiumizer.Tester
{
    internal class TokenTester : IPistitiumTester
    {
        public static void VerifyToken()
        {
            Console.WriteLine("Inside TokenTester.VerifyToken()");
            Console.WriteLine();

            try
            {
                string transientId = "4132623341653434353643326537614544413542";
                string testHandshakeToken = "XZL33YCT67";
                string testRegistrationToken = "TYC6654XKJ";

                if (Token.Handshake(transientId).Equals(testHandshakeToken))
                {
                    Console.WriteLine(string.Format("   Handshake Token: {0} VERIFIED for Transient ID: {1}", testHandshakeToken, transientId));
                }
                else
                {
                    Console.WriteLine(string.Format("   Handshake Token: {0} FAILED for Transient ID: {1}", testHandshakeToken, transientId));
                }

                if (Token.Registration(transientId).Equals(testRegistrationToken))
                {
                    Console.WriteLine(string.Format("Registration Token: {0} VERIFIED for Transient ID: {1}", testRegistrationToken, transientId));
                }
                else
                {
                    Console.WriteLine(string.Format("Registration Token: {0} FAILED for Transient ID: {1}", testRegistrationToken, transientId));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

            Console.WriteLine();
        }

        public static void CreateToken(string transientId)
        {
            Console.WriteLine("Inside TokenTester.CreateToken()");
            Console.WriteLine();

            Console.WriteLine(string.Format("      Transient ID: {0}", transientId));
            Console.WriteLine(string.Format("   Handshake Token: {0}", Token.Handshake(transientId)));
            Console.WriteLine(string.Format("Registration Token: {0}", Token.Registration(transientId)));
            Console.WriteLine();
        }

        public static void GenerateToken()
        {
            Console.WriteLine("Inside TokenTester.GenerateToken()");
            Console.WriteLine();

            try
            {
                for (int i = 0; i < 10; i++)
                {
                    string transientId = RandomIdGenerator.TransientID(true);
                    CreateToken(transientId);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }

        public void Run()
        {
            Console.WriteLine("Inside TokenTester.Run()");
            Console.WriteLine();

            try
            {
                VerifyToken();
                GenerateToken();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
    }
}

///////////////////////////////////////////////////////////
// Sample of how to use RandomIdGenerator
///////////////////////////////////////////////////////////
                
using Pistitium.Payloader;
using Pistitium.Payloader.Helper;

namespace Pistitiumizer.Tester
{
    internal class RandomIdGeneratorTester : IPistitiumTester
    {
        //private const int IdLength = 20;

        public static void Display(string input, TransientId.SeedType? seedType = null)
        {
            string randomId = StringHelper.GetFormattedStringFromInput(input, StringHelper.Format.Hexadecimal);

            if (seedType != null)
            {
                Console.WriteLine($"SeedType: {seedType}");
            }
            
            Console.WriteLine($"   Input: {input}");
            Console.WriteLine($"      ID: {randomId}");
            Console.WriteLine();
        }

        public void Run()
        {
            Console.WriteLine("Inside RandomIdGeneratorTester.Run()");
            Console.WriteLine();

            try
            {
                string input = RandomIdGenerator.Base16Lower(15);
                Display(input, TransientId.SeedType.Base16Lower);

                input = RandomIdGenerator.Base16Upper(20);
                Display(input, TransientId.SeedType.Base16Upper);

                input = RandomIdGenerator.Base16MixedCase(25);
                Display(input, TransientId.SeedType.Base16MixedCase);

                input = RandomIdGenerator.NumvericOnly(30);
                Display(input, TransientId.SeedType.NumvericOnly);

                input = RandomIdGenerator.TransientID(true);
                Display(input);

                input = RandomIdGenerator.AlphaNumericLower(35);
                Display(input);

                input = RandomIdGenerator.AlphaNumericUpper(40);
                Display(input);

                input = RandomIdGenerator.AlphaNumericMixedCase(45);
                Display(input);

                input = RandomIdGenerator.AlphaLower(50);
                Display(input);

                input = RandomIdGenerator.AlphaUpper(55);
                Display(input);

                input = RandomIdGenerator.AlphaMixedCase(60);
                Display(input);            
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
    }
}
                
///////////////////////////////////////////////////////////
// Sample of how to Generate TransientId
///////////////////////////////////////////////////////////
                
using Pistitium.Payloader;

namespace Pistitiumizer.Tester
{
    internal class TransientIdTester : IPistitiumTester
    {
        public void GenerateTransientId()
        {
            Console.WriteLine("Inside TransientIdTester.GenerateTransientId()");
            Console.WriteLine();

            try
            {
                Console.WriteLine(new TransientId());
                Console.WriteLine(TransientId.Generate(TransientId.SeedType.Base16Lower));
                Console.WriteLine(TransientId.Generate(TransientId.SeedType.Base16Upper));
                Console.WriteLine(TransientId.Generate(TransientId.SeedType.Base16MixedCase));
                Console.WriteLine(TransientId.Generate(TransientId.SeedType.NumvericOnly));
                Console.WriteLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }

        public void Run()
        {
            Console.WriteLine("Inside TransientIdTester.Run()");
            Console.WriteLine();

            try
            {
                GenerateTransientId();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
    }
}
                
///////////////////////////////////////////////////////////
// Sample of how to Generate Handshake
///////////////////////////////////////////////////////////
                
using Pistitium.Payloader;

namespace Pistitiumizer.Tester
{
    internal class HandshakeTester : IPistitiumTester
    {
        public void Run()
        {
            Console.WriteLine("Inside HandshakeTester.Run()");
            Console.WriteLine();

            try
            {
                Console.WriteLine(new Handshake().ToString());
                Console.WriteLine(new Handshake(TransientId.SeedType.Base16MixedCase).ToString());
                Console.WriteLine(new Handshake("Greetings to all!").ToString());

                TransientId id = TransientId.Generate(TransientId.SeedType.NumvericOnly);

                Console.WriteLine(new Handshake(TransientId.Generate(TransientId.SeedType.NumvericOnly), "Have a wonderful week!").ToString());
                Console.WriteLine(new Handshake(TransientId.Generate(TransientId.SeedType.Base16Lower), "Have a wonderful week!").ToString());
                Console.WriteLine(new Handshake(TransientId.Generate(TransientId.SeedType.Base16Upper), "Have a wonderful week!").ToString());
                Console.WriteLine(new Handshake(TransientId.Generate(TransientId.SeedType.Base16MixedCase), "Have a wonderful week!").ToString());
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
    }
}

License

MIT