Truxton .NET Core - Revision history

Sam at 18:16, 30 April 2023

2023-04-30T18:16:26Z

Show changes

Sam: /* Common Truxton Interfaces Which Can Be Injected */

2023-04-30T17:54:41Z

Common Truxton Interfaces Which Can Be Injected

Sam: /* Getting Started */

2023-04-30T17:52:34Z

Getting Started

Sam at 17:44, 27 July 2022

2022-07-27T17:44:26Z

Show changes

Pmuessig: /* Dll CheatSheet */

2021-04-01T14:41:39Z

Dll CheatSheet

Pmuessig: /* Add the desired package reference */

2021-04-01T14:40:37Z

Add the desired package reference

Pmuessig: /* Sample ETL code */

2020-11-20T21:03:06Z

Sample ETL code

Pmuessig at 20:00, 20 November 2020

2020-11-20T20:00:20Z

Pmuessig: /* Add the desired package reference */

2020-11-20T19:58:47Z

Add the desired package reference

Pmuessig: /* Add the desired package reference */

2020-11-20T19:58:20Z

Add the desired package reference

@@ Line 1,130: / Line 1,130: @@
 * <code>IETLApplicationLifetime</code> - Found in <code>Truxton.Messaging.dll</code>. Encapsulates the lifetime of our ETL and access to the root CancellationToken to assist in exiting gracefully out of asynchronous operations.
-So to use any of these already registered services you simply add any number of them to the constructor of your ETL. Here is an example:
+So to use any of these already registered services you would add any number of them to the constructor of your ETL. Here is an example:
 <source lang="C#">

@@ Line 9: / Line 9: @@
 ==Getting Started==
-Truxton .NET Core ETLs are simply .Net Core 3.1 console exes that include references to the the Truxton .NET Core libraries.
+Truxton .NET Core ETLs are .Net Core 3.1 console executables that include references to the the Truxton .NET Core libraries.
 ===Prerequisites===

@@ Line 143: / Line 143: @@
 The only package you should need to add for our purposes is <code>Truxton.Messaging.Postgres</code>. This particular package should contain all the sub-dependencies you need to make an ETL and reference core helper classes.
-===Dll CheatSheet===
+===DLL CheatSheet===
 The following dlls are located SDK folder e.g. <code>C:\Program Files\Truxton\SDK</code> in an unpackaged format.

@@ Line 134: / Line 134: @@
 ** <code>Truxton.Messaging</code>
 ** <code>Truxton.Messaging.Postgres</code>
 ** <code>TruxtonAssembly</code>
 * Choose <code>Truxton.Messaging.Postgres</code> and select '''Install''' to install it as a package reference to your ETL project.

