Pistitium.Payloader 1.0.4

dotnet add package Pistitium.Payloader --version 1.0.4
NuGet\Install-Package Pistitium.Payloader -Version 1.0.4
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Pistitium.Payloader" Version="1.0.4" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add Pistitium.Payloader --version 1.0.4
#r "nuget: Pistitium.Payloader, 1.0.4"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install Pistitium.Payloader as a Cake Addin
#addin nuget:?package=Pistitium.Payloader&version=1.0.4

// Install Pistitium.Payloader as a Cake Tool
#tool nuget:?package=Pistitium.Payloader&version=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

Product Compatible and additional computed target framework versions.
.NET net6.0-windows7.0 is compatible.  net7.0-windows was computed.  net8.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.
  • net6.0-windows7.0

    • No dependencies.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
1.0.4 267 2/23/2023
1.0.3 293 1/28/2023
1.0.2 273 1/24/2023
1.0.1 296 1/6/2023
1.0.0 298 1/4/2023

Added:
-HandShake Class
-TransientId Class
-SeedType enum to TransientId
-public static string Generate(SeedType seedType = SeedType.Base16MixedCase, int idLength = IdLength) to TransientId
Expanded Sample code in readme file to demonstrate generation of:
-TransientId
-Token
-Handshake
-RandomIdGenerator