diff --git a/src/Orc.SupportPackage.Example/App.xaml.cs b/src/Orc.SupportPackage.Example/App.xaml.cs
index 78d62842..ba3ae47c 100644
--- a/src/Orc.SupportPackage.Example/App.xaml.cs
+++ b/src/Orc.SupportPackage.Example/App.xaml.cs
@@ -38,4 +38,4 @@ protected override void OnStartup(StartupEventArgs e)
             base.OnStartup(e);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Orc.SupportPackage.Example/ViewModels/MainViewModel.cs b/src/Orc.SupportPackage.Example/ViewModels/MainViewModel.cs
index 8b637b71..3a155ec1 100644
--- a/src/Orc.SupportPackage.Example/ViewModels/MainViewModel.cs
+++ b/src/Orc.SupportPackage.Example/ViewModels/MainViewModel.cs
@@ -7,12 +7,14 @@
     using System.Threading.Tasks;
     using System.Windows;
     using System.Windows.Media.Imaging;
-    using SystemInfo;
     using Catel;
+    using Catel.IoC;
     using Catel.MVVM;
     using Catel.Services;
     using Catel.Threading;
+    using Orc.FileSystem;
     using Orc.SupportPackage.ViewModels;
+    using SystemInfo;
 
     public class MainViewModel : ViewModelBase
     {
@@ -21,27 +23,49 @@ public class MainViewModel : ViewModelBase
 
         private readonly IScreenCaptureService _screenCaptureService;
         private readonly ISystemInfoService _systemInfoService;
+        private readonly IMessageService _messageService;
         private readonly IUIVisualizerService _uiVisualizerService;
         private readonly IAppDataService _appDataService;
-
-        public MainViewModel(IScreenCaptureService screenCaptureService, ISystemInfoService systemInfoService,
-            IUIVisualizerService uiVisualizerService, IAppDataService appDataService)
+        private readonly ITypeFactory _typeFactory;
+        private readonly IEncryptionService _encryptionService;
+        private readonly IOpenFileService _openFileService;
+        private readonly IFileService _fileService;
+
+        public MainViewModel(IScreenCaptureService screenCaptureService, ISystemInfoService systemInfoService, IMessageService messageService,
+            IUIVisualizerService uiVisualizerService, IAppDataService appDataService, ITypeFactory typeFactory, IEncryptionService encryptionService,
+            IOpenFileService openFileService, IFileService fileService)
         {
             Argument.IsNotNull(() => screenCaptureService);
             Argument.IsNotNull(() => systemInfoService);
+            Argument.IsNotNull(() => messageService);
             Argument.IsNotNull(() => uiVisualizerService);
             Argument.IsNotNull(() => appDataService);
+            Argument.IsNotNull(() => typeFactory);
+            Argument.IsNotNull(() => encryptionService);
+            Argument.IsNotNull(() => openFileService);
+            Argument.IsNotNull(() => fileService);
 
             _screenCaptureService = screenCaptureService;
             _systemInfoService = systemInfoService;
+            _messageService = messageService;
             _uiVisualizerService = uiVisualizerService;
             _appDataService = appDataService;
-
+            _typeFactory = typeFactory;
+            _encryptionService = encryptionService;
+            _openFileService = openFileService;
+            _fileService = fileService;
             Screenshot = new TaskCommand(OnScreenshotExecuteAsync);
             ShowSystemInfo = new TaskCommand(OnShowSystemInfoExecuteAsync);
             SavePackage = new TaskCommand(OnSavePackageExecuteAsync);
+            EncryptAndSavePackage = new TaskCommand(OnEncryptAndSavePackageExecuteAsync);
+            GenerateKeys = new TaskCommand(OnGenerateKeysExecuteAsync);
+            DecryptPackage = new TaskCommand(OnDecryptPackageExecuteAsync);
 
             Title = "Orc.SupportPackage example";
+
+            var currentDirectory = Environment.CurrentDirectory;
+            PublicKeyPath = Path.Combine(currentDirectory, "public.pem");
+            PrivateKeyPath = Path.Combine(currentDirectory, "private.pem");
         }
 
         #region Commands
@@ -52,6 +76,66 @@ private async Task OnSavePackageExecuteAsync()
             await _uiVisualizerService.ShowDialogAsync<SupportPackageViewModel>();
         }
 
+        public TaskCommand EncryptAndSavePackage { get; private set; }
+
+        private async Task OnEncryptAndSavePackageExecuteAsync()
+        {
+            var supportPackageViewModel = _typeFactory.CreateInstance<SupportPackageViewModel>();
+            supportPackageViewModel.EncryptionContext = new EncryptionContext
+            {
+                PrivateKeyPath = PrivateKeyPath,
+                PublicKey = await _encryptionService.ReadPublicKeyFromPemFileAsync(PublicKeyPath)
+            };
+
+            await _uiVisualizerService.ShowDialogAsync(supportPackageViewModel);
+        }
+
+        public TaskCommand GenerateKeys { get; private set; }
+
+        private async Task OnGenerateKeysExecuteAsync()
+        {
+            _encryptionService.Generate(PrivateKeyPath, PublicKeyPath);
+            await _messageService.ShowInformationAsync("Encryption keys generated");
+        }
+
+        public TaskCommand DecryptPackage { get; private set; }
+
+        private async Task OnDecryptPackageExecuteAsync()
+        {
+            var result = await _openFileService.DetermineFileAsync(new DetermineOpenFileContext
+            {
+            });
+
+            if (!result.Result)
+            {
+                return;
+            }
+
+            var directory = Path.GetDirectoryName(result.FileName);
+            var fileName = Path.GetFileNameWithoutExtension(result.FileName);
+
+            var decryptedPackagePath = Path.Combine(directory, $"{fileName}_dec.spkg");
+
+            using (var sourceStream = _fileService.OpenRead(result.FileName))
+            {
+                if (_fileService.Exists(decryptedPackagePath))
+                {
+                    _fileService.Delete(decryptedPackagePath);
+                }
+
+                using (var targetStream = _fileService.Create(decryptedPackagePath))
+                {
+                    await _encryptionService.DecryptAsync(sourceStream, targetStream, new EncryptionContext
+                    {
+                        PrivateKeyPath = PrivateKeyPath,
+                        PublicKey = await _encryptionService.ReadPublicKeyFromPemFileAsync(PublicKeyPath)
+                    });
+                }
+            }
+
+            await _messageService.ShowInformationAsync($"Decrypted support package saved on path {decryptedPackagePath}");
+        }
+
         public TaskCommand Screenshot { get; private set; }
 
         private async Task OnScreenshotExecuteAsync()