← Older revision		Revision as of 21:03, 20 November 2020
Line 1,644:		Line 1,644:

	=Sample ETL code=		=Sample ETL code=
		+	Here is a snippet of sample code that puts all the concepts discussed together. It subscribes to ascii text files and produces a unicode child file associated to it with the string "foobar" appended to it. This sample assumes you have the correct package references and logging configured as mentioned earlier in this article
		+
		+	<syntaxhighlight lang="C#">
		+	using Microsoft.Extensions.Logging;
		+	using System;
		+	using System.Collections.Generic;
		+	using System.IO;
		+	using System.Text;
		+	using System.Threading;
		+	using System.Threading.Tasks;
		+	using Truxton;
		+	using Truxton.DataAccess;
		+	using Truxton.Messaging;
		+
		+	namespace MyETL
		+	{
		+	class Program
		+	{
		+	static void Main(string[] args)
		+	{
		+	//create a postgres flavored host and run our ETL in it
		+	new PostgresETLHostBuilder<MyETL>()
		+	.Run();
		+	}
		+	}
		+
		+	/// <summary>
		+	/// This sample ETL takes an ascii text file, appends "foobar" to the content found, then add that as a child
		+	/// </summary>
		+	public class MyETL : IFileConsumer
		+	{
		+	/// <summary>
		+	/// We want files during the LIEC loop.
		+	/// That is: Load, Identify, Extract, Carve
		+	/// </summary>
		+	public int Stage => (int)Stages.LIECLoop_Stage_Minimum;
		+
		+	/// <summary>
		+	/// Our unique name for our ETL
		+	/// </summary>
		+	public string ApplicationName => "MyETL";
		+
		+	/// <summary>
		+	/// The unique message queue name, remember, no spaces!
		+	/// </summary>
		+	public string MessageQueueName => "myetl";
		+
		+	/// <summary>
		+	/// Our ETLs purpose
		+	/// </summary>
		+	public string Description => "MyETL cares about txt files";
		+
		+	/// <summary>
		+	/// Options for this ETL, no need to customize this for this sample
		+	/// </summary>
		+	public ETLOptions Options { get; } = new ETLOptions();
		+
		+	readonly ITruxtonDatabase _truxtonDatabase;
		+	readonly IETLContentService _etlContentService;
		+	readonly IBroadcastService _broadcastService;
		+	readonly ILogger _logger;
		+
		+	public MyETL(ITruxtonDatabase truxtonDatabase,
		+	IBroadcastService broadcastService,
		+	IETLContentService etlContentService,
		+	ILogger<MyETL> logger)
		+	{
		+	_truxtonDatabase = truxtonDatabase;
		+	_broadcastService = broadcastService;
		+	_etlContentService = etlContentService;
		+	_logger = logger;
		+	}
		+
		+	/// <summary>
		+	/// Method which configures which file types we care to recieve
		+	/// </summary>
		+	/// <param name="ct"></param>
		+	/// <returns></returns>
		+	public Task<IEnumerable<ushort>> ConfigureFileTypesAsync(CancellationToken ct)
		+	{
		+	// we only care about ASCII files
		+	var fileTypes = new List<ushort>()
		+	{
		+	(ushort)FileTypes.Type_ASCII_Text,
		+	};
		+
		+	return Task.FromResult<IEnumerable<ushort>>(fileTypes);
		+	}
		+
		+	/// <summary>
		+	/// Main method which will handle incoming messages
		+	/// </summary>
		+	/// <param name="message"></param>
		+	/// <param name="ct"></param>
		+	/// <returns></returns>
		+	public async Task HandleMessageAsync(FileMessage message, CancellationToken ct)
		+	{
		+	_logger.LogDebug($@"Received File {message.Name}. Type: {message.FileType}");
		+
		+	//use the content service to get a stream and read the contents to a string
		+	using (var stream = await _etlContentService.GetStreamAsync(message, ct))
		+	using (var reader = new StreamReader(stream, Encoding.ASCII))
		+	{
		+	string stringContent = await reader.ReadToEndAsync();
		+	_logger.LogDebug($"Content received: {stringContent}");
		+
		+	string foobaredContent = stringContent + " foobar.";
		+
		+	//our string has been foobared, lets add it back to Truxton via _broadcastService
		+	byte[] unicodeBuffer = Encoding.Unicode.GetBytes(foobaredContent);
		+	ulong now = (ulong)DateTime.Now.ToFileTimeUtc();
		+
		+	// Save the results as a child file.
		+	_broadcastService.AddFile(message.MediaID,
		+	message.ID,
		+	unicodeBuffer,
		+	$"{message.Name} - Foobared.txt",
		+	(ushort)FileTypes.Type_Unicode_Text,
		+	Origin.Expanded,// origin is expanded because we want other ETLs to be able to subscribe to this file
		+	now,
		+	now,
		+	now);
		+	}
		+	}
		+	}
		+	}
		+	</syntaxhighlight>

← Older revision		Revision as of 20:00, 20 November 2020
Line 1,642:		Line 1,642:

	Now, any other ETL in our pipeline who cares about UTF8 txt files will be notified with a FileMessage and they can continue further exploitation. You can see how this can get very powerful for well known filetypes (zip archives) or files with rich exploitative metadata (sqlite files).		Now, any other ETL in our pipeline who cares about UTF8 txt files will be notified with a FileMessage and they can continue further exploitation. You can see how this can get very powerful for well known filetypes (zip archives) or files with rich exploitative metadata (sqlite files).
		+
		+	=Sample ETL code=