From a892ab878151e4dc2b41ef7c0e6796186ea819b2 Mon Sep 17 00:00:00 2001 From: Chi Nguyen Date: Tue, 10 Nov 2020 17:38:10 -0800 Subject: [PATCH] create Sentinel API .Net core sample (#1274) * add Sentinel API sample * Update launch.json * Update ActionPayload.json * Update BookmarkPayload.json * Update IncidentPayload.json * Update ScheduledAlertRulePayload.json * Update SecurityAlertRulePayload.json * Update SavedSearchPayload.json * Update DataConnectorPayload.json * Update FusionAlertRulePayload.json * Update IncidentCommentPayload.json * Update README.md Co-authored-by: ngchi Co-authored-by: Preeti Krishna --- .../.gitignore | 2 + .../AzureSentinel_ManagementAPI.sln | 25 + .../AzureSentinel_ManagementAPI/.gitignore | 366 +++++++++ .../.vscode/launch.json | 22 + .../.vscode/tasks.json | 42 + .../Actions/ActionsController.cs | 266 ++++++ .../Actions/Models/ActionRequestPayload.cs | 13 + .../Models/ActionRequestPropertiesPayload.cs | 8 + .../AlertRuleTemplatesController.cs | 112 +++ .../AlertRules/AlertRulesController.cs | 464 +++++++++++ .../AlertRules/Models/AlertRuleKind.cs | 9 + .../AlertRules/Models/AlertRulePayload.cs | 14 + .../Models/FusionAlertRulePayload.cs | 15 + .../FusionAlertRulePropertiesPayload.cs | 8 + .../AlertRules/Models/ProductFilter.cs | 11 + .../Models/ScheduledAlertRulePayload.cs | 17 + .../ScheduledAlertRulePropertiesPayload.cs | 26 + ...ecurityIncidentCreationAlertRulePayload.cs | 15 + ...identCreationAlertRulePropertiesPayload.cs | 9 + .../AlertRules/Models/TriggerOperator.cs | 10 + .../AzureSentinel_ManagementAPI/AppHost.cs | 758 ++++++++++++++++++ .../AzureSentinel_ManagementAPI.csproj | 45 ++ .../Bookmarks/BookmarksController.cs | 274 +++++++ .../Bookmarks/Models/BookmarkPayload.cs | 13 + .../Models/BookmarkPropertiesPayload.cs | 15 + .../Bookmarks/Models/IncidentInfo.cs | 16 + .../DataConnectorsController.cs | 245 ++++++ .../ASCDataConnectorDataTypesPayload.cs | 7 + .../Models/ASCDataConnectorPayload.cs | 9 + .../ASCDataConnectorPropertiesPayload.cs | 14 + .../Models/DataConnectionState.cs | 8 + .../Models/DataConnectorKind.cs | 14 + .../Models/DataConnectorPayload.cs | 14 + .../Models/DataTypeConnectionStatePayload.cs | 11 + .../Hunting/Models/SavedSearchPayload.cs | 16 + .../Models/SavedSearchPropertiesPayload.cs | 17 + .../Hunting/Models/SavedSearchTag.cs | 12 + .../Hunting/SavedSearchController.cs | 326 ++++++++ .../IncidentRelationController.cs | 480 +++++++++++ .../IncidentRelation/Models/EntityKind.cs | 22 + .../Models/RelationEntityPayload.cs | 13 + .../Models/RelationPayload.cs | 12 + .../Models/RelationPropertiesPayload.cs | 11 + .../Incidents/IncidentsController.cs | 648 +++++++++++++++ .../Models/Comments/IncidentCommentPayload.cs | 10 + .../IncidentCommentPropertiesPayload.cs | 7 + .../Models/IncidentAdditionalData.cs | 15 + .../Incidents/Models/IncidentOwner.cs | 14 + .../Incidents/Models/IncidentPayload.cs | 17 + .../Models/IncidentPropertiesPayload.cs | 28 + .../Incidents/Models/IncidentStatus.cs | 9 + .../Authentication/AuthenticationService.cs | 55 ++ .../AzureSentinelApiConfiguration.cs | 27 + .../SharedModels/Enums/Severity.cs | 10 + .../Infrastructure/SharedModels/TupleList.cs | 14 + .../AzureSentinel_ManagementAPI/Program.cs | 44 + .../Resource1.Designer.cs | 693 ++++++++++++++++ .../Resource1.resx | 330 ++++++++ .../ActionPayload/ActionPayload.json | 8 + .../BookmarkPayload/BookmarkPayload.json | 26 + .../DataConnectorPayload.json | 16 + .../FusionAlertRulePayload.json | 9 + .../IncidentCommentPayload.json | 7 + .../IncidentPayload/IncidentPayload.json | 9 + .../SavedSearchPayload.json | 20 + .../ScheduledAlertRulePayload.json | 23 + .../SecurityAlertRulePayload.json | 10 + .../AzureSentinel_ManagementAPI/Utils.cs | 190 +++++ .../appsettings.json | 40 + .../AzureSentinel_ManagementAPI/copydata.bat | 2 + .../Images/After-consent.PNG | Bin 0 -> 70914 bytes .../Images/AzureSentinel-permission.PNG | Bin 0 -> 89957 bytes .../Images/Console-Menu.PNG | Bin 0 -> 39377 bytes .../Images/LogicApp-permission.PNG | Bin 0 -> 78921 bytes .../Images/Start-button.PNG | Bin 0 -> 88674 bytes .../Images/admin-consent.PNG | Bin 0 -> 54377 bytes .../README.md | 189 +++++ 77 files changed, 6276 insertions(+) create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/.gitignore create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI.sln create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.gitignore create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.vscode/launch.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.vscode/tasks.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/ActionsController.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/Models/ActionRequestPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/Models/ActionRequestPropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRuleTemplates/AlertRuleTemplatesController.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/AlertRulesController.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/AlertRuleKind.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/AlertRulePayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/FusionAlertRulePayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/FusionAlertRulePropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ProductFilter.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ScheduledAlertRulePayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ScheduledAlertRulePropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/SecurityIncidentCreationAlertRulePayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/SecurityIncidentCreationAlertRulePropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/TriggerOperator.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AppHost.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AzureSentinel_ManagementAPI.csproj create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/BookmarksController.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/BookmarkPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/BookmarkPropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/IncidentInfo.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/DataConnectorsController.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorDataTypesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorPropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectionState.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectorKind.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectorPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataTypeConnectionStatePayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchPropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchTag.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/SavedSearchController.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/IncidentRelationController.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/EntityKind.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationEntityPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationPropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/IncidentsController.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/Comments/IncidentCommentPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/Comments/IncidentCommentPropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentAdditionalData.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentOwner.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentPropertiesPayload.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentStatus.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/Authentication/AuthenticationService.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/Configuration/AzureSentinelApiConfiguration.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/SharedModels/Enums/Severity.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/SharedModels/TupleList.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Program.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Resource1.Designer.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Resource1.resx create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/ActionPayload/ActionPayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/BookmarkPayload/BookmarkPayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/DataConnectorPayload/DataConnectorPayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/FusionAlertRulePayload/FusionAlertRulePayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/IncidentCommentPayload/IncidentCommentPayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/IncidentPayload/IncidentPayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/SavedSearchPayload/SavedSearchPayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/ScheduledAlertRulePayload/ScheduledAlertRulePayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/SecurityAlertRulePayload/SecurityAlertRulePayload.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Utils.cs create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/appsettings.json create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/copydata.bat create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/After-consent.PNG create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/AzureSentinel-permission.PNG create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/Console-Menu.PNG create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/LogicApp-permission.PNG create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/Start-button.PNG create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/admin-consent.PNG create mode 100644 Tools/Sample Code/AzureSentinel-ManagementAPICsharp/README.md diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/.gitignore b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/.gitignore new file mode 100644 index 0000000000..a39c1ad538 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/.gitignore @@ -0,0 +1,2 @@ +.idea +.vs \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI.sln b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI.sln new file mode 100644 index 0000000000..404aac89c3 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.30204.135 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AzureSentinel_ManagementAPI", "AzureSentinel_ManagementAPI\AzureSentinel_ManagementAPI.csproj", "{F5D25CF4-7FA5-43C3-A14A-28C8816701BF}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {F5D25CF4-7FA5-43C3-A14A-28C8816701BF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F5D25CF4-7FA5-43C3-A14A-28C8816701BF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F5D25CF4-7FA5-43C3-A14A-28C8816701BF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F5D25CF4-7FA5-43C3-A14A-28C8816701BF}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {540DF26E-3A66-49E5-8560-20C3006303AE} + EndGlobalSection +EndGlobal diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.gitignore b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.gitignore new file mode 100644 index 0000000000..6e6ebbe817 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.gitignore @@ -0,0 +1,366 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +#appsettings.json +../.idea +../.vs diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.vscode/launch.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.vscode/launch.json new file mode 100644 index 0000000000..82b16db3ff --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.vscode/launch.json @@ -0,0 +1,22 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": ".NET Core Launch (console)", + "type": "coreclr", + "request": "launch", + "preLaunchTask": "build", + "program": "${workspaceFolder}/bin/Debug/netcoreapp3.1/AzureSentinel_ManagementAPI.dll", + "args": [], + "cwd": "${workspaceFolder}", + "console": "internalConsole", + "stopAtEntry": false + }, + { + "name": ".NET Core Attach", + "type": "coreclr", + "request": "attach", + "processId": "${command:pickProcess}" + } + ] +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.vscode/tasks.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.vscode/tasks.json new file mode 100644 index 0000000000..64c4bad693 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/.vscode/tasks.json @@ -0,0 +1,42 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "build", + "command": "dotnet", + "type": "process", + "args": [ + "build", + "${workspaceFolder}/AzureSentinel_ManagementAPI.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "publish", + "command": "dotnet", + "type": "process", + "args": [ + "publish", + "${workspaceFolder}/AzureSentinel_ManagementAPI.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + }, + { + "label": "watch", + "command": "dotnet", + "type": "process", + "args": [ + "watch", + "run", + "${workspaceFolder}/AzureSentinel_ManagementAPI.csproj", + "/property:GenerateFullPaths=true", + "/consoleloggerparameters:NoSummary" + ], + "problemMatcher": "$msCompile" + } + ] +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/ActionsController.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/ActionsController.cs new file mode 100644 index 0000000000..8af2c40988 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/ActionsController.cs @@ -0,0 +1,266 @@ +using System; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Actions.Models; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.Extensions.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Newtonsoft.Json.Serialization; + +namespace AzureSentinel_ManagementAPI.Actions +{ + public class ActionsController + { + private readonly AzureSentinelApiConfiguration[] azureConfigs; + private readonly AuthenticationService authenticationService; + private bool cliMode; + + public ActionsController( + AzureSentinelApiConfiguration[] azureConfig, + IConfigurationRoot rawConfig, + AuthenticationService authenticationService) + { + azureConfigs = azureConfig; + this.authenticationService = authenticationService; + cliMode = rawConfig.GetValue("Climode"); + } + + /// + /// Create action from payload json + /// + /// + /// + public async Task CreateAction(string ruleId, int insId, string logicAppResourceId = "") + { + ActionRequestPayload[] actions = Utils.LoadPayload("ActionPayload.json", cliMode); + + foreach (ActionRequestPayload payload in actions) + { + try + { + string subscription = azureConfigs[insId].SubscriptionId; + string resourceGroup = azureConfigs[insId].ResourceGroupName; + payload.PropertiesPayload.LogicAppResourceId = string.Format(payload.PropertiesPayload.LogicAppResourceId, subscription, resourceGroup); + + string actionId = Guid.NewGuid().ToString(); + string url = $"{azureConfigs[insId].BaseUrl}/alertRules/{ruleId}/actions/{actionId}?api-version={azureConfigs[insId].ApiVersion}"; + if (!string.IsNullOrEmpty(logicAppResourceId)) + { + payload.PropertiesPayload.LogicAppResourceId = logicAppResourceId; + } + + string serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + } + + /// + /// Delete an action by rule id and action id + /// + /// + /// + /// + public async Task DeleteAction(string ruleId, string actionId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/alertRules/{ruleId}/actions/{actionId}?api-version={azureConfigs[insId].ApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Delete, url); + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + if (response.StatusCode == HttpStatusCode.NotFound) + throw new Exception("Not found, please create a new Action first..."); + + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get an action by rule id and action id + /// + /// + /// + /// + public async Task GetActionById(string ruleId, string actionId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/alertRules/{ruleId}/actions/{actionId}?api-version={azureConfigs[insId].ApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get an action by rule id and action id by instance + /// + /// + /// + /// + public async Task GetAlertRuleByName(string ruleName, int insId) + { + var url = $"{azureConfigs[insId].BaseUrl}/alertRules/{ruleName}?api-version={azureConfigs[insId].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + + /// + /// Get all actions under a rule + /// + /// + /// + public async Task GetActionsByRule(string ruleId, int insId) + { + try + { + await GetAlertRuleByName(ruleId, insId); + + var url = $"{azureConfigs[insId].BaseUrl}/alertRules/{ruleId}/actions?api-version={azureConfigs[insId].ApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject result = JsonConvert.DeserializeObject(res); + var values = result["value"] as JArray; + + if (values == null) + { + values = new JArray(); + } + + int callTimes = 1; + + while (result.ContainsKey("nextLink") && callTimes < 100) + { + try + { + var nextLink = result["nextLink"].ToString(); + request = new HttpRequestMessage(HttpMethod.Get, nextLink); + await authenticationService.AuthenticateRequest(request, insId); + var nextResponse = await http.SendAsync(request); + + if (nextResponse.IsSuccessStatusCode) + { + var newRes = await nextResponse.Content.ReadAsStringAsync(); + JObject newResult = JsonConvert.DeserializeObject(newRes); + result = newResult; + var newValues = result["value"] as JArray; + + if (newValues == null) + { + newValues = new JArray(); + } + + foreach (var v in newValues) + { + values.Add(v); + } + callTimes++; + } + else + { + var err = await response.Content.ReadAsStringAsync(); + Console.WriteLine("Error calling the nextLink: \n" + err); + break; + } + } + catch (Exception ex) + { + Console.WriteLine("Error in parsing nextLink: \n" + ex.Message); + break; + } + } + + Utils.WriteJsonStringToFile($"GetActionsByRule_{azureConfigs[insId].InstanceName}.json", cliMode, JsonConvert.SerializeObject(values, Formatting.Indented), false); + return res; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/Models/ActionRequestPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/Models/ActionRequestPayload.cs new file mode 100644 index 0000000000..541d368644 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/Models/ActionRequestPayload.cs @@ -0,0 +1,13 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.Actions.Models +{ + public class ActionRequestPayload + { + [JsonProperty("etag")] + public string ETag { get; set; } + + [JsonProperty("properties")] + public ActionRequestPropertiesPayload PropertiesPayload { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/Models/ActionRequestPropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/Models/ActionRequestPropertiesPayload.cs new file mode 100644 index 0000000000..0fdd90d473 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Actions/Models/ActionRequestPropertiesPayload.cs @@ -0,0 +1,8 @@ +namespace AzureSentinel_ManagementAPI.Actions.Models +{ + public class ActionRequestPropertiesPayload + { + public string LogicAppResourceId { get; set; } + public string TriggerUri { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRuleTemplates/AlertRuleTemplatesController.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRuleTemplates/AlertRuleTemplatesController.cs new file mode 100644 index 0000000000..0b51d8d57b --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRuleTemplates/AlertRuleTemplatesController.cs @@ -0,0 +1,112 @@ +using System; +using System.Net; +using System.Net.Http; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.Extensions.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; + +namespace AzureSentinel_ManagementAPI.AlertRuleTemplates +{ + public class AlertRuleTemplatesController + { + private readonly AuthenticationService authenticationService; + private readonly AzureSentinelApiConfiguration[] azureConfigs; + private bool cliMode; + + public AlertRuleTemplatesController( + AuthenticationService authenticationService, + IConfigurationRoot rawConfig, + AzureSentinelApiConfiguration[] azureConfig) + { + this.authenticationService = authenticationService; + azureConfigs = azureConfig; + cliMode = rawConfig.GetValue("Climode"); + } + + /// + /// Get alert rule templates for all instances or for a single instance + /// + /// + public async Task GetAlertRuleTemplates(int insId = -1) + { + if (insId != -1) + { + await GetAlertRuleTemplatesByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await GetAlertRuleTemplatesByInstance(i); + } + } + } + + /// + /// Get alert rule templates for a single instance + /// + /// + /// + private async Task GetAlertRuleTemplatesByInstance(int i) + { + try + { + var url = $"{azureConfigs[i].BaseUrl}/alertRuleTemplates?api-version={azureConfigs[i].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, i); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + Utils.WriteJsonStringToFile($"GetAlertRuleTemplates_{azureConfigs[i].InstanceName}.json", cliMode, res); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + return; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + + } + + /// + /// Get alert rule template by id + /// + /// + /// + public async Task GetAlertRuleTemplateById(string ruleTmplId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/alertRuleTemplates/{ruleTmplId}?api-version={azureConfigs[insId].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/AlertRulesController.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/AlertRulesController.cs new file mode 100644 index 0000000000..53e6695a91 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/AlertRulesController.cs @@ -0,0 +1,464 @@ +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Http; +using System.Net.Security; +using System.Text; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Actions; +using AzureSentinel_ManagementAPI.AlertRules.Models; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.Extensions.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Newtonsoft.Json.Serialization; + +namespace AzureSentinel_ManagementAPI.AlertRules +{ + public class AlertRulesController + { + private readonly AzureSentinelApiConfiguration[] azureConfigs; + private readonly AuthenticationService authenticationService; + private bool cliMode; + + public AlertRulesController(AzureSentinelApiConfiguration[] azureConfig, + IConfigurationRoot rawConfig, + AuthenticationService authenticationService) + { + azureConfigs = azureConfig; + this.authenticationService = authenticationService; + cliMode = rawConfig.GetValue("Climode"); + } + + /// + /// Create funsion alert rule for all instances or for a single instance + /// + /// + public async Task CreateFusionAlertRule(int insId = -1) + { + if (insId != -1) + { + await CreateFusionAlertRuleByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await CreateFusionAlertRuleByInstance(i); + } + } + } + + /// + /// Create funsion alert rule for a single instance + /// + /// + /// + public async Task CreateFusionAlertRuleByInstance(int i) + { + var alertRules = Utils.LoadPayload("FusionAlertRulePayload.json", cliMode); + + foreach (var payload in alertRules) + { + try + { + var ruleId = Guid.NewGuid().ToString(); + var url = + $"{azureConfigs[i].BaseUrl}/alertRules/{ruleId}?api-version={azureConfigs[i].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, i); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } + + /// + /// Create Microsoft security incident creation alert rule for all instances or for a single instance + /// + /// + public async Task CreateMicrosoftSecurityIncidentCreationAlertRule(int insId = -1) + { + if (insId != -1) + { + await CreateMSSecurityIncidentAlertRuleByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await CreateMSSecurityIncidentAlertRuleByInstance(i); + } + } + } + + /// + /// Create Microsoft security incident creation alert rule for a single instance + /// + /// + /// + public async Task CreateMSSecurityIncidentAlertRuleByInstance(int i) + { + var alertRules = Utils.LoadPayload("SecurityAlertRulePayload.json", cliMode); + + foreach (var payload in alertRules) + { + try + { + var alertRuleId = Guid.NewGuid().ToString(); + var url = + $"{azureConfigs[i].BaseUrl}/alertRules/{alertRuleId}?api-version={azureConfigs[i].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, i); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } + + /// + /// Create scheduled alert rule for all instances or for a single instance + /// + /// + public async Task CreateScheduledAlertRule(ActionsController actionsController, int insId = -1) + { + if (insId != -1) + { + await CreateScheduledAlertRuleByInstance(insId, actionsController); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await CreateScheduledAlertRuleByInstance(i, actionsController); + } + } + } + + /// + /// Create scheduled alert rule for a single instance + /// + /// + /// + public async Task CreateScheduledAlertRuleByInstance(int i, ActionsController actionsController) + { + var alertRules = Utils.LoadPayload("ScheduledAlertRulePayload.json", cliMode); + + foreach (var payload in alertRules) + { + try + { + var alertRuleId = Guid.NewGuid().ToString(); + var url = + $"{azureConfigs[i].BaseUrl}/alertRules/{alertRuleId}?api-version={azureConfigs[i].ApiVersion}"; + + string playbook = payload.Playbook; + string subscription = azureConfigs[i].SubscriptionId; + string resourceGroup = azureConfigs[i].ResourceGroupName; + playbook = string.Format(playbook, subscription, resourceGroup); + payload.Playbook = null; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + NullValueHandling = NullValueHandling.Ignore, + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, i); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + + if (!string.IsNullOrEmpty(playbook)) + { + await actionsController.CreateAction(alertRuleId, i, playbook); + } + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } + + /// + /// Delete an alert rule by id + /// + /// + /// + public async Task DeleteAlertRule(string ruleId, int insId) + { + try + { + var url = + $"{azureConfigs[insId].BaseUrl}/alertRules/{ruleId}?api-version={azureConfigs[insId].ApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Delete, url); + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + if (response.StatusCode == HttpStatusCode.NotFound) + throw new Exception("Not found, please create a new Alert first..."); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get funsion alert rule by id + /// + /// + /// + public async Task GetFusionAlertRule(string ruleId, int insId) + { + return await GetAlertRuleByName(ruleId, insId); + } + + /// + /// Get Microsoft security incident creation alert rule by id + /// + /// + /// + public async Task GetMicrosoftSecurityIdentityCreationAlertRule(string ruleId, int insId) + { + return await GetAlertRuleByName(ruleId, insId); + } + + /// + /// Get scheduled alert rule by id + /// + /// + /// + public async Task GetScheduledAlertRule(string ruleId, int insId) + { + return await GetAlertRuleByName(ruleId, insId); + } + + /// + /// Get alert rule by rule id + /// + /// + /// + private async Task GetAlertRuleByName(string ruleName, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/alertRules/{ruleName}?api-version={azureConfigs[insId].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get all alert rules for all instances or for a single instance + /// + /// + public async Task GetAlertRules(int insId = -1) + { + if (insId != -1) + { + await GetAlertRulesByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await GetAlertRulesByInstance(i); + } + } + } + + /// + /// Get alert rules for a single instance + /// + /// + /// + private async Task GetAlertRulesByInstance(int i) + { + try + { + var url = $"{azureConfigs[i].BaseUrl}/alertRules?api-version={azureConfigs[i].ApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, i); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject result = JsonConvert.DeserializeObject(res); + var values = result["value"] as JArray; + + if (values == null) + { + values = new JArray(); + } + + int callTimes = 1; + + while (result.ContainsKey("nextLink") && callTimes < 100) + { + try + { + var nextLink = result["nextLink"].ToString(); + request = new HttpRequestMessage(HttpMethod.Get, nextLink); + await authenticationService.AuthenticateRequest(request, i); + var nextResponse = await http.SendAsync(request); + + if (nextResponse.IsSuccessStatusCode) + { + var newRes = await nextResponse.Content.ReadAsStringAsync(); + JObject newResult = JsonConvert.DeserializeObject(newRes); + result = newResult; + var newValues = result["value"] as JArray; + + if (newValues == null) + { + newValues = new JArray(); + } + + foreach (var v in newValues) + { + values.Add(v); + } + callTimes++; + } + else + { + var err = await response.Content.ReadAsStringAsync(); + Console.WriteLine("Error calling the nextLink: \n" + err); + break; + } + } + catch (Exception ex) + { + Console.WriteLine("Error in parsing nextLink: \n" + ex.Message); + break; + } + } + + var formattedRes = JsonConvert.SerializeObject(values, Formatting.Indented); + Utils.WriteJsonStringToFile($"GetAlertRules_{azureConfigs[i].InstanceName}.json", cliMode, formattedRes, false); + Console.WriteLine(formattedRes); + return; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/AlertRuleKind.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/AlertRuleKind.cs new file mode 100644 index 0000000000..f8dccbc8e3 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/AlertRuleKind.cs @@ -0,0 +1,9 @@ +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public enum AlertRuleKind + { + Scheduled, + MicrosoftSecurityIncidentCreation, + Fusion + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/AlertRulePayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/AlertRulePayload.cs new file mode 100644 index 0000000000..d07774a07e --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/AlertRulePayload.cs @@ -0,0 +1,14 @@ +using Newtonsoft.Json; +using Newtonsoft.Json.Converters; + +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public abstract class AlertRulePayload + { + public string Etag { get; set; } + + [JsonConverter(typeof(StringEnumConverter))] + public AlertRuleKind Kind { get; set; } + + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/FusionAlertRulePayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/FusionAlertRulePayload.cs new file mode 100644 index 0000000000..46f790be82 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/FusionAlertRulePayload.cs @@ -0,0 +1,15 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public class FusionAlertRulePayload : AlertRulePayload + { + public FusionAlertRulePayload() + { + Kind = AlertRuleKind.Fusion; + } + + [JsonProperty("properties")] + public FusionAlertRulePropertiesPayload PropertiesPayload { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/FusionAlertRulePropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/FusionAlertRulePropertiesPayload.cs new file mode 100644 index 0000000000..a200a41832 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/FusionAlertRulePropertiesPayload.cs @@ -0,0 +1,8 @@ +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public class FusionAlertRulePropertiesPayload + { + public string AlertRuleTemplateName { get; set; } + public bool Enabled { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ProductFilter.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ProductFilter.cs new file mode 100644 index 0000000000..278281cd82 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ProductFilter.cs @@ -0,0 +1,11 @@ +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public class ProductFilter + { + public const string MicrosoftCloudAppSecurity = "Microsoft Cloud App Security"; + public const string AzureSecurityCenter = "Azure Security Center"; + public const string AzureAdvancedThreatProtection = "Azure Advanced Threat Protection"; + public const string AzureActiveDirectoryIdentityProtection = "Azure Active Directory Identity Protection"; + public const string AzureSecurityCenterForIoT = "Azure Security Center for IoT"; + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ScheduledAlertRulePayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ScheduledAlertRulePayload.cs new file mode 100644 index 0000000000..06615b4638 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ScheduledAlertRulePayload.cs @@ -0,0 +1,17 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public class ScheduledAlertRulePayload : AlertRulePayload + { + public ScheduledAlertRulePayload() + { + Kind = AlertRuleKind.Scheduled; + } + + [JsonProperty("properties")] + public ScheduledAlertRulePropertiesPayload PropertiesPayload { get; set; } + + public string Playbook { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ScheduledAlertRulePropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ScheduledAlertRulePropertiesPayload.cs new file mode 100644 index 0000000000..ea2081bc7d --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/ScheduledAlertRulePropertiesPayload.cs @@ -0,0 +1,26 @@ +using AzureSentinel_ManagementAPI.Infrastructure.SharedModels.Enums; +using Newtonsoft.Json; +using Newtonsoft.Json.Converters; + +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public class ScheduledAlertRulePropertiesPayload + { + public string Query { get; set; } + public string QueryFrequency { get; set; } + public string QueryPeriod { get; set; } + + [JsonConverter(typeof(StringEnumConverter))] + public Severity Severity { get; set; } + + [JsonConverter(typeof(StringEnumConverter))] + public TriggerOperator TriggerOperator { get; set; } + + public int TriggerThreshold { get; set; } + public string DisplayName { get; set; } + public bool Enabled { get; set; } + public string SuppressionDuration { get; set; } + public bool SuppressionEnabled { get; set; } + public string Description { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/SecurityIncidentCreationAlertRulePayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/SecurityIncidentCreationAlertRulePayload.cs new file mode 100644 index 0000000000..f33528868b --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/SecurityIncidentCreationAlertRulePayload.cs @@ -0,0 +1,15 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public class SecurityIncidentCreationAlertRulePayload: AlertRulePayload + { + public SecurityIncidentCreationAlertRulePayload() + { + Kind = AlertRuleKind.MicrosoftSecurityIncidentCreation; + } + + [JsonProperty("properties")] + public SecurityIncidentCreationAlertRulePropertiesPayload PropertiesPayload { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/SecurityIncidentCreationAlertRulePropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/SecurityIncidentCreationAlertRulePropertiesPayload.cs new file mode 100644 index 0000000000..255f495d59 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/SecurityIncidentCreationAlertRulePropertiesPayload.cs @@ -0,0 +1,9 @@ +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public class SecurityIncidentCreationAlertRulePropertiesPayload + { + public string ProductFilter { get; set; } + public string DisplayName { get; set; } + public bool Enabled { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/TriggerOperator.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/TriggerOperator.cs new file mode 100644 index 0000000000..77be3a71b6 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AlertRules/Models/TriggerOperator.cs @@ -0,0 +1,10 @@ +namespace AzureSentinel_ManagementAPI.AlertRules.Models +{ + public enum TriggerOperator + { + GreaterThan, + LessThan, + Equal, + NotEqual + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AppHost.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AppHost.cs new file mode 100644 index 0000000000..22aeec6974 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AppHost.cs @@ -0,0 +1,758 @@ +using System; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Actions; +using AzureSentinel_ManagementAPI.AlertRules; +using AzureSentinel_ManagementAPI.AlertRuleTemplates; +using AzureSentinel_ManagementAPI.Bookmarks; +using AzureSentinel_ManagementAPI.DataConnectors; +using AzureSentinel_ManagementAPI.Incidents; +using AzureSentinel_ManagementAPI.IncidentRelation; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using System.Collections.Generic; +using AzureSentinel_ManagementAPI.Infrastructure.SharedModels; +using Microsoft.Extensions.Configuration; +using AzureSentinel_ManagementAPI.Hunting; + +namespace AzureSentinel_ManagementAPI +{ + class AppHost + { + private readonly AuthenticationService authenticationService; + private readonly AlertRulesController alertRulesController; + private readonly AlertRuleTemplatesController alertRuleTemplatesController; + private readonly IncidentsController incidentsController; + private readonly ActionsController actionsController; + private readonly BookmarksController bookmarksController; + private readonly DataConnectorsController dataConnectorsController; + private readonly IncidentRelationController incidentRelationController; + private readonly SavedSearchController savedSearchController; + private readonly AzureSentinelApiConfiguration[] configurations; + + private List> cmdArgs; + private bool cliMode; + + public AppHost( + IConfigurationRoot rawConfig, + AzureSentinelApiConfiguration[] configurations, + AlertRulesController alertRulesController, + AuthenticationService authenticationService, + AlertRuleTemplatesController alertRuleTemplatesController, + IncidentsController incidentsController, + ActionsController actionsController, + BookmarksController bookmarksController, + DataConnectorsController dataConnectorsController, + IncidentRelationController incidentRelationController, + SavedSearchController savedSearchController) + { + this.configurations = configurations; + this.alertRulesController = alertRulesController; + this.authenticationService = authenticationService; + this.alertRuleTemplatesController = alertRuleTemplatesController; + this.incidentsController = incidentsController; + this.actionsController = actionsController; + this.bookmarksController = bookmarksController; + this.dataConnectorsController = dataConnectorsController; + this.incidentRelationController = incidentRelationController; + this.savedSearchController = savedSearchController; + + cliMode = rawConfig.GetValue("Climode"); + + string exeName = "AzureSentinel_ManagementAPI.exe"; + cmdArgs = new TupleList + { + {$": {exeName} 1 [instanceId]", 3 }, + {$": {exeName} 2 [instanceId]", 4 }, + {$": {exeName} 3 [instanceId]", 4}, + {$": {exeName} 4 [instanceId]", 3}, + {$": {exeName} 5 [instanceId]", 3}, + {$": {exeName} 6 [instanceId]", 2}, + {$": {exeName} 7 [instanceId]", 2}, + {$": {exeName} 8 [instanceId]", 2}, + {$": {exeName} 9 [instanceId]", 2}, + {$": {exeName} 10 [instanceId]", 3}, + {$": {exeName} 11 [instanceId]", 2}, + {$": {exeName} 12 [instanceId]", 3}, + {$": {exeName} 13 [instanceId]", 3}, + {$": {exeName} 14 [instanceId]", 3}, + {$": {exeName} 15 [instanceId]", 2}, + {$": {exeName} 16 [instanceId]", 3}, + {$": {exeName} 17 [instanceId]", 3}, + {$": {exeName} 18 [instanceId]", 2}, + {$": {exeName} 19 [instanceId]", 2}, + {$": {exeName} 20 [instanceId]", 3}, + {$": {exeName} 21 [instanceId]", 2}, + {$": {exeName} 22 [instanceId]", 2}, + {$": {exeName} 23 [instanceId]", 3}, + {$": {exeName} 24 [instanceId]", 3}, + {$": {exeName} 25 [instanceId]", 2}, + {$": {exeName} 26 [instanceId]", 3}, + {$": {exeName} 27 [instanceId]", 2}, + {$": {exeName} 28 [instanceId]", 3}, + {$": {exeName} 29 [instanceId]", 3}, + {$": {exeName} 30 [instanceId]", 4}, + {$": {exeName} 31 [instanceId]", 4}, + {$": {exeName} 32 [instanceId]", 4}, + {$": {exeName} 33 [instanceId]", 3}, + {$": {exeName} 34 [instanceId]", 4}, + {$": {exeName} 35 [instanceId]", 3}, + }; + } + + private void CommandInvalidFormatError() + { + Console.WriteLine("invalid command line"); + PrintCLIMenu(); + throw new Exception("invalid command line"); + } + + public async Task Run(string[] args) + { + if (cliMode) + { + if (args.Length < 1) + { + CommandInvalidFormatError(); + } + + string option = args[0]; + bool isValid = int.TryParse(option, out var index); + isValid = isValid && index > 0 && index < 36; + if (!isValid) + { + CommandInvalidFormatError(); + } + + if (args.Length < cmdArgs[index - 1].Item2 - 1) + { + CommandInvalidFormatError(); + } + + int insId = args.Length == cmdArgs[index - 1].Item2 - 1 ? + 0 : int.Parse(args[cmdArgs[index - 1].Item2 - 1]); + + await RunCommands(cliMode, index, args, insId); + } + else + { + while (true) + { + PrintMenu(); + + Console.Write(Utils.GetString("Option")); + string option = Console.ReadLine(); + + bool isValid = int.TryParse(option, out var index); + isValid = isValid && index > 0 && index < 41; + + if (!isValid) + { + Console.WriteLine(Utils.GetString("Invalid_Option_Text")); + Console.ReadLine(); + continue; + } + + await RunCommands(cliMode, index, args); + + Console.WriteLine(); + Console.WriteLine(Utils.GetString("Continue_Prompt_Text")); + Console.ReadLine(); + } + } + } + + public async Task RunCommands(bool cliMode, int index, string[] args, int insId = 0) + { + string response = ""; + + try + { + switch (index) + { + case 1: + { + string ruleId = cliMode ? args[1] : GetNonEmptyInput(Utils.GetString("Action_Rule_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await actionsController.CreateAction(ruleId, insId); + break; + } + case 2: + { + string ruleId = cliMode ? args[1] : GetNonEmptyInput(Utils.GetString("Action_Rule_Id_Prompt_Text")); + string actionId = cliMode ? args[2] : GetNonEmptyInput(Utils.GetString("Action_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await actionsController.DeleteAction(ruleId, actionId, insId); + break; + } + case 3: + { + string ruleId = cliMode ? args[1] : GetNonEmptyInput(Utils.GetString("Action_Rule_Id_Prompt_Text")); + string actionId = cliMode ? args[2] : GetNonEmptyInput(Utils.GetString("Action_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await actionsController.GetActionById(ruleId, actionId, insId); + break; + } + case 4: + { + string ruleId = cliMode ? args[1] : GetNonEmptyInput(Utils.GetString("Action_Rule_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await actionsController.GetActionsByRule(ruleId, insId); + break; + } + + case 5: + { + + string ruleTmplId = cliMode? args[1]: GetInput(Utils.GetString("Rule_Template_Id_Prompt_Text"), + "57c0cfc-d76d-463b-8755-c781608cdc1a"); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await alertRuleTemplatesController.GetAlertRuleTemplateById(ruleTmplId, insId); + break; + } + case 6: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await alertRuleTemplatesController.GetAlertRuleTemplates(insId); + break; + } + + case 7: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await alertRulesController.CreateFusionAlertRule(insId); + break; + } + case 8: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await alertRulesController.CreateMicrosoftSecurityIncidentCreationAlertRule(insId); + break; + } + case 9: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await alertRulesController.CreateScheduledAlertRule(actionsController, insId); + break; + } + case 10: + { + string ruleId = cliMode ? args[1] : GetNonEmptyInput(Utils.GetString("Rule_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await alertRulesController.DeleteAlertRule(ruleId, insId); + break; + } + case 11: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await alertRulesController.GetAlertRules(insId); + break; + } + case 12: + { + string ruleId = cliMode ? args[1] : GetNonEmptyInput(Utils.GetString("Get_Fusion_Rule_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await alertRulesController.GetFusionAlertRule(ruleId, insId); + break; + } + case 13: + { + string ruleId = cliMode ? args[1] : GetInput(Utils.GetString("Get_Incident_Rule_Prompt_Text"), "Microsoft-alert-rule-2"); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await alertRulesController.GetMicrosoftSecurityIdentityCreationAlertRule(ruleId, insId); + break; + } + case 14: + { + string ruleId = cliMode ? args[1] : GetInput(Utils.GetString("Get_Scheduled_Rule_Prompt_Text"), "scheduled-alert-rule-3"); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await alertRulesController.GetScheduledAlertRule(ruleId, insId); + break; + } + + case 15: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await bookmarksController.CreateBookmark(insId); + break; + } + case 16: + { + string bookmarkId = cliMode ? args[1] : GetNonEmptyInput(Utils.GetString("Bookmark_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await bookmarksController.DeleteBookmark(bookmarkId, insId); + break; + } + case 17: + { + string bookmarkId = cliMode ? args[1] : GetNonEmptyInput(Utils.GetString("Bookmark_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await bookmarksController.GetBookmarkById(bookmarkId, insId); + break; + } + case 18: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await bookmarksController.GetBookmarks(insId); + break; + } + + case 19: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await dataConnectorsController.GetDataConnectors(insId); + break; + } + case 20: + { + string dataConnectorId = GetNonEmptyInput(Utils.GetString("Dataconnector_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await dataConnectorsController.DeleteDataConnector(dataConnectorId, insId); + break; + } + case 21: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await dataConnectorsController.CreateDataConnector(insId); + break; + } + + case 22: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await incidentsController.CreateIncident(insId); + break; + } + case 23: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Delete_Incident_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await incidentsController.DeleteIncident(incidentId, insId); + break; + } + case 24: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Get_Incident_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await incidentsController.GetIncidentById(incidentId, insId); + break; + } + case 25: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await incidentsController.GetIncidents(insId); + break; + } + case 26: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await incidentsController.UpdateIncident(incidentId, insId); + break; + } + case 27: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await incidentsController.BatchUpdateIncidents(insId); + break; + } + case 28: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + await incidentsController.CreateIncidentComment(incidentId); + break; + } + case 29: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await incidentsController.GetAllIncidentComments(incidentId, insId); + break; + } + case 30: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + string commentId = GetNonEmptyInput(Utils.GetString("Comment_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await incidentsController.GetIncidentCommentById(incidentId, commentId, insId); + break; + } + case 31: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + string bookmarkId = GetNonEmptyInput(Utils.GetString("Bookmark_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await incidentRelationController.CreateIncidentRelation(incidentId, bookmarkId, insId); + break; + } + case 32: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + string relationId = GetNonEmptyInput(Utils.GetString("Relation_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await incidentRelationController.DeleteIncidentRelation(incidentId, relationId, insId); + break; + } + case 33: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + await incidentRelationController.GetEntitiesforIncident(incidentId, insId); + break; + } + case 34: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + string relationId = GetNonEmptyInput(Utils.GetString("Relation_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + await incidentRelationController.GetIncidentRelationByName(incidentId, relationId, insId); + break; + } + case 35: + { + string incidentId = GetNonEmptyInput(Utils.GetString("Incident_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + await incidentRelationController.GetIncidentEntitiesbyEntityType(incidentId, insId); + break; + } + case 36: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await savedSearchController.CreateSavedSearch(insId); + break; + } + case 37: + { + string savedSearchId = GetNonEmptyInput(Utils.GetString("Saved_Search_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await savedSearchController.DeleteSavedSearch(savedSearchId, insId); + break; + } + case 38: + { + string savedSearchId = GetNonEmptyInput(Utils.GetString("Saved_Search_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + response = await savedSearchController.GetSavedSearchById(savedSearchId, insId); + break; + } + case 39: + { + if (!cliMode) + { + insId = Utils.SelectInstanceOrApplyAll(configurations); + } + await savedSearchController.GetSavedSearches(insId); + break; + } + case 40: + { + string savedSearchId = GetNonEmptyInput(Utils.GetString("Saved_Search_Id_Prompt_Text")); + if (!cliMode) + { + insId = Utils.SelectInstance(configurations); + } + await savedSearchController.UpdateSavedSearch(savedSearchId, insId); + break; + } + } + + if (response != string.Empty) + { + Console.WriteLine(JToken.Parse(response).ToString(Formatting.Indented)); + } + } + catch (JsonReaderException exception) + { + if (string.IsNullOrEmpty(response)) + { + Console.WriteLine("Deleted"); + Console.WriteLine(Utils.GetString("Continue_Prompt_Text")); + Console.ReadLine(); + return; + } + } + catch (Exception exception) + { + ConsoleColor currentColor = Console.ForegroundColor; + Console.ForegroundColor = ConsoleColor.Red; + await Console.Error.WriteLineAsync(exception.Message); + Console.ForegroundColor = currentColor; + } + + Console.WriteLine(response); + } + + private string GetNonEmptyInput(string promptText) + { + var id = ""; + + while (id.Trim() == string.Empty) + { + Console.WriteLine(promptText); + id = Console.ReadLine(); + } + + return id; + } + + private string GetInput(string promptText, string defaultValue = "") + { + Console.WriteLine(promptText); + var input = Console.ReadLine(); + + if (input.Trim() == string.Empty) + { + input = defaultValue; + } + + return input; + } + + public void PrintMenu() + { + Console.WriteLine(Utils.GetString("Actions_Menu")); + Console.WriteLine(Utils.GetString("Create_Action_Menu")); + Console.WriteLine(Utils.GetString("Delete_Action_Menu")); + Console.WriteLine(Utils.GetString("Get_Action_By_Id_Menu")); + Console.WriteLine(Utils.GetString("Get_Actions_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Alert_Rule_Template_Menu")); + Console.WriteLine(Utils.GetString("Get_Rule_Template_By_Id_Menu")); + Console.WriteLine(Utils.GetString("Get_Rule_Templates_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Alert_Rules_Menu")); + Console.WriteLine(Utils.GetString("Create_Fusion_Rule_Menu")); + Console.WriteLine(Utils.GetString("Create_Incident_Rule_Menu")); + Console.WriteLine(Utils.GetString("Create_Scheduled_Rule_Menu")); + Console.WriteLine(Utils.GetString("Delete_Rule_Menu")); + Console.WriteLine(Utils.GetString("Get_Rules_Menu")); + Console.WriteLine(Utils.GetString("Get_Fusion_Rule_Menu")); + Console.WriteLine(Utils.GetString("Get_Incident_Rule_Menu")); + Console.WriteLine(Utils.GetString("Get_Scheduled_Rule_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Bookmarks_Menu")); + Console.WriteLine(Utils.GetString("Create_Bookmark_Menu")); + Console.WriteLine(Utils.GetString("Delete_Bookmark_Menu")); + Console.WriteLine(Utils.GetString("Get_Bookmark_By_Id_Menu")); + Console.WriteLine(Utils.GetString("Get_Bookmarks_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("DataConnectors_Menu")); + Console.WriteLine(Utils.GetString("Get_DataConnectors_Menu")); + Console.WriteLine(Utils.GetString("Delete_DataConnector_Menu")); + Console.WriteLine(Utils.GetString("Create_DataConnector_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Incident_Menu")); + Console.WriteLine(Utils.GetString("Create_Incident_Menu")); + Console.WriteLine(Utils.GetString("Delete_Incident_Menu")); + Console.WriteLine(Utils.GetString("Get_Incident_By_Id_Menu")); + Console.WriteLine(Utils.GetString("Get_Incidents_Menu")); + Console.WriteLine(Utils.GetString("Update_Incident_Menu")); + Console.WriteLine(Utils.GetString("Batch_Update_Incidents_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Incident_Comments_Menu")); + Console.WriteLine(Utils.GetString("Create_Incident_Comment_Menu")); + Console.WriteLine(Utils.GetString("Get_Incident_Comments_Menu")); + Console.WriteLine(Utils.GetString("Get_Incident_Comment_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Incident_Relation_Menu")); + Console.WriteLine(Utils.GetString("Create_Relation_Menu")); + Console.WriteLine(Utils.GetString("Delete_Relation_Menu")); + Console.WriteLine(Utils.GetString("Get_Relations_Menu")); + Console.WriteLine(Utils.GetString("Get_Relation_Menu")); + Console.WriteLine(Utils.GetString("Get_Entities_By_Type_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Saved_Searches_Menu")); + Console.WriteLine(Utils.GetString("Create_Saved_Search_Menu")); + Console.WriteLine(Utils.GetString("Delete_Saved_Search_Menu")); + Console.WriteLine(Utils.GetString("Get_Saved_Search_Menu")); + Console.WriteLine(Utils.GetString("Get_Saved_Searches_Menu")); + Console.WriteLine(Utils.GetString("Update_Saved_Search_Menu")); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Exit_Text")); + } + + + public void PrintCLIMenu() + { + Console.WriteLine(Utils.GetString("Actions_Menu")); + Console.WriteLine(Utils.GetString("Create_Action_Menu") + cmdArgs[0].Item1); + Console.WriteLine(Utils.GetString("Delete_Action_Menu") + cmdArgs[1].Item1); + Console.WriteLine(Utils.GetString("Get_Action_By_Id_Menu") + cmdArgs[2].Item1); + Console.WriteLine(Utils.GetString("Get_Actions_Menu") + cmdArgs[3].Item1); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Alert_Rule_Template_Menu")); + Console.WriteLine(Utils.GetString("Get_Rule_Template_By_Id_Menu") + cmdArgs[4].Item1); + Console.WriteLine(Utils.GetString("Get_Rule_Templates_Menu") + cmdArgs[5].Item1); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Alert_Rules_Menu")); + Console.WriteLine(Utils.GetString("Create_Fusion_Rule_Menu") + cmdArgs[6].Item1); + Console.WriteLine(Utils.GetString("Create_Incident_Rule_Menu") + cmdArgs[7].Item1); + Console.WriteLine(Utils.GetString("Create_Scheduled_Rule_Menu") + cmdArgs[8].Item1); + Console.WriteLine(Utils.GetString("Delete_Rule_Menu") + cmdArgs[9].Item1); + Console.WriteLine(Utils.GetString("Get_Rules_Menu") + cmdArgs[10].Item1); + Console.WriteLine(Utils.GetString("Get_Fusion_Rule_Menu") + cmdArgs[11].Item1); + Console.WriteLine(Utils.GetString("Get_Incident_Rule_Menu") + cmdArgs[12].Item1); + Console.WriteLine(Utils.GetString("Get_Scheduled_Rule_Menu") + cmdArgs[13].Item1); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Bookmarks_Menu")); + Console.WriteLine(Utils.GetString("Create_Bookmark_Menu") + cmdArgs[14].Item1); + Console.WriteLine(Utils.GetString("Delete_Bookmark_Menu") + cmdArgs[15].Item1); + Console.WriteLine(Utils.GetString("Get_Bookmark_By_Id_Menu") + cmdArgs[16].Item1); + Console.WriteLine(Utils.GetString("Get_Bookmarks_Menu") + cmdArgs[17].Item1); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("DataConnectors_Menu")); + Console.WriteLine(Utils.GetString("Get_DataConnectors_Menu") + cmdArgs[18].Item1); + Console.WriteLine(Utils.GetString("Delete_DataConnector_Menu") + cmdArgs[19].Item1); + Console.WriteLine(Utils.GetString("Create_DataConnector_Menu") + cmdArgs[20].Item1); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Incident_Menu")); + Console.WriteLine(Utils.GetString("Create_Incident_Menu") + cmdArgs[21].Item1); + Console.WriteLine(Utils.GetString("Delete_Incident_Menu") + cmdArgs[22].Item1); + Console.WriteLine(Utils.GetString("Get_Incident_By_Id_Menu") + cmdArgs[23].Item1); + Console.WriteLine(Utils.GetString("Get_Incidents_Menu") + cmdArgs[24].Item1); + Console.WriteLine(Utils.GetString("Update_Incident_Menu") + cmdArgs[25].Item1); + Console.WriteLine(Utils.GetString("Batch_Update_Incidents_Menu") + cmdArgs[26].Item1); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Incident_Comments_Menu")); + Console.WriteLine(Utils.GetString("Create_Incident_Comment_Menu") + cmdArgs[27].Item1); + Console.WriteLine(Utils.GetString("Get_Incident_Comments_Menu") + cmdArgs[28].Item1); + Console.WriteLine(Utils.GetString("Get_Incident_Comment_Menu") + cmdArgs[29].Item1); + Console.WriteLine(); + + Console.WriteLine(Utils.GetString("Incident_Relation_Menu")); + Console.WriteLine(Utils.GetString("Create_Relation_Menu") + cmdArgs[30].Item1); + Console.WriteLine(Utils.GetString("Delete_Relation_Menu") + cmdArgs[31].Item1); + Console.WriteLine(Utils.GetString("Get_Relations_Menu") + cmdArgs[32].Item1); + Console.WriteLine(Utils.GetString("Get_Relation_Menu") + cmdArgs[33].Item1); + Console.WriteLine(Utils.GetString("Get_Entities_By_Type_Menu") + cmdArgs[34].Item1); + Console.WriteLine(); + } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AzureSentinel_ManagementAPI.csproj b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AzureSentinel_ManagementAPI.csproj new file mode 100644 index 0000000000..a7fff16b49 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/AzureSentinel_ManagementAPI.csproj @@ -0,0 +1,45 @@ + + + + Exe + netcoreapp3.1 + + + + + + + + + + + + + + Always + + + + + + + + + + + True + True + Resource1.resx + + + + + + ResXFileCodeGenerator + Resource1.Designer.cs + + + + + + diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/BookmarksController.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/BookmarksController.cs new file mode 100644 index 0000000000..d89533821c --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/BookmarksController.cs @@ -0,0 +1,274 @@ +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Bookmarks.Models; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.Extensions.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Newtonsoft.Json.Serialization; + +namespace AzureSentinel_ManagementAPI.Bookmarks +{ + public class BookmarksController + { + private readonly AzureSentinelApiConfiguration[] azureConfigs; + private readonly AuthenticationService authenticationService; + private bool cliMode; + + public BookmarksController( + AzureSentinelApiConfiguration[] azureConfig, + IConfigurationRoot rawConfig, + AuthenticationService authenticationService) + { + azureConfigs = azureConfig; + this.authenticationService = authenticationService; + cliMode = rawConfig.GetValue("Climode"); + } + + /// + /// Create a bookmark for all instances or for a single instance + /// + /// + public async Task CreateBookmark(int insId = -1) + { + if (insId != -1) + { + await CreateBookmarkByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await CreateBookmarkByInstance(i); + } + } + } + + /// + /// Create a bookmark for a single instance + /// + /// + /// + private async Task CreateBookmarkByInstance(int i) + { + var bookmarks = Utils.LoadPayload("BookmarkPayload.json", cliMode); + + foreach (var payload in bookmarks) + { + try + { + var bookmarkId = Guid.NewGuid().ToString(); + + var url = $"{azureConfigs[i].BaseUrl}/bookmarks/{bookmarkId}?api-version={azureConfigs[i].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, i); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } + + /// + /// Delete a bookmark by id + /// + /// + /// + public async Task DeleteBookmark(string bookmarkId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/bookmarks/{bookmarkId}?api-version={azureConfigs[insId].ApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Delete, url); + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + if (response.StatusCode == HttpStatusCode.NotFound) + throw new Exception("Not found, please create a new Bookmark first..."); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get a bookmark by id + /// + /// + /// + public async Task GetBookmarkById(string bookmarkId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/bookmarks/{bookmarkId}?api-version={azureConfigs[insId].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get all bookmarks for all instances or for a single instance + /// + /// + /// + public async Task GetBookmarks(int insId = -1) + { + if (insId != -1) + { + await GetBookmarksByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await GetBookmarksByInstance(i); + } + } + } + + /// + /// Get bookmarks for a single instance + /// + /// + /// + private async Task GetBookmarksByInstance(int i) + { + try + { + var url = $"{azureConfigs[i].BaseUrl}/bookmarks?api-version={azureConfigs[i].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, i); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject result = JsonConvert.DeserializeObject(res); + var values = result["value"] as JArray; + + if (values == null) + { + values = new JArray(); + } + + int callTimes = 1; + + while (result.ContainsKey("nextLink") && callTimes < 100) + { + try + { + var nextLink = result["nextLink"].ToString(); + request = new HttpRequestMessage(HttpMethod.Get, nextLink); + await authenticationService.AuthenticateRequest(request, i); + var nextResponse = await http.SendAsync(request); + + if (nextResponse.IsSuccessStatusCode) + { + var newRes = await nextResponse.Content.ReadAsStringAsync(); + JObject newResult = JsonConvert.DeserializeObject(newRes); + result = newResult; + var newValues = result["value"] as JArray; + + if (newValues == null) + { + newValues = new JArray(); + } + + foreach (var v in newValues) + { + values.Add(v); + } + callTimes++; + } + else + { + var err = await response.Content.ReadAsStringAsync(); + Console.WriteLine("Error calling the nextLink: \n" + err); + break; + } + } + catch (Exception ex) + { + Console.WriteLine("Error in parsing nextLink: \n" + ex.Message); + break; + } + } + + var formattedRes = JsonConvert.SerializeObject(values, Formatting.Indented); + Utils.WriteJsonStringToFile($"GetBookmarks_{azureConfigs[i].InstanceName}.json", cliMode, formattedRes, false); + Console.WriteLine(formattedRes); + return; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/BookmarkPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/BookmarkPayload.cs new file mode 100644 index 0000000000..1aaa94a6d0 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/BookmarkPayload.cs @@ -0,0 +1,13 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.Bookmarks.Models +{ + public class BookmarkPayload + { + [JsonProperty("etag")] + public string ETag { get; set; } + + [JsonProperty("properties")] + public BookmarkPropertiesPayload PropertiesPayload { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/BookmarkPropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/BookmarkPropertiesPayload.cs new file mode 100644 index 0000000000..c0952c39d6 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/BookmarkPropertiesPayload.cs @@ -0,0 +1,15 @@ +using System.Collections.Generic; + +namespace AzureSentinel_ManagementAPI.Bookmarks.Models +{ + public class BookmarkPropertiesPayload + { + public string DisplayName { get; set; } + public string Query { get; set; } + public string Notes { get; set; } + public List Labels { get; set; } + public string QueryResult { get; set; } + + public IncidentInfo IncidentInfo { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/IncidentInfo.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/IncidentInfo.cs new file mode 100644 index 0000000000..51663a0281 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Bookmarks/Models/IncidentInfo.cs @@ -0,0 +1,16 @@ +using AzureSentinel_ManagementAPI.Infrastructure.SharedModels.Enums; +using Newtonsoft.Json; +using Newtonsoft.Json.Converters; + +namespace AzureSentinel_ManagementAPI.Bookmarks.Models +{ + public class IncidentInfo + { + public string IncidentId { get; set; } + + [JsonConverter(typeof(StringEnumConverter))] + public Severity Severity { get; set; } + public string Title { get; set; } + public string RelationName { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/DataConnectorsController.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/DataConnectorsController.cs new file mode 100644 index 0000000000..780110d9eb --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/DataConnectorsController.cs @@ -0,0 +1,245 @@ +using System; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.DataConnectors.Models; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.Extensions.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Newtonsoft.Json.Serialization; + +namespace AzureSentinel_ManagementAPI.DataConnectors +{ + public class DataConnectorsController + { + private readonly AzureSentinelApiConfiguration[] azureConfigs; + private readonly AuthenticationService authenticationService; + private bool cliMode; + + public DataConnectorsController( + AzureSentinelApiConfiguration[] azureConfig, + IConfigurationRoot rawConfig, + AuthenticationService authenticationService + ) + { + azureConfigs = azureConfig; + this.authenticationService = authenticationService; + cliMode = rawConfig.GetValue("Climode"); + } + + /// + /// Get all data connectors for all instances or for a single instance + /// + /// + public async Task GetDataConnectors(int insId) + { + if (insId != -1) + { + await GetDataConnectorsByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await GetDataConnectorsByInstance(i); + } + } + } + + /// + /// Get all data connectors for a single instance + /// + /// + /// + private async Task GetDataConnectorsByInstance(int i) + { + try + { + var url = $"{azureConfigs[i].BaseUrl}/dataConnectors?api-version={azureConfigs[i].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, i); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject result = JsonConvert.DeserializeObject(res); + var values = result["value"] as JArray; + if (values == null) + { + values = new JArray(); + } + int callTimes = 1; + + while (result.ContainsKey("nextLink") && callTimes < 100) + { + try + { + var nextLink = result["nextLink"].ToString(); + request = new HttpRequestMessage(HttpMethod.Get, nextLink); + await authenticationService.AuthenticateRequest(request, i); + var nextResponse = await http.SendAsync(request); + + if (nextResponse.IsSuccessStatusCode) + { + var newRes = await nextResponse.Content.ReadAsStringAsync(); + JObject newResult = JsonConvert.DeserializeObject(newRes); + result = newResult; + var newValues = result["value"] as JArray; + + if (newValues == null) + { + newValues = new JArray(); + } + + foreach (var v in newValues) + { + values.Add(v); + } + callTimes++; + } + else + { + var err = await response.Content.ReadAsStringAsync(); + Console.WriteLine("Error calling the nextLink: \n" + err); + break; + } + } + catch (Exception ex) + { + Console.WriteLine("Error in parsing nextLink: \n" + ex.Message); + break; + } + } + + var formattedRes = JsonConvert.SerializeObject(values, Formatting.Indented); + Utils.WriteJsonStringToFile($"GetDataConnectors_{azureConfigs[i].InstanceName}.json", cliMode, formattedRes, false); + Console.WriteLine(formattedRes); + return; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + + /// + /// Create a data connector for all instances or for a single instance + /// + /// + public async Task CreateDataConnector(int insId) + { + if (insId != -1) + { + await CreateDataConnectorByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await CreateDataConnectorByInstance(i); + } + } + } + + /// + /// Create a data connector for a single instance + /// + /// + /// + private async Task CreateDataConnectorByInstance(int i) + { + var dataConnectors = Utils.LoadPayload("DataConnectorPayload.json", cliMode); + + foreach (var payload in dataConnectors) + { + try + { + var dataConnectorId = Guid.NewGuid().ToString(); + + var url = + $"{azureConfigs[i].BaseUrl}/dataConnectors/{dataConnectorId}?api-version={azureConfigs[i].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + NullValueHandling = NullValueHandling.Ignore, + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, i); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } + + /// + /// Delete a data connector by id + /// + /// + /// + public async Task DeleteDataConnector(string dataConnectorId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/dataConnectors/{dataConnectorId}?api-version={azureConfigs[insId].ApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Delete, url); + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + if (response.StatusCode == HttpStatusCode.NotFound) + throw new Exception("Not found, please create a new DataConnector first..."); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorDataTypesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorDataTypesPayload.cs new file mode 100644 index 0000000000..a31c85b921 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorDataTypesPayload.cs @@ -0,0 +1,7 @@ +namespace AzureSentinel_ManagementAPI.DataConnectors.Models +{ + public class ASCDataConnectorDataTypesPayload + { + public DataTypeConnectionStatePayload Alerts { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorPayload.cs new file mode 100644 index 0000000000..3da73eb485 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorPayload.cs @@ -0,0 +1,9 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.DataConnectors.Models +{ + public class ASCDataConnectorPayload : DataConnectorPayload + { + [JsonProperty("properties")] public ASCDataConnectorPropertiesPayload PropertiesPayload { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorPropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorPropertiesPayload.cs new file mode 100644 index 0000000000..8a26531259 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/ASCDataConnectorPropertiesPayload.cs @@ -0,0 +1,14 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.DataConnectors.Models +{ + public class ASCDataConnectorPropertiesPayload + { + public string SubscriptionId { get; set; } + + public string TenantId { get; set; } + + [JsonProperty("dataTypes")] + public ASCDataConnectorDataTypesPayload DataTypesPayload { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectionState.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectionState.cs new file mode 100644 index 0000000000..80b70226d6 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectionState.cs @@ -0,0 +1,8 @@ +namespace AzureSentinel_ManagementAPI.DataConnectors.Models +{ + public enum DataConnectionState + { + Enabled, + Disabled + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectorKind.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectorKind.cs new file mode 100644 index 0000000000..d26dbb8b78 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectorKind.cs @@ -0,0 +1,14 @@ +namespace AzureSentinel_ManagementAPI.DataConnectors.Models +{ + public enum DataConnectorKind + { + AzureActiveDirectory, + AzureSecurityCenter, + MicrosoftCloudAppSecurity, + ThreatIntelligence, + Office365, + AmazonWebServicesCloudTrail, + AzureAdvancedThreatProtection, + MicrosoftDefenderAdvancedThreatProtection + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectorPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectorPayload.cs new file mode 100644 index 0000000000..07467a0e74 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataConnectorPayload.cs @@ -0,0 +1,14 @@ +using Newtonsoft.Json; +using Newtonsoft.Json.Converters; + +namespace AzureSentinel_ManagementAPI.DataConnectors.Models +{ + public abstract class DataConnectorPayload + { + [JsonProperty("etag")] + public string ETag { get; set; } + + [JsonConverter(typeof(StringEnumConverter))] + public DataConnectorKind Kind { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataTypeConnectionStatePayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataTypeConnectionStatePayload.cs new file mode 100644 index 0000000000..5d205ed8e1 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/DataConnectors/Models/DataTypeConnectionStatePayload.cs @@ -0,0 +1,11 @@ +using Newtonsoft.Json; +using Newtonsoft.Json.Converters; + +namespace AzureSentinel_ManagementAPI.DataConnectors.Models +{ + public class DataTypeConnectionStatePayload + { + [JsonConverter(typeof(StringEnumConverter))] + public DataConnectionState State { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchPayload.cs new file mode 100644 index 0000000000..dfe27b93ec --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchPayload.cs @@ -0,0 +1,16 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Text; + +namespace AzureSentinel_ManagementAPI.Hunting.Models +{ + public class SavedSearchPayload + { + [JsonProperty("etag")] + public string Etag { get; set; } + + [JsonProperty("properties")] + public SavedSearchPropertiesPayload PropertiesPayload { get; set; } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchPropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchPropertiesPayload.cs new file mode 100644 index 0000000000..ff54a20435 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchPropertiesPayload.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AzureSentinel_ManagementAPI.Hunting.Models +{ + public class SavedSearchPropertiesPayload + { + public string Category { get; set; } + public string DisplayName { get; set; } + public int Version { get; set; } + public string FunctionAlias { get; set; } + public string FunctionParameters { get; set; } + public List Tags { get; set; } + public string Query { get; set; } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchTag.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchTag.cs new file mode 100644 index 0000000000..344a6757e8 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/Models/SavedSearchTag.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AzureSentinel_ManagementAPI.Hunting.Models +{ + public class SavedSearchTag + { + public string Name { get; set; } + public string Value { get; set; } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/SavedSearchController.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/SavedSearchController.cs new file mode 100644 index 0000000000..bf1547f3be --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Hunting/SavedSearchController.cs @@ -0,0 +1,326 @@ +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Hunting.Models; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.Extensions.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Newtonsoft.Json.Serialization; + +namespace AzureSentinel_ManagementAPI.Hunting +{ + public class SavedSearchController + { + private readonly AzureSentinelApiConfiguration[] azureConfigs; + private readonly AuthenticationService authenticationService; + private bool cliMode; + private const string savedSearchApiVersion = "2020-08-01"; + + public SavedSearchController( + AzureSentinelApiConfiguration[] azureConfig, + IConfigurationRoot rawConfig, + AuthenticationService authenticationService + ) + { + azureConfigs = azureConfig; + this.authenticationService = authenticationService; + cliMode = rawConfig.GetValue("Climode"); + } + + /// + /// Create saved search + /// + /// + /// + public async Task CreateSavedSearch(int insId) + { + if (insId != -1) + { + await CreateSavedSearchByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await CreateSavedSearchByInstance(i); + } + } + } + + /// + /// Create saved search by instance + /// + /// + /// + public async Task CreateSavedSearchByInstance(int i) + { + var savedSearches = Utils.LoadPayload("SavedSearchPayload.json", cliMode); + + foreach (var payload in savedSearches) + { + try + { + var savedSearchId = Guid.NewGuid().ToString(); + + var url = + $"{azureConfigs[i].OperationInsightBaseUrl}/savedSearches/{savedSearchId}?api-version={savedSearchApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + NullValueHandling = NullValueHandling.Ignore, + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, i); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } + + /// + /// Update saved search data by instance + /// + /// + /// + /// + public async Task UpdateSavedSearch(string savedSearchId, int insId) + { + var savedSearch = await GetSavedSearchById(savedSearchId, insId); + + try + { + JObject jobject = JObject.Parse(savedSearch); + var savedSearchObj = JsonConvert.DeserializeObject(jobject.ToString()); + + var savedSearchs = Utils.LoadPayload("SavedSearchPayload.json", cliMode); + // Get the first one to update + var payload = savedSearchs[0]; + payload.Etag = savedSearchObj.Etag; + + var url = $"{azureConfigs[insId].OperationInsightBaseUrl}/savedSearches/{savedSearchId}?api-version={savedSearchApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Delete saved search by id and instance + /// + /// + /// + /// + public async Task DeleteSavedSearch(string savedSearchId, int insId) + { + try + { + var url = $"{azureConfigs[insId].OperationInsightBaseUrl}/savedSearches/{savedSearchId}?api-version={savedSearchApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Delete, url); + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + if (response.StatusCode == HttpStatusCode.NotFound) + throw new Exception("Not found, please create a new SavedSearch first..."); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get a specific saved search by id and instance + /// + /// + /// + /// + public async Task GetSavedSearchById(string savedSearchId, int i) + { + try + { + var url = $"{azureConfigs[i].OperationInsightBaseUrl}/savedSearches/{savedSearchId}?api-version={savedSearchApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, i); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + public async Task GetSavedSearches(int insId) + { + if (insId != -1) + { + await GetSavedSearchesByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await GetSavedSearchesByInstance(i); + } + } + } + + /// + /// Get all saved searches by instance + /// + /// + /// + private async Task GetSavedSearchesByInstance(int i) + { + try + { + var url = $"{azureConfigs[i].OperationInsightBaseUrl}/savedSearches?api-version={savedSearchApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, i); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject result = JsonConvert.DeserializeObject(res); + var values = result["value"] as JArray; + if (values == null) + { + values = new JArray(); + } + int callTimes = 1; + + while (result.ContainsKey("nextLink") && callTimes < 100) + { + try + { + var nextLink = result["nextLink"].ToString(); + request = new HttpRequestMessage(HttpMethod.Get, nextLink); + await authenticationService.AuthenticateRequest(request, i); + var nextResponse = await http.SendAsync(request); + + if (nextResponse.IsSuccessStatusCode) + { + var newRes = await nextResponse.Content.ReadAsStringAsync(); + JObject newResult = JsonConvert.DeserializeObject(newRes); + result = newResult; + var newValues = result["value"] as JArray; + + if (newValues == null) + { + newValues = new JArray(); + } + + foreach (var v in newValues) + { + values.Add(v); + } + callTimes++; + } + else + { + var err = await response.Content.ReadAsStringAsync(); + Console.WriteLine("Error calling the nextLink: \n" + err); + break; + } + } + catch (Exception ex) + { + Console.WriteLine("Error in parsing nextLink: \n" + ex.Message); + break; + } + } + + var formattedRes = JsonConvert.SerializeObject(values, Formatting.Indented); + Utils.WriteJsonStringToFile($"GetSavedSearches_{azureConfigs[i].InstanceName}.json", cliMode, formattedRes, false); + Console.WriteLine(formattedRes); + return; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/IncidentRelationController.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/IncidentRelationController.cs new file mode 100644 index 0000000000..30602a172a --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/IncidentRelationController.cs @@ -0,0 +1,480 @@ +using System; +using System.Reflection; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.IncidentRelation.Models; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Serialization; +using Newtonsoft.Json.Linq; +using System.Collections.Generic; +using Microsoft.Extensions.Configuration; + +namespace AzureSentinel_ManagementAPI.IncidentRelation +{ + class IncidentRelationController + { + private readonly AzureSentinelApiConfiguration[] azureConfigs; + private readonly AuthenticationService authenticationService; + private const string Domain = "https://management.azure.com"; + private bool cliMode; + + public IncidentRelationController( + AzureSentinelApiConfiguration[] azureConfig, + IConfigurationRoot rawConfig, + AuthenticationService authenticationService + ) + { + azureConfigs = azureConfig; + this.authenticationService = authenticationService; + cliMode = rawConfig.GetValue("Climode"); + } + + /// + /// Create an incident relation for a single instance, connecting incident and bookmark + /// + /// + /// + /// + public async Task CreateIncidentRelation(string incidentId, string bookmarkId, int insId) + { + try + { + var payload = new RelationPayload + { + PropertiesPayload = new RelationPropertiesPayload + { + RelatedResourceId = $"{azureConfigs[insId].BaseUrl}/bookmarks/{bookmarkId}" + } + }; + + var relationId = Guid.NewGuid().ToString(); + var url = + $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}/relations/{relationId}?api-version={azureConfigs[insId].PreviewApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + NullValueHandling = NullValueHandling.Ignore, + ContractResolver = new DefaultContractResolver + { + + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Delete an incident relation by id + /// + /// + /// + /// + public async Task DeleteIncidentRelation(string incidentId, string relationId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}/relations/{relationId}?api-version={azureConfigs[insId].PreviewApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Delete, url); + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + if (response.StatusCode == HttpStatusCode.NotFound) + throw new Exception("Not found, please create a new incident relation first..."); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get an incident relation by id + /// + /// + /// + /// + public async Task GetIncidentRelationByName(string incidentId, string relationId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}/relations/{relationId}?api-version={azureConfigs[insId].PreviewApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject value = JsonConvert.DeserializeObject(res); + + Console.WriteLine(JsonConvert.SerializeObject(value, Formatting.Indented)); + + var resources = new JObject(); + resources.Add("incidentRelationId", relationId); + + var properties = value["properties"]; + var relatedResourceId = properties != null ? properties["relatedResourceId"] : null; + var resourceDataStr = string.Empty; + + if (relatedResourceId != null) + { + var resourceType = properties["relatedResourceType"].ToString(); + + if (resourceType == "Microsoft.SecurityInsights/bookmarks") + { + var resourceUrl = $"{Domain}{relatedResourceId}?api-version={azureConfigs[insId].ApiVersion}"; + var resourcerequest = new HttpRequestMessage(HttpMethod.Get, resourceUrl); + await authenticationService.AuthenticateRequest(resourcerequest, insId); + var resourceHttp = new HttpClient(); + var resourceRes = await resourceHttp.SendAsync(resourcerequest); + + if (resourceRes.IsSuccessStatusCode) + { + resourceDataStr = await resourceRes.Content.ReadAsStringAsync(); + } + } + else if (resourceType == "Microsoft.SecurityInsights/entities") + { + var resourceUrl = $"{Domain}{relatedResourceId}/expand?api-version={azureConfigs[insId].PreviewApiVersion}"; + var resourceKind = properties["relatedResourceKind"].ToString(); + var expansionId = GetExpansionId(resourceKind); + var payload = new RelationEntityPayload + { + ExpansionId = expansionId + }; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + NullValueHandling = NullValueHandling.Ignore, + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var resourcerequest = new HttpRequestMessage(HttpMethod.Post, resourceUrl) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(resourcerequest, insId); + var resourceHttp = new HttpClient(); + var resourceRes = await resourceHttp.SendAsync(resourcerequest); + + if (resourceRes.IsSuccessStatusCode) + { + resourceDataStr = await resourceRes.Content.ReadAsStringAsync(); + } + } + + if (resourceDataStr != string.Empty) + { + JObject resourceData = JsonConvert.DeserializeObject(resourceDataStr); + resources.Merge(resourceData); + } + } + + Console.WriteLine("related resources:"); + var serializedResources = JsonConvert.SerializeObject(resources, Formatting.Indented); + Console.WriteLine(serializedResources); + Utils.WriteJsonStringToFile($"GetIncidentRelationByNameResources_{azureConfigs[insId].InstanceName}.json", + cliMode, serializedResources, false); + + return; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get all incident relations under an incident, and get all entities under the incident + /// + /// + /// + public async Task GetEntitiesforIncident(string incidentId, int insId) + { + await GetIncidentRelationsAndEntities(incidentId, EntityKind.SecurityAlert, true, insId); + } + + /// + /// Get all incident relations under an incident, and get all entities under the incident + /// + /// + /// + public async Task GetIncidentEntitiesbyEntityType(string incidentId, int insId) + { + // Console.WriteLine(Utils.GetString("Select_Entity_Kind")); + var entityKind = Utils.SelectKind(); + await GetIncidentRelationsAndEntities(incidentId, entityKind, false, insId); + } + + /// + /// Get all incident relations and entities under an incident + /// + /// + /// + /// + /// + public async Task GetIncidentRelationsAndEntities(string incidentId, EntityKind entityKind, bool allKind, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}/relations?api-version={azureConfigs[insId].PreviewApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject result = JsonConvert.DeserializeObject(res); + var values = result["value"] as JArray; + + if (values == null) + { + values = new JArray(); + } + + int callTimes = 1; + + while (result.ContainsKey("nextLink") && callTimes < 100) + { + try + { + var nextLink = result["nextLink"].ToString(); + request = new HttpRequestMessage(HttpMethod.Get, nextLink); + await authenticationService.AuthenticateRequest(request, insId); + var nextResponse = await http.SendAsync(request); + + if (nextResponse.IsSuccessStatusCode) + { + var newRes = await nextResponse.Content.ReadAsStringAsync(); + JObject newResult = JsonConvert.DeserializeObject(newRes); + result = newResult; + var newValues = result["value"] as JArray; + + if (newValues == null) + { + newValues = new JArray(); + } + + foreach (var v in newValues) + { + values.Add(v); + } + + callTimes++; + } + else + { + var err = await response.Content.ReadAsStringAsync(); + Console.WriteLine("Error calling the nextLink: \n" + err); + break; + } + } + catch (Exception ex) + { + Console.WriteLine("Error in parsing nextLink: \n" + ex.Message); + break; + } + } + + var resources = new JArray(); + foreach (JToken value in values) + { + var properties = value["properties"]; + var relatedResourceId = properties != null ? properties["relatedResourceId"] : null; + var resourceDataStr = string.Empty; + + if (relatedResourceId != null) + { + var resourceType = properties["relatedResourceType"].ToString(); + + if (resourceType == "Microsoft.SecurityInsights/bookmarks" && (allKind || entityKind == EntityKind.Bookmark)) + { + var resourceUrl = $"{Domain}{relatedResourceId}?api-version={azureConfigs[insId].ApiVersion}"; + var resourcerequest = new HttpRequestMessage(HttpMethod.Get, resourceUrl); + await authenticationService.AuthenticateRequest(resourcerequest, insId); + var resourceHttp = new HttpClient(); + var resourceRes = await resourceHttp.SendAsync(resourcerequest); + + if (resourceRes.IsSuccessStatusCode) + { + resourceDataStr = await resourceRes.Content.ReadAsStringAsync(); + } + } + else if (resourceType == "Microsoft.SecurityInsights/entities") + { + var resourceUrl = $"{Domain}{relatedResourceId}/expand?api-version={azureConfigs[insId].PreviewApiVersion}"; + var resourceKind = properties["relatedResourceKind"].ToString(); + + var expansionId = GetExpansionId(resourceKind); + var payload = new RelationEntityPayload + { + ExpansionId = expansionId + }; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + NullValueHandling = NullValueHandling.Ignore, + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var resourcerequest = new HttpRequestMessage(HttpMethod.Post, resourceUrl) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(resourcerequest, insId); + var resourceHttp = new HttpClient(); + var resourceRes = await resourceHttp.SendAsync(resourcerequest); + + if (resourceRes.IsSuccessStatusCode) + { + resourceDataStr = await resourceRes.Content.ReadAsStringAsync(); + } + } + + if (resourceDataStr != string.Empty) + { + JObject resourceData = JsonConvert.DeserializeObject(resourceDataStr); + if (resourceType == "Microsoft.SecurityInsights/bookmarks" && allKind) + { + resources.Add(resourceData); + } + else + { + var resourceValue = resourceData["value"]; + var entities = resourceValue != null ? resourceValue["entities"] : null; + if (entities != null) + { + foreach (var entity in entities) + { + if (allKind || entity["kind"].ToString() == entityKind.ToString()) + { + resources.Add(entity); + } + } + } + } + + } + } + } + + Utils.WriteJsonStringToFile($"GetIncidentRelations_{azureConfigs[insId].InstanceName}.json", + cliMode, JsonConvert.SerializeObject(values, Formatting.Indented), false); + + Console.WriteLine(JsonConvert.SerializeObject(values, Formatting.Indented)); + Console.WriteLine(Utils.GetString("Related_Entities")); + var serializedResources = JsonConvert.SerializeObject(resources, Formatting.Indented); + Console.WriteLine(serializedResources); + var fileNamePrefix = allKind ? "GetEntitiesforIncident" : $"GetIncidentEntitiesbyEntityType_{entityKind.ToString()}"; + Utils.WriteJsonStringToFile($"{fileNamePrefix}_{azureConfigs[insId].InstanceName}.json", cliMode, + serializedResources, false); + return; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get entities expansion id by kind + /// + /// + /// + private string GetExpansionId(string kind) + { + switch (kind) + { + case "SecurityAlert": + return "98b974fd-cc64-48b8-9bd0-3a209f5b944b"; + case "Bookmark": + return "27f76e63-c41b-480f-bb18-12ad2e011d49"; + case "Account": + return "a77992f3-25e9-4d01-99a4-5ff606cc410a"; + case "AzureResource": + return "4a014a1b-c5a1-499f-9f54-3f7b99b0a675"; + case "CloudApplication": + return "f74ad13a-ae93-47b9-8782-b1142b95d046"; + case "DnsResolution": + return "80218599-45b4-4402-95cc-86f9929dd43d"; + case "File": + return "0f0bccef-4512-4530-a866-27056a39dcd6"; + case "FileHash": + return "b6eaa3ad-e69b-437e-9c13-bb5273dd34ab"; + case "Host": + return "055a5692-555f-42bd-ac17-923a5a9994ed"; + case "Ip": + return "58c1516f-b78a-4d78-9e71-77c40849c27b"; + case "Malware": + return "b8407195-b9a3-4565-bf08-7b23e5c57e3a"; + case "Process": + return "63a4fa2f-f89d-4cf5-96a2-cb2479e49731"; + case "RegistryKey": + return "d788cd65-a7ef-448e-aa34-81185ac0e611"; + case "RegistryValue": + return "3a45a7e3-80e0-4e05-84db-b97bd1ae452b"; + case "Url": + return "7b61d5e2-4b66-40a7-bb0f-9145b445104e"; + case "IoTDevice": + return "4daeed0e-0e74-4f2d-990c-a958210e9dd7"; + default: + return string.Empty; + } + } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/EntityKind.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/EntityKind.cs new file mode 100644 index 0000000000..2c9a27192b --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/EntityKind.cs @@ -0,0 +1,22 @@ +namespace AzureSentinel_ManagementAPI.IncidentRelation.Models +{ + public enum EntityKind + { + SecurityAlert, + Bookmark, + Account, + AzureResource, + CloudApplication, + DnsResolution, + File, + FileHash, + Host, + Ip, + Malware, + Process, + RegistryKey, + RegistryValue, + Url, + IoTDevice + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationEntityPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationEntityPayload.cs new file mode 100644 index 0000000000..e602dc77d0 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationEntityPayload.cs @@ -0,0 +1,13 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Text; + +namespace AzureSentinel_ManagementAPI.IncidentRelation.Models +{ + public class RelationEntityPayload + { + [JsonProperty("expansionId")] + public string ExpansionId { get; set; } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationPayload.cs new file mode 100644 index 0000000000..122542ad39 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationPayload.cs @@ -0,0 +1,12 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.IncidentRelation.Models +{ + public class RelationPayload + { + public RelationPayload() + { + } + [JsonProperty("properties")] public RelationPropertiesPayload PropertiesPayload { get; set; } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationPropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationPropertiesPayload.cs new file mode 100644 index 0000000000..f6c5f2d009 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/IncidentRelation/Models/RelationPropertiesPayload.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AzureSentinel_ManagementAPI.IncidentRelation.Models +{ + public class RelationPropertiesPayload + { + public string RelatedResourceId { get; set; } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/IncidentsController.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/IncidentsController.cs new file mode 100644 index 0000000000..5cdcb45654 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/IncidentsController.cs @@ -0,0 +1,648 @@ +using System; +using System.Diagnostics; +using System.Linq; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Incidents.Models; +using AzureSentinel_ManagementAPI.Incidents.Models.Comments; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.Extensions.Configuration; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using Newtonsoft.Json.Serialization; + +namespace AzureSentinel_ManagementAPI.Incidents +{ + public class IncidentsController + { + public const string INCIDENT_NAME = "incident-1"; + private const string INCIDENT_COMMENT_NAME = "incident-comment-1"; + private string incidentId = Guid.NewGuid().ToString(); + private string commentId = Guid.NewGuid().ToString(); + + private readonly AzureSentinelApiConfiguration[] azureConfigs; + private readonly AuthenticationService authenticationService; + private bool cliMode; + + public IncidentsController( + AzureSentinelApiConfiguration[] azureConfig, + IConfigurationRoot rawConfig, + AuthenticationService authenticationService) + { + azureConfigs = azureConfig; + this.authenticationService = authenticationService; + cliMode = rawConfig.GetValue("Climode"); + } + + /// + /// Create an incident for all instances or for a single instance + /// + /// + public async Task CreateIncident(int insId = -1) + { + if (insId != -1) + { + await CreateIncidentByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await CreateIncidentByInstance(i); + } + } + } + + /// + /// Create an incident for a single instance + /// + /// + /// + private async Task CreateIncidentByInstance(int i) + { + var incidents = Utils.LoadPayload("IncidentPayload.json", cliMode); + + foreach (var payload in incidents) + { + try + { + incidentId = Guid.NewGuid().ToString(); + var url = $"{azureConfigs[i].BaseUrl}/incidents/{incidentId}?api-version={azureConfigs[i].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, i); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + } + + /// + /// Update an incident by id + /// + /// + /// + public async Task UpdateIncident(string incidentId, int insId) + { + var incident = await GetIncidentById(incidentId, insId); + + try + { + JObject jobject = JObject.Parse(incident); + var incidentObj = JsonConvert.DeserializeObject(jobject.ToString()); + + var incidents = Utils.LoadPayload("IncidentPayload.json", cliMode); + // Get the first one to update + var payload = incidents[0]; + payload.Etag = incidentObj.Etag; + + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}?api-version={azureConfigs[insId].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Batch update incidents for all instances or for a single instance + /// + /// + public async Task BatchUpdateIncidents(int insId) + { + if (insId != -1) + { + await BatchUpdateIncidentsByInstance(insId); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + await BatchUpdateIncidentsByInstance(i); + } + } + } + + /// + /// Batch update incidents for a single instance + /// + /// + /// + private async Task BatchUpdateIncidentsByInstance(int i) + { + var incidentUpdates = Utils.LoadPayload("IncidentPayload.json", cliMode); + var insName = azureConfigs[i].InstanceName; + try + { + var incidents = await GetIncidentsByInstance(i, azureConfigs[i].FilterQuery); + + foreach (var incidentObj in incidents) + { + // Get the first one to update + var payload = incidentUpdates[0]; + var etag = (string)incidentObj["etag"]; + payload.Etag = etag; + var incidentId = (string)incidentObj["name"]; + + var url = $"{azureConfigs[i].BaseUrl}/incidents/{incidentId}?api-version={azureConfigs[i].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, i); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + Console.WriteLine("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + + } + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {insName}: \n" + + ex.Message); + } + } + + /// + /// Batch update incidents from json payload file + /// + /// + public async Task BatchUpdateIncidentsFromJson() + { + var insId = Utils.SelectInstance(azureConfigs); + var incidentUpdates = Utils.LoadPayload("GetIncidents0.json", cliMode); + var incidentIds = incidentUpdates.Select(x => x.Name); + Console.WriteLine("Updating incidents:"); + Console.WriteLine("[{0}]", string.Join(", ", incidentIds)); + + foreach (var payload in incidentUpdates) + { + try + { + var incidentId = payload.Name; + + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}?api-version={azureConfigs[insId].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + Console.WriteLine("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + Console.WriteLine("Something went wrong: \n" + ex.Message); + } + } + } + + /// + /// Delete an incident by id + /// + /// + /// + public async Task DeleteIncident(string incidentId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}?api-version={azureConfigs[insId].ApiVersion}"; + + var request = new HttpRequestMessage(HttpMethod.Delete, url); + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + if (response.StatusCode == HttpStatusCode.NotFound) + throw new Exception("Not found, please create a new Incident first..."); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get an incident by id + /// + /// + /// + /// + public async Task GetIncidentById(string incidentId, int i) + { + try + { + var url = $"{azureConfigs[i].BaseUrl}/incidents/{incidentId}?api-version={azureConfigs[i].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, i); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get all incidents for all instances or for a single instance + /// + /// + public async Task GetIncidents(int insId) + { + if (insId != -1) + { + var values = await GetIncidentsByInstance(insId, azureConfigs[insId].FilterQuery); + var formattedRes = JsonConvert.SerializeObject(values, Formatting.Indented); + Utils.WriteJsonStringToFile($"GetIncidents_{azureConfigs[insId].InstanceName}.json", cliMode,formattedRes, false); + Console.WriteLine(formattedRes); + } + else + { + for (var i = 0; i < azureConfigs.Length; i++) + { + var values = await GetIncidentsByInstance(i, azureConfigs[i].FilterQuery); + var formattedRes = JsonConvert.SerializeObject(values, Formatting.Indented); + Utils.WriteJsonStringToFile($"GetIncidents_{azureConfigs[i].InstanceName}.json", cliMode, formattedRes, false); + Console.WriteLine(formattedRes); + continue; + } + } + } + + /// + /// Get all incidents for a single instance + /// + /// + /// + /// + public async Task GetIncidentsByInstance(int i, string filter = "") + { + try + { + var insName = azureConfigs[i].InstanceName; + var url = $"{azureConfigs[i].BaseUrl}/incidents?api-version={azureConfigs[i].ApiVersion}"; + + if (!string.IsNullOrEmpty(filter)) + { + url = $"{url}{filter}"; + } + + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, i); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject result = JsonConvert.DeserializeObject(res); + var values = result["value"] as JArray; + + if (values == null) + { + values = new JArray(); + } + + int callTimes = 1; + + while (result.ContainsKey("nextLink") && callTimes < 100) + { + try + { + var nextLink = result["nextLink"].ToString(); + request = new HttpRequestMessage(HttpMethod.Get, nextLink); + await authenticationService.AuthenticateRequest(request, i); + var nextResponse = await http.SendAsync(request); + + if (nextResponse.IsSuccessStatusCode) + { + var newRes = await nextResponse.Content.ReadAsStringAsync(); + JObject newResult = JsonConvert.DeserializeObject(newRes); + result = newResult; + var newValues = result["value"] as JArray; + + if (newValues == null) + { + newValues = new JArray(); + } + + foreach (var v in newValues) + { + values.Add(v); + } + + callTimes++; + } + else + { + var err = await response.Content.ReadAsStringAsync(); + Console.WriteLine($"Error calling the nextLink on {insName}: \n" + err); + break; + } + } + catch (Exception ex) + { + Console.WriteLine($"Error in parsing nextLink on {insName}: \n" + ex.Message); + break; + } + } + + return values; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException($"Error calling the API {insName}: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception($"Something went wrong on {azureConfigs[i].InstanceName}: \n" + + ex.Message); + } + } + + /// + /// Create an incident comment for an incident + /// + /// + /// + public async Task CreateIncidentComment(string incidentId) + { + var insId = Utils.SelectInstance(azureConfigs); + + var comments = Utils.LoadPayload("IncidentCommentPayload.json", cliMode); + + foreach (var payload in comments) + { + try + { + commentId = Guid.NewGuid().ToString(); + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}/comments/{commentId}?api-version={azureConfigs[insId].ApiVersion}"; + + var serialized = JsonConvert.SerializeObject(payload, new JsonSerializerSettings + { + ContractResolver = new DefaultContractResolver + { + NamingStrategy = new CamelCaseNamingStrategy() + } + }); + + var request = new HttpRequestMessage(HttpMethod.Put, url) + { + Content = new StringContent(serialized, Encoding.UTF8, "application/json") + }; + await authenticationService.AuthenticateRequest(request, insId); + + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + var res = await response.Content.ReadAsStringAsync(); + Console.WriteLine(JToken.Parse(res).ToString(Formatting.Indented)); + continue; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + } + + /// + /// Get an incident comment by id + /// + /// + /// + /// + public async Task GetIncidentCommentById(string incidentId, string commentId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}/comments/{commentId}?api-version={azureConfigs[insId].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) return await response.Content.ReadAsStringAsync(); + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + + /// + /// Get all incident comments under an incident + /// + /// + /// + public async Task GetAllIncidentComments(string incidentId, int insId) + { + try + { + var url = $"{azureConfigs[insId].BaseUrl}/incidents/{incidentId}/comments?api-version={azureConfigs[insId].ApiVersion}"; + var request = new HttpRequestMessage(HttpMethod.Get, url); + await authenticationService.AuthenticateRequest(request, insId); + var http = new HttpClient(); + var response = await http.SendAsync(request); + + if (response.IsSuccessStatusCode) + { + string res = await response.Content.ReadAsStringAsync(); + JObject result = JsonConvert.DeserializeObject(res); + var values = result["value"] as JArray; + + if (values == null) + { + values = new JArray(); + } + + int callTimes = 1; + + while (result.ContainsKey("nextLink") && callTimes < 100) + { + try + { + var nextLink = result["nextLink"].ToString(); + request = new HttpRequestMessage(HttpMethod.Get, nextLink); + await authenticationService.AuthenticateRequest(request, insId); + var nextResponse = await http.SendAsync(request); + + if (nextResponse.IsSuccessStatusCode) + { + var newRes = await nextResponse.Content.ReadAsStringAsync(); + JObject newResult = JsonConvert.DeserializeObject(newRes); + result = newResult; + var newValues = result["value"] as JArray; + + if (newValues == null) + { + newValues = new JArray(); + } + + foreach (var v in newValues) + { + values.Add(v); + } + + callTimes++; + } + else + { + var err = await response.Content.ReadAsStringAsync(); + Console.WriteLine("Error calling the nextLink: \n" + err); + break; + } + } + catch (Exception ex) + { + Console.WriteLine("Error in parsing nextLink: \n" + ex.Message); + break; + } + } + + Utils.WriteJsonStringToFile($"GetAllIncidentComments_{azureConfigs[insId].InstanceName}.json", cliMode, JsonConvert.SerializeObject(values, Formatting.Indented), false); + return res; + } + + var error = await response.Content.ReadAsStringAsync(); + var formatted = JsonConvert.DeserializeObject(error); + throw new WebException("Error calling the API: \n" + + JsonConvert.SerializeObject(formatted, Formatting.Indented)); + } + catch (Exception ex) + { + throw new Exception("Something went wrong: \n" + ex.Message); + } + } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/Comments/IncidentCommentPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/Comments/IncidentCommentPayload.cs new file mode 100644 index 0000000000..936b5ad5ef --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/Comments/IncidentCommentPayload.cs @@ -0,0 +1,10 @@ +using Newtonsoft.Json; + +namespace AzureSentinel_ManagementAPI.Incidents.Models.Comments +{ + public class IncidentCommentPayload + { + [JsonProperty("properties")] + public IncidentCommentPropertiesPayload PropertiesPayload { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/Comments/IncidentCommentPropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/Comments/IncidentCommentPropertiesPayload.cs new file mode 100644 index 0000000000..069c3987f0 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/Comments/IncidentCommentPropertiesPayload.cs @@ -0,0 +1,7 @@ +namespace AzureSentinel_ManagementAPI.Incidents.Models.Comments +{ + public class IncidentCommentPropertiesPayload + { + public string Message { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentAdditionalData.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentAdditionalData.cs new file mode 100644 index 0000000000..819979e465 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentAdditionalData.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AzureSentinel_ManagementAPI.Incidents.Models +{ + public class IncidentAdditionalData + { + public int AlertsCount { get; set; } + public int BookmarksCount { get; set; } + public int CommentsCount { get; set; } + public string[] AlertProductNames { get; set; } + public string[] Tactics { get; set; } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentOwner.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentOwner.cs new file mode 100644 index 0000000000..953408e330 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentOwner.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AzureSentinel_ManagementAPI.Incidents.Models +{ + public class IncidentOwner + { + public string ObjectId { get; set; } + public string Email { get; set; } + public string AssignedTo { get; set; } + public string UserPrincipalName { get; set; } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentPayload.cs new file mode 100644 index 0000000000..dcf7a10220 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentPayload.cs @@ -0,0 +1,17 @@ +using Newtonsoft.Json; +using System.Diagnostics.Tracing; + +namespace AzureSentinel_ManagementAPI.Incidents.Models +{ + public class IncidentPayload + { + [JsonProperty("properties")] + public IncidentPropertiesPayload PropertiesPayload { get; set; } + + [JsonProperty("etag")] + public string Etag { get; set; } + + [JsonProperty("name")] + public string Name { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentPropertiesPayload.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentPropertiesPayload.cs new file mode 100644 index 0000000000..c3b60deb7c --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentPropertiesPayload.cs @@ -0,0 +1,28 @@ +using AzureSentinel_ManagementAPI.Infrastructure.SharedModels.Enums; +using Newtonsoft.Json; +using Newtonsoft.Json.Converters; + +namespace AzureSentinel_ManagementAPI.Incidents.Models +{ + public class IncidentPropertiesPayload + { + [JsonConverter(typeof(StringEnumConverter))] + public Severity Severity { get; set; } + + [JsonConverter(typeof(StringEnumConverter))] + public IncidentStatus Status { get; set; } + + public string Title { get; set; } + + public string Classification { get; set; } + + public string ClassificationComment { get; set; } + + public string ClassificationReason { get; set; } + + public string Description { get; set; } + + [JsonProperty("owner")] + public IncidentOwner Owner { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentStatus.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentStatus.cs new file mode 100644 index 0000000000..1c85f73111 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Incidents/Models/IncidentStatus.cs @@ -0,0 +1,9 @@ +namespace AzureSentinel_ManagementAPI.Incidents.Models +{ + public enum IncidentStatus + { + New, + Active, + Closed + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/Authentication/AuthenticationService.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/Authentication/AuthenticationService.cs new file mode 100644 index 0000000000..7e1af0a5e0 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/Authentication/AuthenticationService.cs @@ -0,0 +1,55 @@ +using System; +using System.Net.Http; +using System.Net.Http.Headers; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.IdentityModel.Clients.ActiveDirectory; + +namespace AzureSentinel_ManagementAPI.Infrastructure.Authentication +{ + //Access token class to authenticate and obtain AAD Token for future calls + public class AuthenticationService + { + private ClientCredential credential; + private AuthenticationContext authContext; + private readonly AzureSentinelApiConfiguration[] azureConfigs; + + public AuthenticationService(AzureSentinelApiConfiguration[] azureConfig) + { + azureConfigs = azureConfig; + } + + /// + /// Get token by instance id + /// + /// + /// + public async Task GetToken(int id) + { + try + { + var azureConfig = azureConfigs[id]; + authContext = new AuthenticationContext("https://login.microsoftonline.com/" + azureConfig.TenantId); + credential = new ClientCredential(azureConfig.AppId, azureConfig.AppSecret); + return + await authContext.AcquireTokenAsync("https://management.azure.com", credential); + } + catch (Exception ex) + { + throw new Exception("Error Acquiring Access Token: \n" + ex.Message); + } + } + + /// + /// Get authorization token by instance and make the request authorized + /// + /// + /// + /// + public async Task AuthenticateRequest(HttpRequestMessage request, int id) + { + var token = await GetToken(id); + request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token.AccessToken); + } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/Configuration/AzureSentinelApiConfiguration.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/Configuration/AzureSentinelApiConfiguration.cs new file mode 100644 index 0000000000..e177293d6c --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/Configuration/AzureSentinelApiConfiguration.cs @@ -0,0 +1,27 @@ +namespace AzureSentinel_ManagementAPI.Infrastructure.Configuration +{ + public class AzureSentinelApiConfiguration + { + public string InstanceName { get; set; } + public string TenantId { get; set; } + public string AppId { get; set; } + public string AppSecret { get; set; } + public string SubscriptionId { get; set; } + public string ResourceGroupName { get; set; } + public string WorkspaceName { get; set; } + public string ApiVersion { get; set; } + public string PreviewApiVersion { get; set; } + public string UrlTemplate { get; set; } + public string OperationInsightUrlTemplate { get; set; } + public string BaseUrl => string.Format(UrlTemplate, SubscriptionId, ResourceGroupName, WorkspaceName); + public string OperationInsightBaseUrl => string.Format(OperationInsightUrlTemplate, SubscriptionId, ResourceGroupName, WorkspaceName); + public string WorkflowId { get; set; } + public string FilterQuery { get; set; } + + public string LastCreatedAction { get; set; } + public string LastCreatedAlertRule { get; set; } + public string LastCreatedBookmark { get; set; } + public string LastCreatedIncident { get; set; } + public string LastCreatedDataConnector { get; set; } + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/SharedModels/Enums/Severity.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/SharedModels/Enums/Severity.cs new file mode 100644 index 0000000000..4c45458775 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/SharedModels/Enums/Severity.cs @@ -0,0 +1,10 @@ +namespace AzureSentinel_ManagementAPI.Infrastructure.SharedModels.Enums +{ + public enum Severity + { + High, + Medium, + Low, + Informational + } +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/SharedModels/TupleList.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/SharedModels/TupleList.cs new file mode 100644 index 0000000000..f51b081847 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Infrastructure/SharedModels/TupleList.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace AzureSentinel_ManagementAPI.Infrastructure.SharedModels +{ + public class TupleList : List> + { + public void Add(T1 item, T2 item2) + { + Add(new Tuple(item, item2)); + } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Program.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Program.cs new file mode 100644 index 0000000000..73410c2281 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Program.cs @@ -0,0 +1,44 @@ +using System; +using System.Threading.Tasks; +using AzureSentinel_ManagementAPI.Actions; +using AzureSentinel_ManagementAPI.AlertRules; +using AzureSentinel_ManagementAPI.AlertRuleTemplates; +using AzureSentinel_ManagementAPI.Bookmarks; +using AzureSentinel_ManagementAPI.DataConnectors; +using AzureSentinel_ManagementAPI.Incidents; +using AzureSentinel_ManagementAPI.IncidentRelation; +using AzureSentinel_ManagementAPI.Infrastructure.Authentication; +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using AzureSentinel_ManagementAPI.Hunting; + +namespace AzureSentinel_ManagementAPI +{ + class Program + { + public static async Task Main(string[] args) + { + var rawConfig = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build(); + var configurations = rawConfig.GetSection("Instances").Get(); + + var serviceProvider = new ServiceCollection() + .AddSingleton() + .AddSingleton(rawConfig) + .AddSingleton(configurations) + .AddTransient() + .AddTransient() + .AddTransient() + .AddTransient() + .AddTransient() + .AddTransient() + .AddTransient() + .AddTransient() + .AddTransient() + .BuildServiceProvider(); + + await serviceProvider.GetService().Run(args); + } + } + +} \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Resource1.Designer.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Resource1.Designer.cs new file mode 100644 index 0000000000..4bc6e2b493 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Resource1.Designer.cs @@ -0,0 +1,693 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace AzureSentinel_ManagementAPI { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resource1 { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resource1() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("AzureSentinel_ManagementAPI.Resource1", typeof(Resource1).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to please input action id: . + /// + internal static string Action_Id_Prompt_Text { + get { + return ResourceManager.GetString("Action_Id_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input existing action rule id:. + /// + internal static string Action_Rule_Id_Prompt_Text { + get { + return ResourceManager.GetString("Action_Rule_Id_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Actions:. + /// + internal static string Actions_Menu { + get { + return ResourceManager.GetString("Actions_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Alert rule templates:. + /// + internal static string Alert_Rule_Template_Menu { + get { + return ResourceManager.GetString("Alert_Rule_Template_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Alert rules:. + /// + internal static string Alert_Rules_Menu { + get { + return ResourceManager.GetString("Alert_Rules_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 27.- BatchUpdateIncidents. + /// + internal static string Batch_Update_Incidents_Menu { + get { + return ResourceManager.GetString("Batch_Update_Incidents_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Please input existing bookmark id:. + /// + internal static string Bookmark_Prompt_Text { + get { + return ResourceManager.GetString("Bookmark_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Bookmarks:. + /// + internal static string Bookmarks_Menu { + get { + return ResourceManager.GetString("Bookmarks_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input comment id:. + /// + internal static string Comment_Id_Prompt_Text { + get { + return ResourceManager.GetString("Comment_Id_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Enter to continue. + /// + internal static string Continue_Prompt_Text { + get { + return ResourceManager.GetString("Continue_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 1.- CreateActionOfAlertRule - Attach a playbook to an analytic rule. + /// + internal static string Create_Action_Menu { + get { + return ResourceManager.GetString("Create_Action_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 15.- CreateBookmark. + /// + internal static string Create_Bookmark_Menu { + get { + return ResourceManager.GetString("Create_Bookmark_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 21.- CreateDataConnector. + /// + internal static string Create_DataConnector_Menu { + get { + return ResourceManager.GetString("Create_DataConnector_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 7.- CreateFusionAlertRule. + /// + internal static string Create_Fusion_Rule_Menu { + get { + return ResourceManager.GetString("Create_Fusion_Rule_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 28.- CreateIncidentComment. + /// + internal static string Create_Incident_Comment_Menu { + get { + return ResourceManager.GetString("Create_Incident_Comment_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 22.- CreateIncident. + /// + internal static string Create_Incident_Menu { + get { + return ResourceManager.GetString("Create_Incident_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 8.- CreateMicrosoftSecurityIncidentCreationAlertRule. + /// + internal static string Create_Incident_Rule_Menu { + get { + return ResourceManager.GetString("Create_Incident_Rule_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 31.- CreateIncidentRelation. + /// + internal static string Create_Relation_Menu { + get { + return ResourceManager.GetString("Create_Relation_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 36.- CreateSavedSearch. + /// + internal static string Create_Saved_Search_Menu { + get { + return ResourceManager.GetString("Create_Saved_Search_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 9.- CreateScheduledAlertRule. + /// + internal static string Create_Scheduled_Rule_Menu { + get { + return ResourceManager.GetString("Create_Scheduled_Rule_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input data connector id:. + /// + internal static string Dataconnector_Prompt_Text { + get { + return ResourceManager.GetString("Dataconnector_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to DataConnectors:. + /// + internal static string DataConnectors_Menu { + get { + return ResourceManager.GetString("DataConnectors_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 2.- DeleteActionOfAlertRule2. + /// + internal static string Delete_Action_Menu { + get { + return ResourceManager.GetString("Delete_Action_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 16.- DeleteBookmark. + /// + internal static string Delete_Bookmark_Menu { + get { + return ResourceManager.GetString("Delete_Bookmark_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 20.- DeleteDataConnector. + /// + internal static string Delete_DataConnector_Menu { + get { + return ResourceManager.GetString("Delete_DataConnector_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 23.- DeleteIncident. + /// + internal static string Delete_Incident_Menu { + get { + return ResourceManager.GetString("Delete_Incident_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input incident id (the incident's 'name' field, aka Internal Incident Id) you want to delete:. + /// + internal static string Delete_Incident_Prompt_Text { + get { + return ResourceManager.GetString("Delete_Incident_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 32.- DeleteIncidentRelation. + /// + internal static string Delete_Relation_Menu { + get { + return ResourceManager.GetString("Delete_Relation_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 10.- DeleteAlertRule. + /// + internal static string Delete_Rule_Menu { + get { + return ResourceManager.GetString("Delete_Rule_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 37.- DeleteSavedSearch. + /// + internal static string Delete_Saved_Search_Menu { + get { + return ResourceManager.GetString("Delete_Saved_Search_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Ctrl + C to exit. + /// + internal static string Exit_Text { + get { + return ResourceManager.GetString("Exit_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 3.- GetActionOfAlertRuleById. + /// + internal static string Get_Action_By_Id_Menu { + get { + return ResourceManager.GetString("Get_Action_By_Id_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 4.- GetAllActionsByAlertRule. + /// + internal static string Get_Actions_Menu { + get { + return ResourceManager.GetString("Get_Actions_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 17.- GetBookmarkById. + /// + internal static string Get_Bookmark_By_Id_Menu { + get { + return ResourceManager.GetString("Get_Bookmark_By_Id_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 18.- GetBookmarks. + /// + internal static string Get_Bookmarks_Menu { + get { + return ResourceManager.GetString("Get_Bookmarks_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 19.- GetDataConnectors. + /// + internal static string Get_DataConnectors_Menu { + get { + return ResourceManager.GetString("Get_DataConnectors_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 35.- GetIncidentEntitiesbyEntityType. + /// + internal static string Get_Entities_By_Type_Menu { + get { + return ResourceManager.GetString("Get_Entities_By_Type_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 12.- GetFusionAlertRule. + /// + internal static string Get_Fusion_Rule_Menu { + get { + return ResourceManager.GetString("Get_Fusion_Rule_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input fusion alert rule id:. + /// + internal static string Get_Fusion_Rule_Prompt_Text { + get { + return ResourceManager.GetString("Get_Fusion_Rule_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 24.- GetIncidentByInternalId. + /// + internal static string Get_Incident_By_Id_Menu { + get { + return ResourceManager.GetString("Get_Incident_By_Id_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 30.- GetIncidentCommentById. + /// + internal static string Get_Incident_Comment_Menu { + get { + return ResourceManager.GetString("Get_Incident_Comment_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 29.- GetAllIncidentComments. + /// + internal static string Get_Incident_Comments_Menu { + get { + return ResourceManager.GetString("Get_Incident_Comments_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input incident id (the incident's 'name' field, aka Internal Incident Id) you want to get:. + /// + internal static string Get_Incident_Prompt_Text { + get { + return ResourceManager.GetString("Get_Incident_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 13.- GetMicrosoftSecurityIncidentCreationAlertRule. + /// + internal static string Get_Incident_Rule_Menu { + get { + return ResourceManager.GetString("Get_Incident_Rule_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input microsoft security incident alert rule id:. + /// + internal static string Get_Incident_Rule_Prompt_Text { + get { + return ResourceManager.GetString("Get_Incident_Rule_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 25.- GetIncidents. + /// + internal static string Get_Incidents_Menu { + get { + return ResourceManager.GetString("Get_Incidents_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 34.- GetIncidentRelationByName. + /// + internal static string Get_Relation_Menu { + get { + return ResourceManager.GetString("Get_Relation_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 33.- GetAllIncidentRelationsAndEntities. + /// + internal static string Get_Relations_Menu { + get { + return ResourceManager.GetString("Get_Relations_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 5.- GetAlertRuleTemplateById. + /// + internal static string Get_Rule_Template_By_Id_Menu { + get { + return ResourceManager.GetString("Get_Rule_Template_By_Id_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 6.- GetAlertRuleTemplates. + /// + internal static string Get_Rule_Templates_Menu { + get { + return ResourceManager.GetString("Get_Rule_Templates_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 11.- GetAllAlertRules. + /// + internal static string Get_Rules_Menu { + get { + return ResourceManager.GetString("Get_Rules_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 38.- GetSavedSearchById. + /// + internal static string Get_Saved_Search_Menu { + get { + return ResourceManager.GetString("Get_Saved_Search_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 39.- GetSavedSearches. + /// + internal static string Get_Saved_Searches_Menu { + get { + return ResourceManager.GetString("Get_Saved_Searches_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 14.- GetScheduledAlertRule. + /// + internal static string Get_Scheduled_Rule_Menu { + get { + return ResourceManager.GetString("Get_Scheduled_Rule_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input scheduled alert rule id:. + /// + internal static string Get_Scheduled_Rule_Prompt_Text { + get { + return ResourceManager.GetString("Get_Scheduled_Rule_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Incident comments:. + /// + internal static string Incident_Comments_Menu { + get { + return ResourceManager.GetString("Incident_Comments_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input existing incident id ((the incident's 'name' field, aka Internal Incident Id):. + /// + internal static string Incident_Id_Prompt_Text { + get { + return ResourceManager.GetString("Incident_Id_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Incidents:. + /// + internal static string Incident_Menu { + get { + return ResourceManager.GetString("Incident_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Incident relations:. + /// + internal static string Incident_Relation_Menu { + get { + return ResourceManager.GetString("Incident_Relation_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Invalid option... please, press enter to continue.... + /// + internal static string Invalid_Option_Text { + get { + return ResourceManager.GetString("Invalid_Option_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Option:. + /// + internal static string Option { + get { + return ResourceManager.GetString("Option", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to related entities:. + /// + internal static string Related_Entities { + get { + return ResourceManager.GetString("Related_Entities", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input existing incident relation id:. + /// + internal static string Relation_Id_Prompt_Text { + get { + return ResourceManager.GetString("Relation_Id_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input alert rule id: . + /// + internal static string Rule_Id_Prompt_Text { + get { + return ResourceManager.GetString("Rule_Id_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input alert rule template id(Default is 157c0cfc-d76d-463b-8755-c781608cdc1a):. + /// + internal static string Rule_Template_Id_Prompt_Text { + get { + return ResourceManager.GetString("Rule_Template_Id_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to please input saved search id:. + /// + internal static string Saved_Search_Id_Prompt_Text { + get { + return ResourceManager.GetString("Saved_Search_Id_Prompt_Text", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to SavedSearches/Hunting queries:. + /// + internal static string Saved_Searches_Menu { + get { + return ResourceManager.GetString("Saved_Searches_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Please an entity kind:. + /// + internal static string Select_Entity_Kind { + get { + return ResourceManager.GetString("Select_Entity_Kind", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 26.- UpdateIncident. + /// + internal static string Update_Incident_Menu { + get { + return ResourceManager.GetString("Update_Incident_Menu", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to 40.- UpdateSavedSearch. + /// + internal static string Update_Saved_Search_Menu { + get { + return ResourceManager.GetString("Update_Saved_Search_Menu", resourceCulture); + } + } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Resource1.resx b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Resource1.resx new file mode 100644 index 0000000000..73aec42df7 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Resource1.resx @@ -0,0 +1,330 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Actions: + + + please input action id: + + + please input existing action rule id: + + + Alert rules: + + + Alert rule templates: + + + 27.- BatchUpdateIncidents + + + Bookmarks: + + + Please input existing bookmark id: + + + please input comment id: + + + Enter to continue + + + 1.- CreateActionOfAlertRule - Attach a playbook to an analytic rule + + + 15.- CreateBookmark + + + 21.- CreateDataConnector + + + 7.- CreateFusionAlertRule + + + 28.- CreateIncidentComment + + + 22.- CreateIncident + + + 8.- CreateMicrosoftSecurityIncidentCreationAlertRule + + + 31.- CreateIncidentRelation + + + 36.- CreateSavedSearch + + + 9.- CreateScheduledAlertRule + + + DataConnectors: + + + please input data connector id: + + + 2.- DeleteActionOfAlertRule2 + + + 16.- DeleteBookmark + + + 20.- DeleteDataConnector + + + 23.- DeleteIncident + + + please input incident id (the incident's 'name' field, aka Internal Incident Id) you want to delete: + + + 32.- DeleteIncidentRelation + + + 10.- DeleteAlertRule + + + 37.- DeleteSavedSearch + + + Ctrl + C to exit + + + 4.- GetAllActionsByAlertRule + + + 3.- GetActionOfAlertRuleById + + + 18.- GetBookmarks + + + 17.- GetBookmarkById + + + 19.- GetDataConnectors + + + 35.- GetIncidentEntitiesbyEntityType + + + 12.- GetFusionAlertRule + + + please input fusion alert rule id: + + + 25.- GetIncidents + + + 24.- GetIncidentByInternalId + + + 29.- GetAllIncidentComments + + + 30.- GetIncidentCommentById + + + please input incident id (the incident's 'name' field, aka Internal Incident Id) you want to get: + + + 13.- GetMicrosoftSecurityIncidentCreationAlertRule + + + please input microsoft security incident alert rule id: + + + 33.- GetAllIncidentRelationsAndEntities + + + 34.- GetIncidentRelationByName + + + 11.- GetAllAlertRules + + + 6.- GetAlertRuleTemplates + + + 5.- GetAlertRuleTemplateById + + + 39.- GetSavedSearches + + + 38.- GetSavedSearchById + + + 14.- GetScheduledAlertRule + + + please input scheduled alert rule id: + + + Incident comments: + + + please input existing incident id ((the incident's 'name' field, aka Internal Incident Id): + + + Incidents: + + + Incident relations: + + + Invalid option... please, press enter to continue... + + + Option: + + + related entities: + + + please input existing incident relation id: + + + please input alert rule id: + + + please input alert rule template id(Default is 157c0cfc-d76d-463b-8755-c781608cdc1a): + + + SavedSearches/Hunting queries: + + + please input saved search id: + + + Please an entity kind: + + + 26.- UpdateIncident + + + 40.- UpdateSavedSearch + + \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/ActionPayload/ActionPayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/ActionPayload/ActionPayload.json new file mode 100644 index 0000000000..f0cffec0a2 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/ActionPayload/ActionPayload.json @@ -0,0 +1,8 @@ +[ + { + "properties": { + "triggerUri": "", + "logicAppResourceId": "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Logic/workflows/" + } + } +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/BookmarkPayload/BookmarkPayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/BookmarkPayload/BookmarkPayload.json new file mode 100644 index 0000000000..d7017f4919 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/BookmarkPayload/BookmarkPayload.json @@ -0,0 +1,26 @@ +[ + { + "properties": { + "displayName": "My bookmark", + "notes": "Found a suspicious activity", + "labels": [ + "Tag1", + "Tag2" + ], + "query": "SecurityEvent | where TimeGenerated > ago(1d) and TimeGenerated < ago(2d)", + "queryResult": "Security Event query result" + } + }, + { + "properties": { + "displayName": "My bookmark2", + "notes": "Found a suspicious activity", + "labels": [ + "Tag1", + "Tag2" + ], + "query": "SecurityEvent | where TimeGenerated > ago(1d) and TimeGenerated < ago(2d)", + "queryResult": "Security Event query result" + } + } +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/DataConnectorPayload/DataConnectorPayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/DataConnectorPayload/DataConnectorPayload.json new file mode 100644 index 0000000000..68db8b5161 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/DataConnectorPayload/DataConnectorPayload.json @@ -0,0 +1,16 @@ +[ + { + "kind": "Office365", + "properties": { + "tenantId": "", + "dataTypes": { + "sharePoint": { + "state": "Enabled" + }, + "exchange": { + "state": "Enabled" + } + } + } + } +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/FusionAlertRulePayload/FusionAlertRulePayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/FusionAlertRulePayload/FusionAlertRulePayload.json new file mode 100644 index 0000000000..4296af9771 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/FusionAlertRulePayload/FusionAlertRulePayload.json @@ -0,0 +1,9 @@ +[ + { + "kind": "Fusion", + "properties": { + "enabled": true, + "alertRuleTemplateName": "f71aba3d-28fb-450b-b192-4e76a83015c8" + } + } +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/IncidentCommentPayload/IncidentCommentPayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/IncidentCommentPayload/IncidentCommentPayload.json new file mode 100644 index 0000000000..b9e95513b7 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/IncidentCommentPayload/IncidentCommentPayload.json @@ -0,0 +1,7 @@ +[ + { + "properties": { + "message": "Some message" + } + } +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/IncidentPayload/IncidentPayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/IncidentPayload/IncidentPayload.json new file mode 100644 index 0000000000..a667dbc437 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/IncidentPayload/IncidentPayload.json @@ -0,0 +1,9 @@ +[ + { + "properties": { + "severity": "Low", + "status": "New", + "title": "Test Incident" + } + } +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/SavedSearchPayload/SavedSearchPayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/SavedSearchPayload/SavedSearchPayload.json new file mode 100644 index 0000000000..502420cdfe --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/SavedSearchPayload/SavedSearchPayload.json @@ -0,0 +1,20 @@ +[ +{ + "properties": { + "Category": "Hunting Queries", + "DisplayName": "HuntingRule 1", + "Query": "SecurityEvent | where EventID == \"4688\" | where CommandLine contains \"-noni -ep bypass $\"", + "Tags": [ + { + "Name": "Description", + "Value": "Test", + "Hunting": "Query" + }, + { + "Name": "Tactics", + "Value": "Execution, Discovery" + } + ] + } +} +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/ScheduledAlertRulePayload/ScheduledAlertRulePayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/ScheduledAlertRulePayload/ScheduledAlertRulePayload.json new file mode 100644 index 0000000000..02720d7de2 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/ScheduledAlertRulePayload/ScheduledAlertRulePayload.json @@ -0,0 +1,23 @@ +[ + { + "kind": "Scheduled", + "properties": { + "displayName": "Test Rule", + "description": "", + "severity": "High", + "enabled": true, + "tactics": [ + "Persistence", + "LateralMovement" + ], + "query": "AzureActivity | where isnotempty(OperationName)", + "queryFrequency": "PT1H", + "queryPeriod": "P2DT1H30M", + "triggerOperator": "GreaterThan", + "triggerThreshold": 0, + "suppressionDuration": "PT1H", + "suppressionEnabled": false + }, + "playbook": "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Logic/workflows/" + } +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/SecurityAlertRulePayload/SecurityAlertRulePayload.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/SecurityAlertRulePayload/SecurityAlertRulePayload.json new file mode 100644 index 0000000000..2cd03eb43e --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Templates/SecurityAlertRulePayload/SecurityAlertRulePayload.json @@ -0,0 +1,10 @@ +[ + { + "kind": "MicrosoftSecurityIncidentCreation", + "properties": { + "productFilter": "Microsoft Cloud App Security", + "displayName": "MCAS alert rule", + "enabled": true + } + } +] diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Utils.cs b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Utils.cs new file mode 100644 index 0000000000..179c062e9f --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/Utils.cs @@ -0,0 +1,190 @@ +using AzureSentinel_ManagementAPI.Infrastructure.Configuration; +using Newtonsoft.Json; +using System; +using System.Globalization; +using System.IO; +using System.Reflection; +using System.Resources; + +namespace AzureSentinel_ManagementAPI +{ + static class Utils + { + private static ResourceManager resource = new ResourceManager("AzureSentinel_ManagementAPI.Resource1", Assembly.GetExecutingAssembly()); + + /// + /// Select one from enum type + /// + /// + /// + public static TEnum SelectKind() + { + string[] kinds = System.Enum.GetNames(typeof(TEnum)); + + for (int i = 0; i < kinds.Length; i++) + { + Console.WriteLine($" {(i + 1).ToString()}. {kinds[i]}"); + } + + var len = kinds.Length; + var isValid = false; + var index = -1; + + while (!isValid) + { + Console.WriteLine($"Please type in a number between 1 and {len.ToString()}"); + var option = Console.ReadLine(); + isValid = int.TryParse(option, out index); + isValid = isValid && index > 0 && index < len; + } + TEnum kind = (TEnum)Enum.Parse(typeof(TEnum), kinds[index - 1], true); + return kind; + } + + /// + /// Get user input, return default value if no user input + /// + /// + /// + /// + public static string GetInput(string promptText, string defaultValue = "") + { + Console.WriteLine(promptText); + var input = Console.ReadLine(); + + if (input.Trim() == string.Empty) + { + input = defaultValue; + } + + return input; + } + + /// + /// Select a specific instance + /// + /// + /// + public static int SelectInstance(AzureSentinelApiConfiguration[] configs) + { + var isValid = false; + var index = -1; + int len = configs.Length; + + if (len == 1) + return 0; + + while (!isValid) + { + Console.WriteLine($"Please select instance, Please type in a number between 1 and {len.ToString()}:"); + + for(int i = 0; i < len; i++) + { + Console.WriteLine($"{i + 1}. {configs[i].InstanceName}"); + } + + var option = Console.ReadLine(); + isValid = int.TryParse(option, out index); + isValid = isValid && index > 0 && index <= len; + } + return index-1; + } + + /// + /// Select a specific instance to apply to all instances + /// + /// + /// + public static int SelectInstanceOrApplyAll(AzureSentinelApiConfiguration[] configs) + { + int len = configs.Length; + + if (len == 1) + return 0; + + Console.WriteLine($"Please select an instance, Please type in a number between 1 and {len.ToString()}, Otherwise it would apply to all:"); + + for (int i = 0; i < len; i++) + { + Console.WriteLine($"{i + 1}. {configs[i].InstanceName}"); + } + + var option = Console.ReadLine(); + int index; + bool isValid = int.TryParse(option, out index); + isValid = isValid && index > 0 && index <= len; + + return isValid ? index - 1: -1; + } + + /// + /// Write json output string to a json file + /// + /// + /// + /// + public static void WriteJsonStringToFile(string fileName, bool cliMode, string jsonData, bool format = true) + { + try + { + if (format) + { + var jsonObj = JsonConvert.DeserializeObject(jsonData); + jsonData = JsonConvert.SerializeObject(jsonObj, Formatting.Indented); + } + + string projectPath = cliMode ? Directory.GetCurrentDirectory() : + Path.GetDirectoryName(Path.GetDirectoryName( + Path.GetDirectoryName(Directory.GetCurrentDirectory()))); + string resultFolder = "Results"; + string filePath = Path.Combine(projectPath, resultFolder, fileName); + System.IO.File.WriteAllText(filePath, jsonData); + } + catch (Exception ex) + { + Console.WriteLine(ex.Message); + } + } + + /// + /// Load payload from json file + /// + /// + /// + /// + public static T LoadPayload(string fileName, bool cliMode) + { + try { + Console.WriteLine($"Request body from {fileName}:"); + string projectPath = cliMode ? Directory.GetCurrentDirectory() : + Path.GetDirectoryName(Path.GetDirectoryName( + Path.GetDirectoryName(Directory.GetCurrentDirectory()))); + + string fileFolderName = Path.GetFileNameWithoutExtension(fileName); + string resultFolder = Path.Combine("Templates", fileFolderName); + string filePath = Path.Combine(projectPath, resultFolder, fileName); + var data = System.IO.File.ReadAllText(filePath); + + Console.WriteLine(data); + + var incidentObj = JsonConvert.DeserializeObject(data); + return incidentObj; + } + catch (Exception ex) + { + Console.WriteLine(ex.Message); + return default; + } + } + + /// + /// Get localized text from resource file by key + /// + /// + /// + public static string GetString(string key) + { + return resource.GetString(key, CultureInfo.CurrentCulture); + } + } +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/appsettings.json b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/appsettings.json new file mode 100644 index 0000000000..b91b49ceea --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/appsettings.json @@ -0,0 +1,40 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Debug", + "System": "Information", + "Microsoft": "Information" + } + }, + "Climode": false, + "Instances": [ + { + "InstanceName": "", + "TenantId": "", + "AppId": "", + "AppSecret": "", + "SubscriptionId": "", + "ResourceGroupName": "", + "WorkspaceName": "", + "ApiVersion": "2020-01-01", + "PreviewApiVersion": "2019-01-01-preview", + "FilterQuery": "", + "UrlTemplate": "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.OperationalInsights/workspaces/{2}/providers/Microsoft.SecurityInsights", + "OperationInsightUrlTemplate": "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.OperationalInsights/workspaces/{2}" + }, + { + "InstanceName": "", + "TenantId": "", + "AppId": "", + "AppSecret": "", + "SubscriptionId": "", + "ResourceGroupName": "", + "WorkspaceName": "", + "ApiVersion": "2020-01-01", + "PreviewApiVersion": "2019-01-01-preview", + "FilterQuery": "", + "UrlTemplate": "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.OperationalInsights/workspaces/{2}/providers/Microsoft.SecurityInsights", + "OperationInsightUrlTemplate": "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.OperationalInsights/workspaces/{2}" + } + ] +} diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/copydata.bat b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/copydata.bat new file mode 100644 index 0000000000..c34e7a53ea --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/AzureSentinel_ManagementAPI/copydata.bat @@ -0,0 +1,2 @@ +REM xcopy "Templates\*.*" "bin\Debug\netcoreapp3.1\Templates" /K /D /H /E +xcopy "Templates\*.*" "bin\Release\netcoreapp3.1\publish\Templates" /K /D /H /E \ No newline at end of file diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/After-consent.PNG b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/After-consent.PNG new file mode 100644 index 0000000000000000000000000000000000000000..8f651f16124169740a0d0d3f287625ce5e3356c7 GIT binary patch literal 70914 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 E2j1drp#T5? literal 0 HcmV?d00001 diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/AzureSentinel-permission.PNG b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/AzureSentinel-permission.PNG new file mode 100644 index 0000000000000000000000000000000000000000..b295cd8d2fc90711a28e6ba54c4946569c9757bc GIT binary patch literal 89957 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 G#{UyKuRLM^ literal 0 HcmV?d00001 diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/Console-Menu.PNG b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/Console-Menu.PNG new file mode 100644 index 0000000000000000000000000000000000000000..66aff7257e482fbec0ab60e125c91b8323d1e617 GIT binary patch literal 39377 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 literal 0 HcmV?d00001 diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/LogicApp-permission.PNG b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/LogicApp-permission.PNG new file mode 100644 index 0000000000000000000000000000000000000000..689e35bcf7287202adf464513407d1beb8d40751 GIT binary patch literal 78921 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 literal 0 HcmV?d00001 diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/Start-button.PNG b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/Images/Start-button.PNG new file mode 100644 index 0000000000000000000000000000000000000000..3d77bdb92570f50b03604e26d5f0038630261259 GIT binary patch literal 88674 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

s_?k{7^DNxyeGf@95TN9SO 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 literal 0 HcmV?d00001 diff --git a/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/README.md b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/README.md new file mode 100644 index 0000000000..d979ac82a9 --- /dev/null +++ b/Tools/Sample Code/AzureSentinel-ManagementAPICsharp/README.md @@ -0,0 +1,189 @@ +# Azure Sentinel Management API C# Sample +Author: Chi Nguyen + +## Description +This repo contains a C# .NET Core 3.1 console application to demonstrate how you can leverage the Azure Sentinel Management API to programmatically manage your Azure Sentinel workspace(s). + +The application uses OAuth 2.0 client credentials flow on Microsoft Identity Platform for authentication. Essentially, the flow permits the application to use its own credentials, instead of impersonating a user, to authenticate when calling the Azure Sentinel API. Please refer to [OAuth 2.0 client credentials flow](https://docs.microsoft.com/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow) for more details on the authentication mechanism. + +What can you use this solution for? +1. For starters, it serves as a quickstart to help you set up a custom application to call the Azure Sentinel REST API to automate your management tasks on Azure Sentinel. Some examples include importing and exporting analytic rules, disable and enable an analytic rules, updating multiple incidents at once across workspaces, and many other use cases. The app can handle multiple Azure Sentinel workspaces cross-tenant at once, so if you manage multiple workspaces for multiple clients as a MSSP, this can be a solution. +2. Additionally, the solution can be combined and integrated with other tools within your organization to achieve a more comprehensive security solution. + +Please refer to the documentation and specs below for more details on Azure Sentinel API. +* [Sentinel API documentation](https://docs.microsoft.com/rest/api/securityinsights/) +* [Saved Searches/Hunting queries API documentation](https://docs.microsoft.com/rest/api/loganalytics/savedsearches) +* [Sentinel API specs - Stable: 2020-01-01 version](https://github.com/Azure/azure-rest-api-specs/blob/master/specification/securityinsights/resource-manager/Microsoft.SecurityInsights/stable/2020-01-01/SecurityInsights.json) +* [Sentinel API specs - Preview: 2019-01-01 version](https://github.com/Azure/azure-rest-api-specs/blob/master/specification/securityinsights/resource-manager/Microsoft.SecurityInsights/preview/2019-01-01-preview/SecurityInsights.json) + +This sample provides examples of the following Sentinel API operation groups. + +| Entity | Operation | API version | +| -----------|-----------|--------| +| Alert Rule | Get, Create, Update, Delete | Stable | +| Alert Rule Templates | Get | Stable | +| Data Connector | Get, Create, Delete | Stable | +| Incidents | Get, Create, Update, Delete | Stable| +| Incident Comments | Get, Create | Stable | +| Incident Relation | Get, Create, Update, Delete | Preview | +| Bookmarks | Get, Create, Delete | Stable| +| Playbooks | Get, Create, Delete| Stable| +| Hunting Queries | Get, Create, Update, Delete | Stable | + + +## Prerequisites +To configure the tool, the following assembly is required to authenticate and make requests to the Azure Sentinel Management API. + +### _Azure Sentinel_ +1. **Active Azure Subscription**, if you don't have one, create a [free account](https://azure.microsoft.com/free/?WT.mc_id=A261C142F) before you begin. + +2. **Log Analytics workspace**. If you don't have one, [create a Log Analytics workspace](https://docs.microsoft.com/azure/azure-monitor/learn/quick-create-workspace). + +3. Obtain **WorkSpaceId** and **WorkspaceKey** following these steps. Copy this workspace Id and Key as you will need them later to run the application. + 1. In the Azure portal, search for and select **Log Analytics workspaces** + 1. In your list of Log Analytics workspaces, select the workspace you intend on configuring the agent to report to. + 1. Select **Advanced Settings**. + +4. To enable Azure Sentinel, you need **Contributor** permissions to the subscription in which the Azure Sentinel workspace resides. Learn more to [onboard Azure Sentinel](https://docs.microsoft.com/azure/sentinel/quickstart-onboard#enable-azure-sentinel-). + +5. To use Azure Sentinel, you need either **contributor** or **reader** permissions on the resource group that the workspace belongs to. + +### _AAD Application Registration_ +To configure the sample, you'll need to register a new Azure Active Directory application (Service Principal) in the Microsoft [Application Registration Portal](https://portal.azure.com/#blade/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/RegisteredApps). +Follow these steps to register a new application: +1. Sign in to the [Application Registration Portal](https://portal.azure.com/#blade/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/RegisteredApps) using either your personal or work or school account. + +2. Choose **New registration**. + +3. Enter an application name, and choose **Register**. + +4. Open the **Overview** page of your app. Copy and save the **Application Id** field. You will need it later to complete the configuration process. + +5. Under **Certificates & secrets**, choose **New client secret** and add a quick description. A new secret will be displayed in the **Value** column. Copy this password. You will need it later to complete the configuration process and it will not be shown again. + +### _Permissions_ + Adhering to the principle of least privilege, always grant the lowest possible permissions required to your API. + +1. Azure Sentinel permissions + 1. To access your Azure Sentinel workspace, your app needs **Sentinel Contributor / Azure Sentinel Responder / Azure Sentinel Reader**” permissions. If you have multiple Azure Sentinel workspaces, repeat these steps for each of the workspaces. + 1. In the Resource Group where Azure Sentinel has been built, open **Access Control (IAM)** setting. + 2. Select **Add a role assignment**. + 3. Under **Role** search box, search for and select one of the roles above. + 4. Under **Select** search box, search for your app name and select it. + 5. Select **Save** to finish the role assignment. + + ![Azure Sentinel permission](./Images/AzureSentinel-permission.png) +2. Logic Apps permissions + 1. To get/enable/disable a security playbook associated with an analytic rule, your app needs **Logic App Contributor / Logic App Operator** permission. If you have multiple Azure Sentinel workspaces, repeat these steps for each of the workspaces. + 1. In the Resource Group where Azure Sentinel has been built, open **Access Control (IAM)** setting. + 2. Select **Add a role assignment**. + 3. Under **Role** search box, search for and select one of the roles above. + 4. Under **Select** search box, search for your app name and select it. + 5. Select **Save** to finish the role assignment. + + ![Logic Apps permission](./Images/LogicApp-permission.png) + +3. If you have Azure Sentinel workspaces in multiple tenants, then follow these additional steps to grant other tenants access to your app. + 1. Provide your Administrator your **Application Id** that you get in the previous steps. Your organization’s Admin (or other user authorized to grant consent for organizational resources) is required to grant consent to the application. + + 2. As the tenant Admin for your organization, open a browser window and craft the following URL in the address bar. Make sure to replace APPLICATION_ID with the **application Id** of your app, then select **Accept**. + ```https://login.microsoftonline.com/common/adminconsent?client_id=APPLICATION_ID``` + + 3. After logging in, the tenant Admin will be presented with a dialog like the following (depending on which permissions the application is requesting): + + ![Scope consent dialog](./Images/admin-consent.png) + + 4. When the tenant Admin agrees to this dialog, he/she is granting consent for all users of their organization to use this application. If a message like the following screenshot appears, then ignore it. That is expected for a daemon app without a Redirect URI. + + ![After admin consent dialog](./Images/After-consent.png) + +### _Azure Key Vault_ +Although Azure Key Vault is an optional component, we highly recommend it. +TODO: Wire up Azure Key Vault to manage application and Azure Sentinel credentials in this solution. + +## Setup + +1. Create a new folder called **Samples** in your local machine. +2. Open a command prompt. +3. In the command prompt, navigate to this **Samples** folder. Clone Azure Sentinel repository to the folder by running this command: git clone https://github.com/Azure/Azure-Sentinel.git +4. In explorer, navigate to the cloned repo, then navigate to the **Tools** directory, select **Sample Code**. Then in **AzureSentinel-ManagementAPICsharp** folder, open **AzureSentinel_ManagementAPI.sln** in Visual Studio 2017 or later. +5. Install necessary dependencies: In Visual Studio, right click the **AzureSentinel_ManagementAPI** solution, then select **Restore NuGet Packages**. +6. Open **Appsettings.json** file, fill in the values of the following variables using the information you've saved from the [Prerequisites](#Prerequisites) section. + 1. **InstanceName**: a name of your choice for your Azure Sentinel. + 2. **TenantId**: ID value of your tenant where your app resides. + 3. **AppId**: your application ID. + 4. **AppSecret**: your application secret. + 5. **SubscriptionId**: ID value of your subscription where your app resides. + 6. **ResourceGroupName**: name of your resource group where you've granted Azure Sentinel and Logic Apps permissions to your app. + 7. **WorkspaceName**: name of your Azure Sentinel workspace. + 8. **FilterQuery**: customize the filter clause to your needs. In the following example, I filter incidents by incident **LastModifiedDateTime**, **Status**, and an analyst who the incident's assigned to. + 9. Repeat step 1-8 above if you have multiple Azure Sentinel instances. + + ``` + "Instances": [ + { + "InstanceName": "", + "TenantId": "", + "AppId": "", + "AppSecret": "", + "SubscriptionId": "", + "ResourceGroupName": "", + "WorkspaceName": "", + "ApiVersion": "2020-01-01", + "PreviewApiVersion": "2019-01-01-preview", + "FilterQuery": "&$filter=properties/lastModifiedTimeUtc gt 2020-08-10T07:00:00.000000Z and properties/status eq 'Active' and properties/owner/assignedTo eq 'analyst@contoso.com'", + "UrlTemplate": "https://management.azure.com/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.OperationalInsights/workspaces/{2}/providers/Microsoft.SecurityInsights" + }, + ``` + +## Run The Application +Follow these steps to run the application in Visual Studio. + +1. The **Templates** folder contains templates of the request body or payload for **CREATE/UPDATE** API requests in json format. Modify the payload for each entity you'd like to make a request. For example, **IncidentPayload.json** file is where you can edit your payload you'd like to send when making for CreateIncidents request. +2. Choose the **AzureSentinel_ManagementAPI** button on the toolbar to run the application in Debug mode. (Or, you can press F5.) + + ![Start application](./Images/start-button.png) + +3. Once the app is running, a menu like the folowing screenshot appears in the console window. + 1. Each API call is represented by each option in the menu. Enter a number corresponding with your API request in the console. For example, next to the **Option**, enter number **22** to create an incident. The content of the incident comes from the **IncidentPayload.json** file you've filled in. + 2. Press ENTER or Ctrl + C if you want to close the application. + + ![View Console](./Images/console-menu.png) + +4. The **Results** folder contains responses from all GET requests you make. For example, when you make a GetIncidents request, the app will export the incidents returned from the request to a file starting with **GetIncidents.json** in the Results folder. + +## Important Notes +The API currently has some limitations, and here are a few things to note regarding this sample. + +1. Data Connectors: For CREATE data connector request to enable a data connection in Azure Sentinel, the API currently supports **User-Delegated** mode of authentication only, which requires a user sign-in. This solution is using **Application-Only** authentication, as the app is a daemon service running in the background without a user sign-in, so it isn't currently working if you enable a data connector via this solution. + +2. Incidents: To close an incident (option 26 or 27 in the option menu), these following fields must be filled with values. Go to **Templates** folder, open **IncidentPayload.json** file, and make the modification accordingly. + + "classification": "", + "classificationComment": "", + "classificationReason": "" + +3. Actions: To select a playbook for an analytic rule, you can either use Option 1 (Create Action) or option 9 (Create Alert rule) in the menu. Open your **ActionPayload.json** file in **templates** folder and ill in values of these fields: + 1. **triggerUri**: Callback URL for your playbook trigger. To get this URL, make a POST request to [WorkflowTrigger CallbackUrl](https://docs.microsoft.com/rest/api/logic/workflowtriggers/listcallbackurl). You can easily obtain the value using this [code-try](https://docs.microsoft.com/rest/api/logic/workflowtriggers/listcallbackurl#code-try-0). The **value** field in the response should be the URL. + 2. **logicAppResourceId**: Azure ARM resource ID of your logic app. Fill in the Subscription Id, Resource Group Name, and Playbook Name in the value. + + ```[ + { + "properties": { + "triggerUri": "", + "logicAppResourceId": "/subscriptions//resourceGroups//providers/Microsoft.Logic/workflows/" + } + }, + ``` + +### Contributing + +This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com. + +When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA. + +This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). +For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. + +### Copyright +Copyright (c) 2020 Microsoft. All rights reserved.