@@ -85,12 +169,17 @@ private async Task OnShowSystemInfoExecuteAsync()
             var sysInfoLines = sysInfoElements.Select(x => x.ToString());
             SystemInfo = string.Join("\n", sysInfoLines);
         }
+
         #endregion
 
         #region Properties
         public BitmapImage ScreenPic { get; private set; }
 
         public string SystemInfo { get; set; }
+
+        public string PrivateKeyPath { get; set; }
+
+        public string PublicKeyPath { get; set; }
         #endregion
     }
 }
diff --git a/src/Orc.SupportPackage.Example/Views/MainView.xaml b/src/Orc.SupportPackage.Example/Views/MainView.xaml
index 50488903..bdb7dc8e 100644
--- a/src/Orc.SupportPackage.Example/Views/MainView.xaml
+++ b/src/Orc.SupportPackage.Example/Views/MainView.xaml
@@ -41,7 +41,55 @@
 
             <TabItem Header="Zipping all data">
                 <Grid>
-                    <Button Content="Save support package as" Margin="15  15 15 15" Command="{Binding SavePackage}"/>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto"/>
+                        <ColumnDefinition Width="2*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+                    
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                        <RowDefinition Height="*"/>
+                        <RowDefinition Height="*"/>
+                    </Grid.RowDefinitions>
+
+                    <Label>Public Key</Label>
+                    <Label Grid.Row="1">Private Key</Label>
+                    <TextBox Grid.Column="1"
+                             Margin="4"
+                             Text="{Binding PublicKeyPath}"/>
+                    <TextBox Grid.Column="1"
+                             Margin="4"
+                             Grid.Row="1"
+                             Text="{Binding PrivateKeyPath}"/>
+
+                    <Button Grid.RowSpan="2"
+                            Grid.Column="2"
+                            Margin="4"
+                            Padding="6"
+                            Command="{Binding GenerateKeys}">
+                        Generate
+                    </Button>
+
+                    <Button Content="Save support package as" 
+                            Margin="15" 
+                            Grid.ColumnSpan="3"
+                            Grid.Row="2"
+                            Command="{Binding SavePackage}"/>
+
+                    <Button Content="Save encrypted support package as" 
+                            Margin="15" 
+                            Grid.ColumnSpan="3"
+                            Grid.Row="3"
+                            Command="{Binding EncryptAndSavePackage}"/>
+
+                    <Button Content="Decrypt support package" 
+                            Margin="15" 
+                            Grid.ColumnSpan="3"
+                            Grid.Row="4"
+                            Command="{Binding DecryptPackage}"/>
                 </Grid>
             </TabItem>
         </TabControl>
