/// <summary>
        ///     schedule a plugin to be executed at each heartbeat
        /// </summary>
        /// <param name="plugin">the plugin to be scheduled</param>
        public override void SchedulePlugin(APlugin plugin)
        {
            if (!plugin.CanBeRun())
            {
                return;
            }

            try
            {
                // the scheduler is called to run the plugin each heartbeat
                SchedulerService.Instance.ScheduleTask($"task_{plugin.Infos.FileName}", plugin.Heartbeat, () =>
                {
                    try
                    {
                        Run(plugin);
                        Log.Instance?.Info($"{plugin.Infos.FileName} correctly executed.");
                    }
                    catch (Exception e)
                    {
                        Log.Instance?.Error($"{plugin.Infos.FileName} had a problem: {e.Message}");
                    }
                });
            }
            catch (Exception e)
            {
                Log.Instance?.Error($"SchedulePlugin: {e.Message}");
            }
        }
Exemple #2
0
        /// <summary>
        ///     run a code from a shared object fille
        /// </summary>
        /// <param name="plugin">plugin to be executed</param>
        public void RunFromSO(APlugin plugin)
        {
            // .so works only on linux
            if (OSAttribute.IsLinux)
            {
                QueueLength++;

                ThreadPool.QueueUserWorkItem(obj =>
                {
                    try
                    {
                        using var dllimport = new DllImportEntryPoint();
                        var result          = dllimport.UseRunEntryPointSharedObject(plugin.Infos.FilePath);

                        plugin.RaiseOnExecutionFinished(result);
                    }
                    catch (Exception e)
                    {
                        Log.Instance?.Error($"{plugin.Infos.FileName} encountered a problem: {e.Message}");
                    }
                    finally
                    {
                        Consume();
                    }
                });
            }
        }
Exemple #3
0
        private void ExecuteScriptLinux(APlugin plugin, string file, string args)
        {
            using var dllimport = new DllImportLaunchCmdUnix();
            var result = "";

            if (plugin.AdministratorRights)
            {
                result = dllimport.UseLaunchCommand(
                    $"sudo -u {plugin.AdministratorUsername} -s {file} -c {args} 2> /dev/null");
            }
            else
            {
                result = dllimport.UseLaunchCommand($"{file} {args} 2> /dev/null");
            }

            // if it's not a valid json
            try
            {
                JObject.Parse(result);
            }
            catch (JsonReaderException)
            {
                Log.Instance?.Error($"{plugin.Infos.Name}: result not in a json format: {result}");
                return;
            }

            plugin.RaiseOnExecutionFinished(result);
        }
Exemple #4
0
 private static void PrintPluginLine(APlugin plugin, bool valid, string error)
 {
     Console.ForegroundColor = valid ? ConsoleColor.Green : ConsoleColor.Red;
     Console.Write($"[{plugin.Infos.FileName}]:");
     Console.ResetColor();
     Console.WriteLine($" {error}");
 }
Exemple #5
0
        /// <summary>
        ///     run a code from a dll (dotnet dll and classical dll)
        /// </summary>
        /// <param name="plugin">plugin to be executed</param>
        public void RunFromDLL(APlugin plugin)
        {
            QueueLength++;

            ThreadPool.QueueUserWorkItem(obj =>
            {
                // TODO: verifier si il y a un moyen de connaitre si c est une dll dotnet

                try
                {
                    TryRunAssemblyDLL(plugin);
                }
                catch (Exception e)
                {
                    // if it can't load assembly, it need to try a classic type file dll
                    if (e is BadImageFormatException)
                    {
                        RunClassicDLL(plugin);
                    }
                }
                finally
                {
                    Consume();
                }
            });
        }
Exemple #6
0
        private void RunClassicDLL(APlugin plugin)
        {
            using var dllimport = new DllImportEntryPoint();

            var result = dllimport.UseRunEntryPointSharedObject(plugin.Infos.FilePath);

            plugin.RaiseOnExecutionFinished(result);
        }
