Pistitium.Payloader 1.0.3

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 Run()
        {
            Console.WriteLine("Inside PayloaderTester.Run()");
            Console.WriteLine();

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

///////////////////////////////////////////////////////////
// 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);

License

MIT