diff --git a/src/Orc.SupportPackage.Xaml/Context/SupportPackageBuilderContext.cs b/src/Orc.SupportPackage.Xaml/Context/SupportPackageBuilderContext.cs
new file mode 100644
index 00000000..a1f4eb8c
--- /dev/null
+++ b/src/Orc.SupportPackage.Xaml/Context/SupportPackageBuilderContext.cs
@@ -0,0 +1,18 @@
+namespace Orc.SupportPackage
+{
+    using System.Collections.Generic;
+
+    public class SupportPackageBuilderContext
+    {
+        /// <summary>
+        /// Name of support package file
+        /// </summary>
+        public string FileName { get; set; }
+
+        public List<SupportPackageFileSystemArtifact> Artifacts { get; set; }
+
+        public bool IsEncrypted { get; set; }
+
+        public EncryptionContext EncryptionContext { get; set; }
+    }
+}
diff --git a/src/Orc.SupportPackage.Xaml/Services/Interfaces/ISupportPackageBuilderService.cs b/src/Orc.SupportPackage.Xaml/Services/Interfaces/ISupportPackageBuilderService.cs
index b32b0f39..18c61fc6 100644
--- a/src/Orc.SupportPackage.Xaml/Services/Interfaces/ISupportPackageBuilderService.cs
+++ b/src/Orc.SupportPackage.Xaml/Services/Interfaces/ISupportPackageBuilderService.cs
@@ -13,6 +13,8 @@ public interface ISupportPackageBuilderService
     {
         #region Methods
         Task<bool> CreateSupportPackageAsync(string fileName, List<SupportPackageFileSystemArtifact> artifacts);
+        Task<bool> CreateSupportPackageAsync(SupportPackageBuilderContext context);
+
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/Orc.SupportPackage.Xaml/Services/SupportPackageBuilderService.cs b/src/Orc.SupportPackage.Xaml/Services/SupportPackageBuilderService.cs
index f0ed8c23..093a2113 100644
--- a/src/Orc.SupportPackage.Xaml/Services/SupportPackageBuilderService.cs
+++ b/src/Orc.SupportPackage.Xaml/Services/SupportPackageBuilderService.cs
@@ -7,10 +7,7 @@
 
 namespace Orc.SupportPackage
 {
-    using System;
     using System.Collections.Generic;
-    using System.IO;
-    using System.IO.Compression;
     using System.Linq;
     using System.Text;
     using System.Threading.Tasks;
@@ -20,8 +17,6 @@ namespace Orc.SupportPackage
 
     public class SupportPackageBuilderService : ISupportPackageBuilderService
     {
-        private const int DirectorySizeLimitInBytes = 25 * 1024 * 1024;
-
         #region Fields
         private static readonly ILog Log = LogManager.GetCurrentClassLogger();
 
@@ -45,6 +40,18 @@ public SupportPackageBuilderService(ISupportPackageService supportPackageService
         #region Methods
         public virtual async Task<bool> CreateSupportPackageAsync(string fileName, List<SupportPackageFileSystemArtifact> artifacts)
         {
+            return await CreateSupportPackageAsync(new SupportPackageBuilderContext
+            {
+                FileName = fileName,
+                Artifacts = artifacts,
+            });
+        }
+
+        public async Task<bool> CreateSupportPackageAsync(SupportPackageBuilderContext context)
+        {
+            var fileName = context.FileName;
+            var artifacts = context.Artifacts;
+
             Argument.IsNotNullOrWhitespace(() => fileName);
             Argument.IsNotNull(() => artifacts);
 
@@ -61,7 +68,9 @@ public virtual async Task<bool> CreateSupportPackageAsync(string fileName, List<
             }
 
             var excludeFileNamePatterns = artifacts.Where(artifact => !artifact.IncludeInSupportPackage).OfType<SupportPackageFileNamePattern>().SelectMany(artifact => artifact.FileNamePatterns).Distinct().ToArray();
-            var directories = artifacts.Where(artifact => artifact.IncludeInSupportPackage).OfType<SupportPackageDirectory>().Select(artifact => artifact.DirectoryName).Distinct().ToArray();
+            var directories = artifacts.Where(artifact => artifact.IncludeInSupportPackage).OfType<SupportPackageDirectory>().Select(artifact => artifact.DirectoryName)
+                .Distinct()
+                .ToArray();
 
             builder.AppendLine();
             builder.AppendLine("## Exclude file name patterns");
@@ -81,79 +90,28 @@ public virtual async Task<bool> CreateSupportPackageAsync(string fileName, List<
                 builder.AppendLine("- " + directory);
             }
 
-            var result = await _supportPackageService.CreateSupportPackageAsync(fileName, directories, excludeFileNamePatterns);
-
-            var customDataDirectoryName = "CustomData";
-            using (var fileStream = new FileStream(fileName, FileMode.OpenOrCreate))
+            var customData = artifacts.Where(artifact => artifact.IncludeInSupportPackage).OfType<CustomPathsPackageFileSystemArtifact>().SelectMany(x => x.Paths);
+            if (customData.Any())
             {
-                using (var zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Update))
-                {
-                    foreach (var artifact in artifacts.OfType<CustomPathsPackageFileSystemArtifact>().Where(artifact => artifact.IncludeInSupportPackage))
-                    {
-                        builder.AppendLine();
-                        builder.AppendLine("## Include custom data");
-                        builder.AppendLine();
-
-                        foreach (var path in artifact.Paths)
-                        {
-                            try
-                            {
-                                var directoryInfo = new DirectoryInfo(path);
-                                if (directoryInfo.Exists)
-                                {
-                                    var directorySize = directoryInfo.GetFiles("*.*", SearchOption.AllDirectories).Sum(info => info.Length);
-                                    if (directorySize > DirectorySizeLimitInBytes)
-                                    {
-                                        Log.Info("Skipped directory '{0}' beacuse its size is greater than '{1}' bytes", path, DirectorySizeLimitInBytes);
-
-                                        builder.AppendLine("- Directory (skipped): " + path);
-                                    }
-                                    else
-                                    {
-                                        zipArchive.CreateEntryFromDirectory(path, Path.Combine(customDataDirectoryName, directoryInfo.Name), CompressionLevel.Optimal);
-                                        builder.AppendLine("- Directory: " + path);
-                                    }
-                                }
-                            }
-                            catch (Exception ex)
-                            {
-                                Log.Warning(ex);
-                            }
-
-                            try
-                            {
-                                if (_fileService.Exists(path))
-                                {
-                                    zipArchive.CreateEntryFromAny(path, customDataDirectoryName, CompressionLevel.Optimal);
-                                    builder.AppendLine("- File: " + path);
-                                }
-                            }
-                            catch (Exception ex)
-                            {
-                                Log.Warning(ex);
-                            }
-                        }
-                    }
-
-                    builder.AppendLine();
-                    builder.AppendLine("## File system entries");
-                    builder.AppendLine();
-                    builder.AppendLine("- Total: " + zipArchive.Entries.Count);
-                    builder.AppendLine("- Files: " + zipArchive.Entries.Count(entry => !entry.Name.EndsWith("/")));
-                    builder.AppendLine("- Directories: " + zipArchive.Entries.Count(entry => entry.Name.EndsWith("/")));
-
-                    var builderEntry = zipArchive.CreateEntry("SupportPackageOptions.txt");
-
-                    using (var streamWriter = new StreamWriter(builderEntry.Open()))
-                    {
-                        await streamWriter.WriteAsync(builder.ToString());
-                    }
-
-                    await fileStream.FlushAsync();
-                }
+                builder.AppendLine();
+                builder.AppendLine("## Include custom data");
+                builder.AppendLine();
             }
 
-            return result;
+            using (var supportPackageContext = new SupportPackageContext())
+            {
+                supportPackageContext.ZipFileName = fileName;
+                supportPackageContext.AddArtifactDirectories(directories);
+                supportPackageContext.AddExcludeFileNamePatterns(excludeFileNamePatterns);
+                supportPackageContext.AddCustomFileSystemPaths(customData.ToArray());
+                supportPackageContext.DescriptionBuilder = builder;
+                supportPackageContext.IsEncrypted = context.IsEncrypted;
+                supportPackageContext.EncryptionContext = context.EncryptionContext;
+
+                var result = await _supportPackageService.CreateSupportPackageAsync(supportPackageContext);
+
+                return result;
+            }
         }
 
         #endregion
diff --git a/src/Orc.SupportPackage.Xaml/ViewModels/SupportPackageViewModel.cs b/src/Orc.SupportPackage.Xaml/ViewModels/SupportPackageViewModel.cs
index d3930afe..eed7709f 100644
--- a/src/Orc.SupportPackage.Xaml/ViewModels/SupportPackageViewModel.cs
+++ b/src/Orc.SupportPackage.Xaml/ViewModels/SupportPackageViewModel.cs
@@ -109,6 +109,8 @@ public SupportPackageViewModel(ISaveFileService saveFileService, ISupportPackage
         public bool IncludeCustomPathsInSupportPackage { get; set; }
 
         public List<string> SelectedCustomPaths { get; }
+
+        public EncryptionContext EncryptionContext { get; set; }
         #endregion
 
         #region Commands
@@ -227,7 +229,13 @@ private async Task OnCreateSupportPackageExecuteAsync()
                     _isCreatingSupportPackage = false;
                 }))
             {
-                await TaskHelper.Run(() => _supportPackageService.CreateSupportPackageAsync(fileName, supportPackageFileSystemArtifacts), true);
+                await TaskHelper.Run(() => _supportPackageService.CreateSupportPackageAsync(new SupportPackageBuilderContext
+                {
+                    FileName = fileName,
+                    Artifacts = supportPackageFileSystemArtifacts,
+                    IsEncrypted = EncryptionContext is not null,
+                    EncryptionContext = EncryptionContext
+                }), true);
 
                 LastSupportPackageFileName = fileName;
             }
diff --git a/src/Orc.SupportPackage/Context/SupportPackageContext.cs b/src/Orc.SupportPackage/Context/SupportPackageContext.cs
index 53403307..9fde11da 100644
--- a/src/Orc.SupportPackage/Context/SupportPackageContext.cs
+++ b/src/Orc.SupportPackage/Context/SupportPackageContext.cs
@@ -8,7 +8,9 @@
 namespace Orc.SupportPackage
 {
     using System;
+    using System.Collections.Generic;
     using System.IO;
+    using System.Text;
     using Catel;
     using Catel.Logging;
     using Catel.Reflection;
@@ -19,6 +21,10 @@ public class SupportPackageContext : Disposable, ISupportPackageContext
 
         private readonly string _rootDirectory;
 
+        private readonly List<string> _artifactsDirectories = new();
+        private readonly List<string> _excludefileNamePatterns = new();
+        private readonly List<string> _customFileSystemPaths = new();
+
         public SupportPackageContext()
         {
             var assembly = AssemblyHelper.GetEntryAssembly();
@@ -29,7 +35,21 @@ public SupportPackageContext()
             Directory.CreateDirectory(_rootDirectory);
         }
 
-        public string RootDirectory { get { return _rootDirectory; } }
+        public string RootDirectory => _rootDirectory;
+
+        public string ZipFileName { get; set; }
+
+        public bool IsEncrypted { get; set; }
+
+        public EncryptionContext EncryptionContext { get; set; }
+
+        public StringBuilder DescriptionBuilder { get; set; }
+
+        public IReadOnlyCollection<string> ExcludeFileNamePatterns => _excludefileNamePatterns;
+
+        public IReadOnlyCollection<string> ArtifactsDirectories => _artifactsDirectories;
+
+        public IReadOnlyCollection<string> CustomFileSystemPaths => _customFileSystemPaths;
 
         public string GetDirectory(string relativeDirectoryName)
         {
@@ -56,6 +76,36 @@ public string GetFile(string relativeFilePath)
             return fullPath;
         }
 
+        public void AddArtifactDirectories(string[] directories)
+        {
+            if (directories is null)
+            {
+                return;
+            }
+
+            _artifactsDirectories.AddRange(directories);
+        }
+
+        public void AddExcludeFileNamePatterns(string[] fileNamePatterns)
+        {
+            if (fileNamePatterns is null)
+            {
+                return;
+            }
+
+            _excludefileNamePatterns.AddRange(fileNamePatterns);
+        }
+
+        public void AddCustomFileSystemPaths(string[] fileSystemPaths)
+        {
+            if (fileSystemPaths is null)
+            {
+                return;
+            }
+
+            _customFileSystemPaths.AddRange(fileSystemPaths);
+        }
+
         protected override void DisposeManaged()
         {
             Log.Info("Deleting temporary files from '{0}'", _rootDirectory);
@@ -66,6 +116,11 @@ protected override void DisposeManaged()
                 {
                     Directory.Delete(_rootDirectory, true);
                 }
+
+                if (DescriptionBuilder is not null)
+                {
+                    DescriptionBuilder.Clear();
+                }
             }
             catch (Exception ex)
             {
diff --git a/src/Orc.SupportPackage/Cryptography/EncryptionContext.cs b/src/Orc.SupportPackage/Cryptography/EncryptionContext.cs
new file mode 100644
index 00000000..615dc3e1
--- /dev/null
+++ b/src/Orc.SupportPackage/Cryptography/EncryptionContext.cs
@@ -0,0 +1,35 @@
+namespace Orc.SupportPackage
+{
+    using Catel;
+
+    public class EncryptionContext
+    {
+        public EncryptionContext()
+        {
+
+        }
+
+        public EncryptionContext(EncryptionContext context)
+        {
+            Argument.IsNotNull(() => context);
+
+            PublicKey = context.PublicKey;
+            PrivateKeyPath = context.PrivateKeyPath;
+        }
+
+        public EncryptionContext(string publicKey)
+        {
+            PublicKey = publicKey;
+        }
+
+        /// <summary>
+        /// Base64-encrypted xml print of generated public key
+        /// </summary>
+        public string PublicKey { get; set; }
+
+        /// <summary>
+        /// Path to private key on disk
+        /// </summary>
+        public string PrivateKeyPath { get; set; }
+    }
+}
diff --git a/src/Orc.SupportPackage/Cryptography/EncryptionService.cs b/src/Orc.SupportPackage/Cryptography/EncryptionService.cs
new file mode 100644
index 00000000..d37f092d
--- /dev/null
+++ b/src/Orc.SupportPackage/Cryptography/EncryptionService.cs
@@ -0,0 +1,238 @@
+namespace Orc.SupportPackage
+{
+    using System;
+    using System.IO;
+    using System.Security.Cryptography;
+    using System.Text;
+    using System.Threading.Tasks;
+    using Catel;
+    using Catel.Logging;
+    using Orc.FileSystem;
+
+    public class EncryptionService : IEncryptionService
+    {
+        private static readonly ILog Log = LogManager.GetCurrentClassLogger();
+
+        private const int KeySize = 2048;
+        private const int RandomizedKeySize = 256; // For data encryption
+        private const int IVSize = 128;
+
+        private readonly IFileService _fileService;
+
+        private const string PemLeadingPrivate = "-----BEGIN RSA PRIVATE KEY-----";
+        private const string PemTrailingPrivate = "-----END RSA PRIVATE KEY-----";
+        private const string PemLeadingPublic = "-----BEGIN RSA PUBLIC KEY-----";
+        private const string PemTrailingPublic = "-----END RSA PUBLIC KEY-----";
+
+        public EncryptionService(IFileService fileService)
+        {
+            Argument.IsNotNull(() => fileService);
+
+            _fileService = fileService;
+        }
+
+        public async Task EncryptAsync(
+            Stream sourceStream,
+            Stream targetStream,
+            EncryptionContext content)
+        {
+            try
+            {
+                Argument.IsNotNullOrEmpty(() => content.PublicKey);
+
+                using (var rsa = new RSACng(KeySize))
+                {
+                    var publicRaw = Convert.FromBase64String(content.PublicKey);
+
+                    rsa.ImportRSAPublicKey(publicRaw, out _);
+
+                    sourceStream.Seek(0, SeekOrigin.Begin);
+
+                    // To successfuly encrypt with rsa + sha the message (randomized key) should be less than KeySize - SHA overhead size (66 bytes)
+                    // var maxRandomizedKeyLength = rsa.KeySize / 8 - 66
+
+                    using (var symmetric = CreateAlghorithm())
+                    {
+                        // These parameters should be passed as cipher text (encrypted with rsa)
+                        var dataKey = GenerateSymmetricKey(RandomizedKeySize);
+                        var iv = GenerateSymmetricKey(IVSize);
+
+                        symmetric.Key = dataKey;
+                        symmetric.IV = iv;
+
+                        // Create an encryptor to perform the stream transform.
+                        using (var encryptor = symmetric.CreateEncryptor(symmetric.Key, symmetric.IV))
+                        {
+                            var secretBytes = new byte[symmetric.Key.Length + symmetric.IV.Length];
+                            Buffer.BlockCopy(symmetric.IV, 0, secretBytes, 0, symmetric.IV.Length);
+                            Buffer.BlockCopy(symmetric.Key, 0, secretBytes, symmetric.IV.Length, symmetric.Key.Length);
+
+                            var cipherSecret = rsa.Encrypt(secretBytes, RSAEncryptionPadding.OaepSHA256);
+
+                            // Write this block in the beggining of cipher text
+                            await targetStream.WriteAsync(cipherSecret);
+
+                            using (var cryptoStream = new CryptoStream(targetStream, encryptor, CryptoStreamMode.Write, true))
+                            {
+                                await sourceStream.CopyToAsync(cryptoStream);
+                                await cryptoStream.FlushAsync();
+                            }
+                        }
+                    }
+
+
+                    await targetStream.FlushAsync();
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Failed to encrypt");
+
+                throw;
+            }
+        }
+
+        public async Task DecryptAsync(
+            Stream sourceStream,
+            Stream targetStream,
+            EncryptionContext context)
+        {
+            try
+            {
+                Argument.IsNotNullOrEmpty(() => context.PrivateKeyPath);
+
+                using (var rsa = new RSACng(KeySize))
+                {
+                    // Read secret keeping only the payload of the key 
+                    var pemText = await ReadPrivateKeyFromPemFileAsync(context.PrivateKeyPath);
+
+                    var secretRaw = Convert.FromBase64String(pemText);
+
+                    rsa.ImportRSAPrivateKey(secretRaw, out _);
+
+                    var ivBytes = IVSize / 8;
+
+                    // Read and decrypt data encryption parameters
+                    var buffer = new byte[256]; // OaepSHA256
+
+                    await sourceStream.ReadAsync(buffer);
+
+                    var ivAndKey = rsa.Decrypt(buffer, RSAEncryptionPadding.OaepSHA256);
+
+                    using (var symmetric = CreateAlghorithm())
+                    {
+                        var iv = ivAndKey[0..ivBytes];
+                        var key = ivAndKey[ivBytes..];
+
+                        // Create an encryptor to perform the stream transform.
+                        using (var decryptor = symmetric.CreateDecryptor(key, iv))
+                        {
+                            using (var cryptoStream = new CryptoStream(sourceStream, decryptor, CryptoStreamMode.Read, true))
+                            {
+                                await cryptoStream.CopyToAsync(targetStream);
+                            }
+                        }
+                    }
+
+                    await targetStream.FlushAsync();
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Failed to decrypt");
+                throw;
+            }
+        }
+
+        public void Generate(string secretPath, string publicKeyPath)
+        {
+            using (var rsa = new RSACng(KeySize))
+            {
+                var privateKey = rsa.ExportRSAPrivateKey();
+
+                // Follow DER format specification the result is 270 bytes long (for key size 2048)
+                // It consist of:
+                // 1. collection of the following objects; that takes up 4 bytes
+                // 2. The first object is an integer (which happens to be the public modulus);
+                // the integer itself is 257 bytes (not 256; that's because ASN.1 integers are signed, and so there has to be a leading 00
+                // to make the top bit zero to signify positive), as well as 4 overhead bytes, for a total of 261 bytes
+                // 3. The second object is an integer (which happens to be the public exponent);
+                // if you use 65537 as the exponent, this takes up a total of 5 bytes long (including overhead)
+                // So 4+261+5 gives you a total of 270 bytes
+                var publicKey = rsa.ExportRSAPublicKey();
+
+                var privateKeyPem = Convert.ToBase64String(privateKey);
+                var publicKeyPem = Convert.ToBase64String(publicKey);
+
+                var stringBuilder = new StringBuilder();
+
+                stringBuilder.AppendLine(PemLeadingPrivate);
+                stringBuilder.AppendLine(privateKeyPem);
+                stringBuilder.AppendLine(PemTrailingPrivate);
+
+                var privateTextPem = stringBuilder.ToString();
+
+                stringBuilder.Clear();
+
+                stringBuilder.AppendLine(PemLeadingPublic);
+                stringBuilder.AppendLine(publicKeyPem);
+                stringBuilder.AppendLine(PemTrailingPublic);
+
+                var publicTextPem = stringBuilder.ToString();
+
+                _fileService.WriteAllText(secretPath, privateTextPem);
+                _fileService.WriteAllText(publicKeyPath, publicTextPem);
+            }
+        }
+
+        public async Task<string> ReadPublicKeyFromPemFileAsync(string keyPath)
+        {
+            var pemText = await _fileService.ReadAllTextAsync(keyPath);
+            pemText = pemText.Replace(PemTrailingPublic, "");
+            pemText = pemText.Replace(PemLeadingPublic, "");
+
+            pemText = pemText.Trim('\r', '\n');
+
+            return pemText;
+        }
+
+        public async Task<string> ReadPrivateKeyFromPemFileAsync(string keyPath)
+        {
+            var pemText = await _fileService.ReadAllTextAsync(keyPath);
+            pemText = pemText.Replace(PemTrailingPrivate, "");
+            pemText = pemText.Replace(PemLeadingPrivate, "");
+
+            pemText = pemText.Trim('\r', '\n');
+
+            return pemText;
+        }
+
+        /// <summary>
+        /// Symmetric algorith used in the hybrid crypto
+        /// </summary>
+        /// <returns></returns>
+        protected virtual SymmetricAlgorithm CreateAlghorithm()
+        {
+            var aes = Aes.Create();
+
+            // It is reasonable to set encryption mode to Cipher Block Chaining
+            // (CBC) and Padding PKCS7. Use default options for other symmetric key parameters.
+            aes.Mode = CipherMode.CBC;
+            aes.Padding = PaddingMode.PKCS7;
+            aes.BlockSize = 128;
+
+            return aes;
+        }
+
+        protected virtual byte[] GenerateSymmetricKey(int bits)
+        {
+            using (var random = RandomNumberGenerator.Create())
+            {
+                var key = new byte[bits / 8];
+                random.GetNonZeroBytes(key);
+
+                return key;
+            }
+        }
+    }
+}
diff --git a/src/Orc.SupportPackage/Cryptography/Interfaces/IEncryptionService.cs b/src/Orc.SupportPackage/Cryptography/Interfaces/IEncryptionService.cs
new file mode 100644
index 00000000..1d8bde79
--- /dev/null
+++ b/src/Orc.SupportPackage/Cryptography/Interfaces/IEncryptionService.cs
@@ -0,0 +1,14 @@
+namespace Orc.SupportPackage
+{
+    using System.IO;
+    using System.Threading.Tasks;
+
+    public interface IEncryptionService
+    {
+        Task DecryptAsync(Stream sourceStream, Stream targetStream, EncryptionContext content);
+        Task EncryptAsync(Stream sourceStream, Stream targetStream, EncryptionContext content);
+
+        public void Generate(string secretLocation, string publicKeyLocation);
+        Task<string> ReadPublicKeyFromPemFileAsync(string keyPath);
+    }
+}
diff --git a/src/Orc.SupportPackage/ModuleInitializer.cs b/src/Orc.SupportPackage/ModuleInitializer.cs
index 851207fc..8a8615ec 100644
--- a/src/Orc.SupportPackage/ModuleInitializer.cs
+++ b/src/Orc.SupportPackage/ModuleInitializer.cs
@@ -16,8 +16,9 @@ public static void Initialize()
 
         serviceLocator.RegisterType<ISupportPackageService, SupportPackageService>();
         serviceLocator.RegisterType<IScreenCaptureService, ScreenCaptureService>();
+        serviceLocator.RegisterType<IEncryptionService, EncryptionService>();
 
         var languageService = serviceLocator.ResolveType<ILanguageService>();
         languageService.RegisterLanguageSource(new LanguageResourceSource("Orc.SupportPackage", "Orc.SupportPackage.Properties", "Resources"));
     }
-}
\ No newline at end of file
+}
diff --git a/src/Orc.SupportPackage/Services/Interfaces/ISupportPackageService.cs b/src/Orc.SupportPackage/Services/Interfaces/ISupportPackageService.cs
index 2124af36..023eab4c 100644
--- a/src/Orc.SupportPackage/Services/Interfaces/ISupportPackageService.cs
+++ b/src/Orc.SupportPackage/Services/Interfaces/ISupportPackageService.cs
@@ -1,4 +1,4 @@
-// --------------------------------------------------------------------------------------------------------------------
+// --------------------------------------------------------------------------------------------------------------------
 // <copyright file="ISupportPackageService.cs" company="WildGums">
 //   Copyright (c) 2008 - 2015 WildGums. All rights reserved.
 // </copyright>
@@ -8,11 +8,14 @@
 namespace Orc.SupportPackage
 {
     using System.Threading.Tasks;
+    using MethodTimer;
 
     public interface ISupportPackageService
     {
         #region Methods
         Task<bool> CreateSupportPackageAsync(string zipFileName, string[] directories, string[] excludeFileNamePatterns);
+
+        Task<bool> CreateSupportPackageAsync(SupportPackageContext supportPackageContext);
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/Orc.SupportPackage/Services/SupportPackageService.cs b/src/Orc.SupportPackage/Services/SupportPackageService.cs
index 31544926..18d011bc 100644
--- a/src/Orc.SupportPackage/Services/SupportPackageService.cs
+++ b/src/Orc.SupportPackage/Services/SupportPackageService.cs
@@ -8,6 +8,7 @@
 namespace Orc.SupportPackage
 {
     using System;
+    using System.Collections.Generic;
     using System.Drawing.Imaging;
     using System.IO;
     using System.IO.Compression;
@@ -30,35 +31,56 @@ namespace Orc.SupportPackage
 
     public class SupportPackageService : ISupportPackageService
     {
+        private const int DirectorySizeLimitInBytes = 25 * 1024 * 1024;
+        private const string CustomDataFolderName = "CustomData";
+
         private static readonly ILog Log = LogManager.GetCurrentClassLogger();
 
         private readonly IScreenCaptureService _screenCaptureService;
         private readonly ITypeFactory _typeFactory;
         private readonly IDirectoryService _directoryService;
         private readonly IAppDataService _appDataService;
+        private readonly IEncryptionService _encryptionService;
+        private readonly IFileService _fileService;
         private readonly ISystemInfoService _systemInfoService;
 
-        public SupportPackageService(ISystemInfoService systemInfoService,
-            IScreenCaptureService screenCaptureService, ITypeFactory typeFactory,
-            IDirectoryService directoryService, IAppDataService appDataService)
+        public SupportPackageService(ISystemInfoService systemInfoService, IScreenCaptureService screenCaptureService, ITypeFactory typeFactory,
+            IDirectoryService directoryService, IAppDataService appDataService, IEncryptionService encryptionService, IFileService fileService)
         {
             Argument.IsNotNull(() => systemInfoService);
             Argument.IsNotNull(() => screenCaptureService);
             Argument.IsNotNull(() => typeFactory);
             Argument.IsNotNull(() => directoryService);
             Argument.IsNotNull(() => appDataService);
+            Argument.IsNotNull(() => encryptionService);
+            Argument.IsNotNull(() => fileService);
 
             _systemInfoService = systemInfoService;
             _screenCaptureService = screenCaptureService;
             _typeFactory = typeFactory;
             _directoryService = directoryService;
             _appDataService = appDataService;
+            _encryptionService = encryptionService;
+            _fileService = fileService;
         }
 
-        [Time]
         public virtual async Task<bool> CreateSupportPackageAsync(string zipFileName, string[] directories, string[] excludeFileNamePatterns)
         {
-            Argument.IsNotNullOrEmpty(() => zipFileName);
+            using (var packageContext = new SupportPackageContext
+            {
+                ZipFileName = zipFileName,
+            })
+            {
+                packageContext.AddExcludeFileNamePatterns(excludeFileNamePatterns);
+
+                return await CreateSupportPackageAsync(packageContext);
+            }
+        }
+
+        [Time]
+        public virtual async Task<bool> CreateSupportPackageAsync(SupportPackageContext supportPackageContext)
+        {
+            Argument.IsNotNullOrEmpty(() => supportPackageContext.ZipFileName);
 
             var result = true;
 
@@ -66,77 +88,59 @@ public virtual async Task<bool> CreateSupportPackageAsync(string zipFileName, st
             {
                 Log.Info("Creating support package");
 
-                using (var supportPackageContext = new SupportPackageContext())
-                {
-                    // Note: screenshot first, see remarks in screenshot method
-                    var screenshotFileName = supportPackageContext.GetFile("screenshot.jpg");
-                    await CaptureWindowAndSaveAsync(screenshotFileName);
+                // Note: screenshot first, see remarks in screenshot method
+                var screenshotFileName = supportPackageContext.GetFile("screenshot.jpg");
+                await CaptureWindowAndSaveAsync(screenshotFileName);
 
-                    var systemInfoXmlFileName = supportPackageContext.GetFile("systeminfo.xml");
-                    var systemInfoTxtFileName = supportPackageContext.GetFile("systeminfo.txt");
-                    await GetAndSaveSystemInformationAsync(systemInfoXmlFileName, systemInfoTxtFileName);
+                var systemInfoXmlFileName = supportPackageContext.GetFile("systeminfo.xml");
+                var systemInfoTxtFileName = supportPackageContext.GetFile("systeminfo.txt");
+                await GetAndSaveSystemInformationAsync(systemInfoXmlFileName, systemInfoTxtFileName);
 
-                    var supportPackageProviderTypes = (from type in TypeCache.GetTypes()
-                                                       where !type.IsAbstractEx() && type.IsClassEx() &&
-                                                             type.ImplementsInterfaceEx<ISupportPackageProvider>()
-                                                       select type).ToList();
+                var supportPackageProviderTypes = (from type in TypeCache.GetTypes()
+                                                   where !type.IsAbstractEx() && type.IsClassEx() &&
+                                                         type.ImplementsInterfaceEx<ISupportPackageProvider>()
+                                                   select type).ToList();
 
-                    foreach (var supportPackageProviderType in supportPackageProviderTypes)
+                foreach (var supportPackageProviderType in supportPackageProviderTypes)
+                {
+                    try
                     {
-                        try
-                        {
-                            Log.Debug("Gathering support package info from '{0}'", supportPackageProviderType.FullName);
+                        Log.Debug("Gathering support package info from '{0}'", supportPackageProviderType.FullName);
 
-                            var provider = (ISupportPackageProvider)_typeFactory.CreateInstance(supportPackageProviderType);
-                            await provider.ProvideAsync(supportPackageContext);
-                        }
-                        catch (Exception ex)
-                        {
-                            Log.Warning(ex, "Failed to gather support package info from '{0}'. Info will be excluded from the package", supportPackageProviderType.FullName);
-                        }
+                        var provider = (ISupportPackageProvider)_typeFactory.CreateInstance(supportPackageProviderType);
+                        await provider.ProvideAsync(supportPackageContext);
                     }
-                    using (var fileStream = new FileStream(zipFileName, FileMode.OpenOrCreate))
+                    catch (Exception ex)
                     {
-                        using (var zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Update))
-                        {
-                            zipArchive.CreateEntryFromDirectory(_appDataService.GetApplicationDataDirectory(Catel.IO.ApplicationDataTarget.UserRoaming), "AppData", CompressionLevel.Optimal);
-                            zipArchive.CreateEntryFromDirectory(supportPackageContext.RootDirectory, string.Empty, CompressionLevel.Optimal);
+                        Log.Warning(ex, "Failed to gather support package info from '{0}'. Info will be excluded from the package", supportPackageProviderType.FullName);
+                    }
+                }
 
-                            if (directories is not null && directories.Length > 0)
-                            {
-                                foreach (var directory in directories)
-                                {
-                                    if (!_directoryService.Exists(directory))
-                                    {
-                                        Log.Warning($"Directory '{directory}' does not exist, skipping");
-                                        continue;
-                                    }
-
-                                    var directoryPathInArchive = directory.TrimEnd('\\').Split('\\').LastOrDefault();
-                                    if (!string.IsNullOrEmpty(directoryPathInArchive))
-                                    {
-                                        zipArchive.CreateEntryFromDirectory(directory, string.Empty, CompressionLevel.Optimal);
-                                    }
-                                }
-                            }
+                if (supportPackageContext.IsEncrypted)
+                {
+                    using (var memoryStream = new MemoryStream())
+                    {
+                        using (var fileStream = new FileStream(supportPackageContext.ZipFileName, FileMode.OpenOrCreate))
+                        {
+                            await ZipSupportPackageContentAsync(memoryStream, supportPackageContext);
 
-                            if (excludeFileNamePatterns is not null && excludeFileNamePatterns.Length > 0)
+                            if (supportPackageContext.CustomFileSystemPaths.Any())
                             {
-                                Log.Info("Removing excluded files...");
-
-                                var excludeFileNameRegexes = excludeFileNamePatterns.Select(s => new Regex(s.Replace("*", ".*").Replace(".", "\\.") + "$", RegexOptions.IgnoreCase | RegexOptions.Compiled)).ToList();
-
-                                var zipEntries = zipArchive.Entries.ToList();
-                                foreach (var zipEntry in zipEntries)
-                                {
-                                    if (excludeFileNameRegexes.Any(regex => regex.IsMatch(zipEntry.FullName)))
-                                    {
-                                        zipEntry.Delete();
-                                    }
-                                }
+                                await ZipCustomAddedContentAsync(memoryStream, supportPackageContext.CustomFileSystemPaths, supportPackageContext.DescriptionBuilder ?? new StringBuilder());
                             }
 
-                            await fileStream.FlushAsync();
+                            await _encryptionService.EncryptAsync(memoryStream, fileStream, supportPackageContext.EncryptionContext);
+                        }
+                    }
+                }
+                else
+                {
+                    using (var fileStream = new FileStream(supportPackageContext.ZipFileName, FileMode.OpenOrCreate))
+                    {
+                        await ZipSupportPackageContentAsync(fileStream, supportPackageContext);
+                        if (supportPackageContext.CustomFileSystemPaths.Any())
+                        {
+                            await ZipCustomAddedContentAsync(fileStream, supportPackageContext.CustomFileSystemPaths, supportPackageContext.DescriptionBuilder ?? new StringBuilder());
                         }
                     }
                 }
@@ -152,6 +156,118 @@ public virtual async Task<bool> CreateSupportPackageAsync(string zipFileName, st
             return result;
         }
 
+        private async Task ZipSupportPackageContentAsync(Stream stream, SupportPackageContext supportPackageContext)
+        {
+            var directories = supportPackageContext.ArtifactsDirectories;
+            var excludeFileNamePatterns = supportPackageContext.ExcludeFileNamePatterns;
+
+            using (var zipArchive = new ZipArchive(stream, ZipArchiveMode.Update, true))
+            {
+                zipArchive.CreateEntryFromDirectory(_appDataService.GetApplicationDataDirectory(Catel.IO.ApplicationDataTarget.UserRoaming), "AppData", CompressionLevel.Optimal);
+                zipArchive.CreateEntryFromDirectory(supportPackageContext.RootDirectory, string.Empty, CompressionLevel.Optimal);
+
+                if (directories is not null && directories.Count > 0)
+                {
+                    foreach (var directory in directories)
+                    {
+                        if (!_directoryService.Exists(directory))
+                        {
+                            Log.Warning($"Directory '{directory}' does not exist, skipping");
+                            continue;
+                        }
+
+                        var directoryPathInArchive = directory.TrimEnd('\\').Split('\\').LastOrDefault();
+                        if (!string.IsNullOrEmpty(directoryPathInArchive))
+                        {
+                            zipArchive.CreateEntryFromDirectory(directory, string.Empty, CompressionLevel.Optimal);
+                        }
+                    }
+                }
+
+                if (excludeFileNamePatterns is not null && excludeFileNamePatterns.Count > 0)
+                {
+                    Log.Info("Removing excluded files...");
+
+                    var excludeFileNameRegexes = excludeFileNamePatterns.Select(s => new Regex(s.Replace("*", ".*").Replace(".", "\\.") + "$", RegexOptions.IgnoreCase | RegexOptions.Compiled)).ToList();
+
+                    var zipEntries = zipArchive.Entries.ToList();
+                    foreach (var zipEntry in zipEntries)
+                    {
+                        if (excludeFileNameRegexes.Any(regex => regex.IsMatch(zipEntry.FullName)))
+                        {
+                            zipEntry.Delete();
+                        }
+                    }
+                }
+
+                await stream.FlushAsync();
+            }
+
+        }
+
+        private async Task ZipCustomAddedContentAsync(Stream stream, IEnumerable<string> customArtifactsDataPath, StringBuilder builder)
+        {
+            using (var zipArchive = new ZipArchive(stream, ZipArchiveMode.Update, true))
+            {
+                foreach (var path in customArtifactsDataPath)
+                {
+                    try
+                    {
+                        var directoryInfo = new DirectoryInfo(path);
+                        if (directoryInfo.Exists)
+                        {
+                            var directorySize = directoryInfo.GetFiles("*.*", SearchOption.AllDirectories).Sum(info => info.Length);
+                            if (directorySize > DirectorySizeLimitInBytes)
+                            {
+                                Log.Info("Skipped directory '{0}' because its size is greater than '{1}' bytes", path, DirectorySizeLimitInBytes);
+
+                                builder.AppendLine("- Directory (skipped): " + path);
+                            }
+                            else
+                            {
+                                zipArchive.CreateEntryFromDirectory(path, Path.Combine(CustomDataFolderName, directoryInfo.Name), CompressionLevel.Optimal);
+                                builder.AppendLine("- Directory: " + path);
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Log.Warning(ex);
+                    }
+
+                    try
+                    {
+                        if (_fileService.Exists(path))
+                        {
+                            zipArchive.CreateEntryFromAny(path, CustomDataFolderName, CompressionLevel.Optimal);
+                            builder.AppendLine("- File: " + path);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Log.Warning(ex);
+                    }
+
+                }
+
+                builder.AppendLine();
+                builder.AppendLine("## File system entries");
+                builder.AppendLine();
+                builder.AppendLine("- Total: " + zipArchive.Entries.Count);
+                builder.AppendLine("- Files: " + zipArchive.Entries.Count(entry => !entry.Name.EndsWith("/")));
+                builder.AppendLine("- Directories: " + zipArchive.Entries.Count(entry => entry.Name.EndsWith("/")));
+
+                var builderEntry = zipArchive.CreateEntry("SupportPackageOptions.txt");
+
+                using (var streamWriter = new StreamWriter(builderEntry.Open()))
+                {
+                    await streamWriter.WriteAsync(builder.ToString());
+                }
+
+                await stream.FlushAsync();
+            }
+        }
+
         private async Task CaptureWindowAndSaveAsync(string screenshotFile)
         {
             Argument.IsNotNullOrEmpty(() => screenshotFile);