Exemple #7
0
    public async Task <StorageCode> Save <T>(APlugin plugin, T obj)
    {
        if (!HasDifference(plugin, obj))
        {
            return(StorageCode.Pass);
        }

        return(await SaveDifferencial(plugin, obj));
    }
Exemple #8
0
        public void AddPlugin(APlugin aPlugin)
        {
            aPlugin.Servers       = Servers;
            aPlugin.Files         = Files;
            aPlugin.Searches      = Searches;
            aPlugin.Notifications = Notifications;
            aPlugin.ApiKeys       = ApiKeys;
            aPlugin.Scheduler     = Scheduler;

            _plugins.Add(aPlugin);
        }
Exemple #9
0
 private void StartProcess(APlugin plugin, string file, string args)
 {
     if (OSAttribute.IsLinux)
     {
         ExecuteScriptLinux(plugin, file, args);
     }
     else if (OSAttribute.IsWindows)
     {
         ExecuteScriptWindows(plugin, file, args);
     }
 }
Exemple #10
0
    public bool HasDifference <T>(APlugin plugin, T obj)
    {
        if (!plugin.ObserveAllAttributes && plugin.AttributesToObserve == null)
        {
            return(true);
        }

        var key = plugin.Infos.Name;

        var convertedJsonObject = JObject.Parse(obj.ToString());

        if (!storedObject.ContainsKey(plugin.Infos.Name))
        {
            storedObject.Add(key, convertedJsonObject);
            return(true);
        }

        List <string> attributesToObserve;

        if (plugin.ObserveAllAttributes)
        {
            attributesToObserve = new List <string>();

            foreach (var token in convertedJsonObject)
            {
                attributesToObserve.Add(token.Key);
            }
        }
        else
        {
            attributesToObserve = plugin.AttributesToObserve;
        }

        foreach (var attr in attributesToObserve)
        {
            var storedAttr = storedObject[key][attr];

            if (convertedJsonObject[attr] == null)
            {
                Log.Instance?.Warn(
                    $"Attribute {attr} in differencial mode on plugin '{plugin.Infos.FileName}' is uknown. Difference returned is true.");
                return(true);
            }

            if (!comparer.Equals(convertedJsonObject[attr], storedAttr))
            {
                storedObject[key] = convertedJsonObject;
                return(true);
            }
        }

        return(false);
    }
Exemple #11
0
        public override async Task <StorageCode> SaveDifferencial <T>(APlugin plugin, T obj)
        {
            var strTodayDate      = DateTime.Now.ToString("yyyy-MM-dd");
            var completeTodayDate = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss.ff");

            var path     = $"{strTodayDate}/{Environment.MachineName}/{plugin.Infos.Name}";
            var fileName = $"{completeTodayDate}_{plugin.Infos.Name}.json";

            await StreamWriter.WriteLineAsync($"{path};{fileName};{obj.ToString()}");

            await StreamWriter.FlushAsync();

            return(StorageCode.Success);
        }
Exemple #12
0
        public async Task <StorageCode> Save <T>(APlugin plugin, T obj)
        {
            var dirName = "results/";

            var strTodayDate      = DateTime.Now.ToString("yyyy-MM-dd");
            var completeTodayDate = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");

            var folder = $"{SavePath}/{dirName}{strTodayDate}/{plugin.Infos.Name}/";

            Directory.CreateDirectory(folder);

            using var fw = File.CreateText($"{folder}{completeTodayDate}_{plugin.Infos.Name}.json");
            await fw.WriteAsync(obj.ToString());

            return(StorageCode.Success);
        }
Exemple #13
0
        private void TryRunAssemblyDLL(APlugin plugin)
        {
            var assembly = Assembly.LoadFrom(plugin.Infos.FilePath);
            var type     = assembly.GetTypes().FirstOrDefault();

            var entryPointMethod = type?.GetMethod(MethodEntryPointName);

            if (entryPointMethod != null)
            {
                dynamic instance = Activator.CreateInstance(type);
                var     result   = entryPointMethod.Invoke(instance, null);

                plugin.RaiseOnExecutionFinished(result);
            }
            else
            {
                Log.Instance?.Error($"Method '{MethodEntryPointName}' from DLL {plugin.Infos.FileName} not found.");
            }
        }
Exemple #14
0
        /// <summary>
        ///     run a code from a script language
        /// </summary>
        /// <param name="plugin">plugin to be executed</param>
        public void RunFromScript(APlugin plugin)
        {
            QueueLength++;

            ThreadPool.QueueUserWorkItem(obj =>
            {
                var file = "";
                var args = plugin.Infos.FilePath;

                var fileExtension = plugin.Infos.FileExtension;

                // check if the extension is known
                if (!refPluginMaster.ExtensionsNames.ContainsKey(plugin.Infos.FileExtension))
                {
                    Log.Instance?.Error("Unknown extension.");
                }

                file = refPluginMaster.ExtensionsNames[fileExtension];

                // check if the extension had been set
                if (string.IsNullOrEmpty(file))
                {
                    Log.Instance?.Error(
                        $"Value {refPluginMaster.ExtensionsNames[fileExtension]} from interpreter object in json file not found.");
                    return;
                }

                try
                {
                    StartProcess(plugin, file, args);
                }
                catch (Exception e)
                {
                    Log.Instance?.Error($"{plugin.Infos.FileName} encountered a problem: {e.Message}");
                }
                finally
                {
                    Consume();
                }
            });
        }
Exemple #15
0
        public override async Task <StorageCode> SaveDifferencial <T>(APlugin plugin, T obj)
        {
            var anonymousObject = JObject.Parse(obj.ToString());

            var collection = defaultDatabase.GetCollection <dynamic>("results");

            dynamic document = new ExpandoObject();

            document.date         = DateTime.UtcNow.ToString("s");
            document.name         = plugin.Infos.Name;
            document.machine_name = Environment.MachineName;
            document.result       = BsonSerializer.Deserialize <dynamic>(obj.ToString());

            await collection.InsertOneAsync(document,
                                            new InsertOneOptions
            {
                BypassDocumentValidation = true
            });

            return(StorageCode.Success);
        }
Exemple #16
0
        /// <summary>
        ///     run a plugin depending it's type
        /// </summary>
        /// <param name="plugin">plugin to be executed</param>
        public void Run(APlugin plugin)
        {
            if (!plugin.CanBeRun())
            {
                return;
            }

            switch (plugin.Type)
            {
            case PluginFileInfos.FileType.DLL:
                Executor.RunFromDLL(plugin);
                break;

            case PluginFileInfos.FileType.Script:
                Executor.RunFromScript(plugin);
                break;

            case PluginFileInfos.FileType.SharedObject:
                Executor.RunFromSO(plugin);
                break;
            }
        }
Exemple #17
0
        public async Task <StorageCode> Save <T>(APlugin plugin, T obj)
        {
            var resultProtocol = new LineProtocolPoint(
                plugin.Infos.Name,
                new Dictionary <string, object>
            {
                { "result", JsonConvert.DeserializeObject <dynamic>(obj.ToString()) }
            }
                );

            var payload = new LineProtocolPayload();

            payload.Add(resultProtocol);

            var influxResult = await client.WriteAsync(payload);

            if (influxResult.Success)
            {
                return(StorageCode.Success);
            }
            return(StorageCode.Failed);
        }
Exemple #18
0
        private void ExecuteScriptWindows(APlugin plugin, string file, string args)
        {
            var verb     = "";
            var username = "";

            // if the plugin is a powershell scripts, it needs some tweeks to execute it
            if (plugin.Infos.FileExtension.Equals(".ps1"))
            {
                file = "Powershell.exe";
                args = $"-executionpolicy remotesigned -File {args}";
            }

            var start = new ProcessStartInfo
            {
                FileName               = file,
                Arguments              = args,
                Verb                   = verb,
                UserName               = username,
                UseShellExecute        = false,
                CreateNoWindow         = true,
                RedirectStandardOutput = true,
                RedirectStandardError  = true
            };

            using var process      = Process.Start(start);
            using var readerOutput = process.StandardOutput;
            using var readerInput  = process.StandardError;

            var err = readerInput.ReadToEnd();

            if (!string.IsNullOrEmpty(err))
            {
                Log.Instance?.Error($"Plugin encoutered an error: {err}");
                throw new ApplicationException(err);
            }

            plugin.RaiseOnExecutionFinished(readerOutput.ReadToEnd());
        }
Exemple #19
0
 /// <summary>
 ///     set a plugin's configuration from the configuration file
 /// </summary>
 /// <param name="plugin"></param>
 public abstract void SetPluginConfiguration(APlugin plugin);
Exemple #20
0
 public abstract Task <StorageCode> SaveDifferencial <T>(APlugin plugin, T obj);
Exemple #21
0
        /*
         * A plugin's configuration is composed of 3 majors attributes:
         *  - hearthbeat (in hours), the plugin will be launched one time per heartbeat.
         *  - activated (bool), tell if the plugin is activated or not
         *  - os (array), is composed of one or more familly os (linux, windows, osx)
         *      plugin will be executed only on the specified OS
         *
         */

        public override void SetPluginConfiguration(APlugin plugin)
        {
            if (Root == null)
            {
                return;
            }

            var pluginConfig = Root[MagicStringEnumerator.JSONPlugins].Value <JObject>(plugin.Infos.FileName);

            T _SetAttribute <T>(string name, T fallback) where T : struct
            {
                var val = pluginConfig[name]?.Value <T?>();

                if (val == null)
                {
                    Log.Instance?.Warn(
                        $"{plugin.Infos.FileName} has not \"{name}\" set. Default value used \"{fallback}\".");
                    return(fallback);
                }

                return(val.Value);
            }

            // plugin needs to have a specific configuration, otherwise it can't be run
            if (pluginConfig == null)
            {
                throw new NullReferenceException($"Plugin {plugin.Infos.FileName} does not have any configuration.");
            }

            plugin.Heartbeat = _SetAttribute(MagicStringEnumerator.JSONHeartbeat, 1.0f);
            plugin.Activated = _SetAttribute(MagicStringEnumerator.JSONActivated, false);

            if (OSAttribute.IsLinux)
            {
                var needAdministratorRights = _SetAttribute(MagicStringEnumerator.JSONAdminRights, false);

                if (needAdministratorRights)
                {
                    var administratorUsername = pluginConfig[MagicStringEnumerator.JSONAdminUsername]?.Value <string>();

                    if (string.IsNullOrEmpty(administratorUsername))
                    {
                        throw new ArgumentException(
                                  $"Adminstrator username must be specified in {plugin.Infos.FileName}'.");
                    }

                    plugin.AdministratorUsername = administratorUsername;
                }
            }

            // if no os is specified then all of them are authorized
            if (pluginConfig[MagicStringEnumerator.JSONOs] == null)
            {
                plugin.OsAuthorized |= OSAttribute.TargetFlag.All;
            }
            else
            {
                foreach (var os in pluginConfig[MagicStringEnumerator.JSONOs].ToObject <string[]>())
                {
                    if (!OSAttribute.OSNameToTargetFlag.ContainsKey(os))
                    {
                        throw new ArgumentException($"OS {os} is not recognized.");
                    }

                    plugin.OsAuthorized |= OSAttribute.OSNameToTargetFlag[os];
                }
            }

            if (pluginConfig[MagicStringEnumerator.JSONDifferencialAll]?.Value <bool>() == true)
            {
                plugin.ObserveAllAttributes = true;
            }
            else
            {
                var attributesToObserve = GetAttributesToObserve(pluginConfig);
                if (attributesToObserve != null)
                {
                    plugin.AttributesToObserve = attributesToObserve;
                }
            }
        }
Exemple #22
0
        public override async Task <StorageCode> SaveDifferencial <T>(APlugin plugin, T obj)
        {
            await Task.Run(() => { Console.WriteLine(obj); });

            return(StorageCode.Success);
        }
Exemple #23
0
 public void Add(APlugin aPlugin)
 {
     _plugins.Add(aPlugin);
 }
Exemple #24
0
 public virtual void SchedulePlugin(APlugin plugin)
 {
 }