diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 00000000..339315ad --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,12 @@ +# To get started with Dependabot version updates, you'll need to specify which +# package ecosystems to update and where the package manifests are located. +# Please see the documentation for all configuration options: +# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file + +version: 2 +updates: + - package-ecosystem: "" # See documentation for possible values + directory: "/" # Location of package manifests + schedule: + interval: "weekly" + diff --git a/.github/labeler.yml b/.github/labeler.yml new file mode 100644 index 00000000..c53d2d66 --- /dev/null +++ b/.github/labeler.yml @@ -0,0 +1,2 @@ +App: + - '/.*/' diff --git a/.github/workflows/ci.yaml b/.github/workflows/dockerbuild.yaml similarity index 78% rename from .github/workflows/ci.yaml rename to .github/workflows/dockerbuild.yaml index f06f556d..eaf2d1b0 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/dockerbuild.yaml @@ -1,4 +1,4 @@ -name: ci +name: dockerbuild on: push: @@ -23,6 +23,13 @@ jobs: ret = [] for i in flist: a,v = i.split('/') + # Look for folders only + if 'unsupported' in v or 'unsupported' in a: + continue + + if '.md' in v: + continue + ret.append({'app':a, 'version':v }) print(json.dumps({'include': ret})) EOF @@ -38,7 +45,7 @@ jobs: steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 - name: Set up QEMU uses: docker/setup-qemu-action@v1 @@ -47,7 +54,7 @@ jobs: uses: docker/setup-buildx-action@v1 - name: Login to DockerHub - uses: docker/login-action@v1 + uses: docker/login-action@v3 with: username: ${{ secrets.DOCKERHUB_USERNAME }} password: ${{ secrets.DOCKERHUB_TOKEN }} @@ -60,28 +67,28 @@ jobs: name: Build and push Master if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }} id: docker_build_master - uses: docker/build-push-action@v2 + uses: docker/build-push-action@v6 with: context: ${{ matrix.app }}/${{ matrix.version }} file: ${{ matrix.app }}/${{ matrix.version }}/Dockerfile - platforms: linux/amd64,linux/arm64,linux/386 + platforms: linux/amd64,linux/arm64 push: true tags: | - ${{ secrets.DOCKERHUB_USERNAME }}/${{ matrix.app }}:${{ matrix.version }} - ${{ secrets.DOCKERHUB_USERNAME }}/${{ matrix.app }}:latest - ${{ secrets.DOCKERHUB_USERNAME }}/shuffle:${{ matrix.app }}_${{ matrix.version }} + frikky/${{ matrix.app }}:${{ matrix.version }} + frikky/${{ matrix.app }}:latest + frikky/shuffle:${{ matrix.app }}_${{ matrix.version }} - name: Build and push Feature PR if: ${{ github.event_name == 'pull_request' }} id: docker_build_feature - uses: docker/build-push-action@v2 + uses: docker/build-push-action@v6 with: context: ${{ matrix.app }}/${{ matrix.version }} file: ${{ matrix.app }}/${{ matrix.version }}/Dockerfile platforms: linux/amd64,linux/arm64,linux/386 push: true tags: | - ${{ secrets.DOCKERHUB_USERNAME }}/${{ matrix.app }}:${{ github.head_ref }} + frikky/${{ matrix.app }}:${{ github.head_ref }} - name: Image digest run: | diff --git a/.github/workflows/project_automation.yml b/.github/workflows/project_automation.yml new file mode 100644 index 00000000..837957f6 --- /dev/null +++ b/.github/workflows/project_automation.yml @@ -0,0 +1,26 @@ +name: Automation - Add all new issues to roadmap project + +on: + issues: + types: + - opened + +jobs: + add-label: + name: Add label to issue + runs-on: ubuntu-latest + steps: + - uses: github/issue-labeler@v3.3 #May not be the latest version + with: + configuration-path: .github/labeler.yml + repo-token: ${{ secrets.ADD_TO_PROJECT_PAT }} + enable-versioned-regex: 0 + + add-to-project: + name: Add issue to project + runs-on: ubuntu-latest + steps: + - uses: actions/add-to-project@v0.5.0 + with: + project-url: https://github.com/orgs/Shuffle/projects/8 + github-token: ${{ secrets.ADD_TO_PROJECT_PAT }} diff --git a/.gitignore b/.gitignore index b6de6b64..10cc58e5 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,8 @@ *.swo *.swp +*.swn +*.swm +*.pem *test.py *.remote-sync.json .DS_Store diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 00000000..271c0fc2 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,76 @@ +# Repository Guidelines + +## Project Structure & Module Organization +This repository hosts Shuffle app implementations. Each app lives in a top-level folder named after the integration (e.g., `aws-ec2/`), and each release is versioned under a subfolder like `1.0.0/`. A typical app version contains: + +- `src/app.py`: the Shuffle SDK entry point. +- `api.yaml`: OpenAPI definition used by Shuffle. +- `requirements.txt`: Python dependencies for the app. +- `Dockerfile`: container build instructions for the app. +- `README.md`: app-specific usage and action documentation. +- Optional assets such as screenshots (`*.png`). + +In `api.yaml`, prefer an `authentication` block for shared credentials (URL, tokens, keys). Actions should only include auth parameters when they truly differ per call. + +## Build, Test, and Development Commands +Apps are built and run container-first via the Shuffle SDK image. From an app version directory: + +- `docker build -t shuffle-: .`: build the app image. +- `docker run --rm shuffle-:`: run the app container locally. + +For quick iteration on code, you can also run the Python entrypoint in a virtualenv: + +- `pip install -r requirements.txt` +- `python src/app.py --log-level DEBUG` + +## Coding Style & Naming Conventions +Use 4-space indentation and standard Python style. Keep functions `snake_case`, classes `CamelCase`, and constants `UPPER_SNAKE_CASE`. Match existing patterns in `src/app.py` and keep action names aligned with `api.yaml`. + +## Creating New Shuffle Apps (Agent Workflow) +Use an existing app as a template (e.g., `http/1.4.0/` or `aws-ec2/1.0.0/`) and follow the same folder layout. A minimal, working app version should include: + +- `api.yaml`: action definitions, parameters, and examples. +- `src/app.py`: class extending the Shuffle SDK (`shuffle_sdk.AppBase`). +- `requirements.txt`: third-party dependencies. +- `Dockerfile`: built on `frikky/shuffle:app_sdk`. + +When adding actions, ensure the `api.yaml` action name matches the method name in `src/app.py` and parameter names align exactly. Keep input parsing defensive (strings vs JSON), and return JSON-serializable results. For HTTP integrations, centralize auth and base URL handling and add a TLS `verify` option. If a service requires special payloads (e.g., ADF for Jira), accept JSON strings and pass through unchanged. Keep `api.yaml` examples realistic because they show up in the Shuffle UI. + +## Authentication & App Configuration +Most apps declare credentials in `api.yaml` under `authentication:` so Shuffle injects them automatically. In code, read those values as normal action arguments (Shuffle passes them into each action). Prefer a single auth helper in `src/app.py` (e.g., `_auth()` for tokens, `_build_api_base()` for base URLs) and reuse it across actions. If an integration supports multiple auth modes (token vs password), accept both and choose the provided one. + +Prefer small, focused actions (create, update, list, search) and document auth requirements and examples in the app `README.md`. + +## Manual Python App Notes (From Shuffle Docs) +- **SDK image choices:** Shuffle provides Alpine (slim), Kali (security tooling), and Blackarch (kitchen‑sink). This repo’s Dockerfiles typically use `frikky/shuffle:app_sdk` (Alpine‑based) unless a toolset requires otherwise. +- **Directory layout:** `api.yaml`, `Dockerfile`, `requirements.txt`, `README.md`, and `src/app.py` are expected in each app version. Complex apps can add additional modules under `src/` and import them from `app.py`. +- **Actions & wiring:** Every action in `api.yaml` must map to a method in `src/app.py` with the same name and argument list. Authentication parameters are passed into each action automatically when declared under `authentication:`. +- **Utility helpers:** In `AppBase`, you can use `self.get_file`, `self.set_files`, `self.update_file`, and cache helpers `self.get_cache`, `self.set_cache`, `self.delete_cache` for file and key/value workflows. +- **Prototyping:** Build and test your Python logic locally first, then wire it into `src/app.py`. Keep return values JSON‑serializable so Shuffle can consume them. +- **Upload & hotload:** After a prototype works, upload it to Shuffle (cloud) or hotload locally (on‑prem) by rebuilding the app image. Local Docker rebuilds are faster for iteration. + +## Testing, Hotloading, and CI/CD +- **Cloud upload test:** Use the Upload App API to add the app to your org, then run a workflow to validate actions. +- **Local hotload (on‑prem):** Place the app folder in `shuffle-apps/`, set `SHUFFLE_APP_HOTLOAD_FOLDER=./shuffle-apps`, then use the hot reload button in the UI. Allow ~20 seconds for the reload to complete. +- **Update workflow deps:** If you update an existing app version, remove and re‑add the app in any workflows that reference it. +- **Fast local iteration:** After the first upload, rebuild locally: `docker images | grep ` then `docker build . -t `. +- **CI/CD pattern:** Create a test workflow, upload a test app version, run the workflow via API, and validate `workflowexecution.workflow.validation.valid` before promoting. + +## Publishing Apps +- **OpenAPI apps:** Upload to your instance, then use the `/apps` page to publish so it appears on `shuffler.io`. +- **Python apps:** Fork `https://github.com/frikky/shuffle-apps`, add your app, and open a pull request to upstream. + +## Testing Guidelines +There is no repository-wide test suite. If you add tests for a specific app, keep them alongside the app version (e.g., `aws-ec2/1.0.0/tests/`) and document how to run them in that app’s `README.md`. + +## Commit & Pull Request Guidelines +Commit messages are short and descriptive, sometimes using a prefix like `fix:`. Follow that style and keep commits scoped to a single app/version when possible. + +For pull requests, include: + +- A clear description of the change and impacted app/version path. +- Updated `README.md` or `api.yaml` when behavior changes. +- Screenshots/assets if user-facing output or UI-related docs are affected. + +## Security & Configuration Tips +Many apps require API keys or credentials. Do not commit secrets; use environment variables or Shuffle configuration fields instead, and document required inputs in the app’s `README.md`. diff --git a/README.md b/README.md index 3ed3879d..a8f01df6 100644 --- a/README.md +++ b/README.md @@ -1,28 +1,28 @@ # Shuffle Apps -This is a repository for apps to be used in [Shuffle](https://github.com/frikky/shuffle) +All public apps are available in the search, engine either in your local instance or on [https://shuffler.io/search?tab=apps](https://shuffler.io/search). This is a repository for apps to be used in [Shuffle](https://github.com/shuffle/shuffle) -**PS:** These apps should be valid with WALKOFF, but the SDK is different, meaning you have to change the FIRST line in each Dockerfile (FROM frikky/shuffle:app_sdk). +**PS:** These apps should be valid with WALKOFF (from NSA), but the SDK is different, meaning you have to change the FIRST line in each Dockerfile (FROM shuffle/shuffle:app_sdk) to make it compatible with Shuffle. ## App Creation -App creation can be done with the Shuffle App Creator (exports as OpenAPI) or Python, which makes it possible to connect _literally_ any tool. Always prioritize using the App Creator when applicable. +App creation can be done with the Shuffle App Creator (exports as OpenAPI), with AI Generation, or Python - which makes it possible to connect _literally_ any tool. Always prioritize using the App Creator when applicable, as it makes maintaining an app easier. -![Shuffle-workflow-categories](https://github.com/frikky/shuffle-workflows/blob/master/images/categories_circle_dark.png) +![Shuffle-workflow-categories](https://github.com/shuffle/shuffle-workflows/blob/master/images/categories_circle_dark.png) ### References -* [App Development Process](https://github.com/frikky/shuffle-docs/blob/master/handbook/engineering/app_development.md) +* [App Development Process](https://github.com/shuffle/shuffle-docs/blob/master/handbook/engineering/app_development.md) * [Python app documentation](https://shuffler.io/docs/app_creation) -* [Apps in progress](https://github.com/frikky/Shuffle-apps/projects/1) +* [Apps in progress](https://github.com/shuffle/shuffle-apps/projects/1) ### Categories We have defined eight (8) "major" categories of tools that are necessary to any cybersecurity threat. Most security-related tools can fit into one of these eight. -1. [Communication](https://github.com/frikky/Shuffle-apps/issues/26) - Any way to chat; WhatsApp, SMS, Email etc. -2. [Case Management](https://github.com/frikky/Shuffle-apps/issues/22) - The central hub for operation teams. -3. [SIEM](https://github.com/frikky/Shuffle-apps/issues/21) - Search engine for logs in an enterprise. Used to find evil. -4. [Assets](https://github.com/frikky/Shuffle-apps/issues/25) - Discover endpoint information. Vulnerabilities, owners, departments etc. -5. [IAM](https://github.com/frikky/Shuffle-apps/issues/86) - Access Management. Active Directory, Google Workspaces, Single Sign-on etc. -6. [Intelligence](https://github.com/frikky/Shuffle-apps/issues/24) - Typically a vendor explaining what you should be looking for. -7. [Network](https://github.com/frikky/Shuffle-apps/issues/27) - Anything BETWEEN your connected devices. Firewalls, WAF, Switches, Bluetooth... -8. [Eradication](https://github.com/frikky/Shuffle-apps/issues/23) - Control machines directly to eradicate evil. Hard and undefined (EDR & AV) +1. [Communication](https://github.com/shuffle/shuffle-apps/issues/26) - Any way to chat; WhatsApp, SMS, Email etc. +2. [Case Management](https://github.com/shuffle/shuffle-apps/issues/22) - The central hub for operation teams. +3. [SIEM](https://github.com/shuffle/shuffle-apps/issues/21) - Search engine for logs in an enterprise. Used to find evil. +4. [Assets](https://github.com/shuffle/shuffle-apps/issues/25) - Discover endpoint information. Vulnerabilities, owners, departments etc. +5. [IAM](https://github.com/shuffle/shuffle-apps/issues/86) - Access Management. Active Directory, Google Workspaces, Single Sign-on etc. +6. [Intelligence](https://github.com/shuffle/shuffle-apps/issues/24) - Typically a vendor explaining what you should be looking for. +7. [Network](https://github.com/shuffle/shuffle-apps/issues/27) - Anything BETWEEN your connected devices. Firewalls, WAF, Switches, Bluetooth... +8. [Eradication](https://github.com/shuffle/shuffle-apps/issues/23) - Control machines directly to eradicate evil. Hard and undefined (EDR & AV) ## OpenAPI Apps in this repository are mostly manually made. Shuffle is striving for standardization and accessability, and our effort is focused on OpenAPI rather than manual work. With this in mind, most app creation that supports REST API's will be continued here. @@ -32,18 +32,18 @@ Apps in this repository are mostly manually made. Shuffle is striving for standa ## Support * [Discord](https://discord.gg/B2CBzUm) * [Twitter](https://twitter.com/shuffleio) -* [Email](mailto:frikky@shuffler.io) -* [Open issue](https://github.com/frikky/Shuffle/issues/new) +* [Email](mailto:support@shuffler.io) +* [Open issue](https://github.com/shuffle/shuffle/issues/new) * [Shuffler.io](https://shuffler.io/contact) ## External contributions -[**App magicians**](https://github.com/frikky/shuffle-apps) - - +[**App magicians**](https://github.com/shuffle/shuffle-apps) + + [**OpenAPI creators**](https://github.com/frikky/security-openapis) - + @@ -51,4 +51,4 @@ Apps in this repository are mostly manually made. Shuffle is striving for standa All apps, workflows and modular parts of Shuffle including our App SDK is under licensed under MIT, meaning you can freely use it anywhere in any way you want. # Contributing -Contributing guidelines for outlined [here](https://github.com/frikky/Shuffle/blob/master/.github/CONTRIBUTING.md). +Contributing guidelines for outlined [here](https://github.com/shuffle/shuffle/blob/master/.github/CONTRIBUTING.md). diff --git a/active-directory/1.0.0/README.md b/active-directory/1.0.0/README.md index ecb788b5..e99000f2 100644 --- a/active-directory/1.0.0/README.md +++ b/active-directory/1.0.0/README.md @@ -1,3 +1,30 @@ +# Active Directory +Active Directory is used all over the world for different reasons. This app helps you explore and control those users. It's based on an LDAP connection. + +## Authentication +* server: The IP or hostname to connect to +* port: The port to connect to. Default: 389 +* domain: Your CORP domain. Used to login properly together with your login_user +* login_user: Your username. DONT add CORP\\ in front +* password: The password of the user logging in. +* base_dn: The base DN found by running `Get-ADDomain` in powershell, then getting the value of the field "UsersContainer". Should NOT contain spaces. example: `OU=Users,DC=icplahd,DC=com` +* use_ssl: Whether to use SSL to connect to the default port. + +* search_base: Usually same as base_dn + +## Base DN +Finding the Base DN can be done by going to a Windows server in the domain. + +1. Open Powershell +2. Run +``` +Get-ADDomain +``` +3. Find the response from "UsersContainer" and use this for Base DN and Search Base + +## Typical issues +- InvalidCredentials: This happens when the credentials are wrong. See #authentication to understand if your format for your username/password is correct. + ## Features get user attributes -- done reset password -- done diff --git a/active-directory/1.0.0/api.yaml b/active-directory/1.0.0/api.yaml index 29d7ef63..187ed2eb 100644 --- a/active-directory/1.0.0/api.yaml +++ b/active-directory/1.0.0/api.yaml @@ -29,8 +29,8 @@ authentication: schema: type: string - name: domain - description: "Domain to BIND to AD/LDAP with" - example: "MYCOMPANY" + description: "Domain to BIND to AD/LDAP with. Should JUST be the NetBIOSName from Get-Addomain" + example: "ICPLAHD" required: true schema: type: string @@ -48,7 +48,7 @@ authentication: type: string - name: base_dn description: "Search Base DN" - example: "OU=Users,DC=mycompany,DC=com" + example: "OU=Users,DC=icplahd,DC=com" required: true schema: type: string @@ -56,6 +56,9 @@ authentication: description: "Use SSL Connection Security" required: true example: "True" + options: + - "true" + - "false" schema: type: string actions: @@ -166,10 +169,139 @@ actions: description: "If empty it will use the base_dn." required: false multiline: false - example: "OU=Users,DC=mycompany,DC=com" + example: "OU=Users,DC=icplahd,DC=com" + schema: + type: string + returns: + schema: + type: string + - name: lock_user + description: Lock User account + parameters: + - name: samaccountname + description: user to lock + required: true + multiline: false + example: 'user01' + schema: + type: string + - name: search_base + description: "If empty it will use the base_dn." + required: false + multiline: false + example: "OU=Users,DC=icplahd,DC=com" + schema: + type: string + returns: + schema: + type: string + - name: unlock_user + description: Unlock User account + parameters: + - name: samaccountname + description: user to unlock + required: true + multiline: false + example: 'user01' + schema: + type: string + - name: search_base + description: "If empty it will use the base_dn." + required: false + multiline: false + example: "OU=Users,DC=icplahd,DC=com" + schema: + type: string + returns: + schema: + type: string + - name: change_user_password_at_next_login + description: Set given password for user at next login + parameters: + - name: samaccountname + description: user to change password for + required: true + multiline: false + example: 'user01' + schema: + type: string + - name: search_base + description: "If empty it will use the base_dn." + required: false + multiline: false + example: "OU=Users,DC=icplahd,DC=com" + schema: + type: string + - name: new_user_password + description: "New password you want to set" + required: true + multiline: false + example: "***" + schema: + type: string + - name: repeat_new_user_password + description: "Repeat new password you want to set" + required: true + multiline: false + example: "***" + schema: + type: string + returns: + schema: + type: string + - name: add_user_to_group + description: Add user to group + parameters: + - name: samaccountname + description: user to change password for + required: true + multiline: false + example: 'user01' + schema: + type: string + - name: search_base + description: "If empty it will use the base_dn." + required: false + multiline: false + example: "OU=Users,DC=icplahd,DC=com" + schema: + type: string + - name: group_name + description: "Group you want to add user to" + required: true + multiline: false + example: "Group name" + schema: + type: string + returns: + schema: + type: string + - name: remove_user_from_group + description: Remove user from group + parameters: + - name: samaccountname + description: user to change password for + required: true + multiline: false + example: 'user01' + schema: + type: string + - name: search_base + description: "If empty it will use the base_dn." + required: false + multiline: false + example: "OU=Users,DC=icplahd,DC=com" + schema: + type: string + - name: group_name + description: "Group you want to remove user from" + required: true + multiline: false + example: "Group name" schema: type: string returns: schema: type: string -large_image: data:image/png;base64,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 + +large_image: data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAK4AAACuCAYAAACvDDbuAAAAAXNSR0IArs4c6QAAD6lJREFUeF7tnXmQFOUZh3+zO8fOzF5ccoioiIBcsRRQNOKREFAQAaNRMJRXhWi0Ek2iKWMlUVJWqlQ0sSxMJcGT0qLCciqKKBAUFTwW5FpYVFxYEISdY+eenk71zA47O85Ib3/b2927v/kHavd7v+/t533m7W96ZnptsizL4IMELEbARnEtVjGmmyZAcSmCJQlQXEuWjUlTXDpgSQIU15JlY9IUlw5YkgDFtWTZmDTFpQOWJEBxLVk2Jk1x6YAlCVBcS5aNSVNcOmBJAhTXkmVj0hSXDliSAMW1ZNmYNMWlA5YkQHEtWTYmTXHpgCUJUFxLlo1JU1w6YEkCFNeSZWPSFJcOWJIAxbVk2Zg0xaUDliRAcS1ZNiZNcemAJQlQXEuWjUlTXDpgSQIU15JlY9IUt5s4EEsBC+rC2B0CXhrrsfxRU1zLl7D1ABoiKaw7mkREkvHsvgh2hQofnDyr2vJHTXEtVsLGSAqBpIz3j8Uxb1sMkoa7G1NcixXdSukqQv5xRwjPf51EPAX4EzI0OFrwkCmulUwwWa7RaBSNkgN/3RNLd9CPjydwINo5SVLczuFs6VU2Ho1hWxD42h/Bcw1ASDL+cCiu8TUwXQbu5T5EU6ZLq01CFNfc9enw7NY0xnBHbRTNSSAqyUjIwMPDyzB/RNnJtcqW+6BcejLzg+KauToacvu4ScLf6iKIpICdvqSqPWe+uOy4GsBrCOlWl8PqgxJWHVFepctYfSSJ944nNSBrG8KOK4xQ0wRdSlxfQsbeoIS4JOGZ+hiWHNb/nM2Oq8k74aAuI66txicMQ8sE7LhaqInHUFxBhuy4ggA1hlNcjeCyYey4ggA1hlNcjeCKicurCoJAVYZTXJWgig1jxxUEqDGc4moEx62CIDjBcIorCJAvzgQBagynuBrBseMKghMMp7iCANlxBQFqDKe4GsGx4wqCEwynuIIA2XEFAWoMp7gawbHjCoITDKe4ggDZcQUBagynuBrBseMKghMMp7iCANlxBQFqDKe4GsEV7bjLmhCTbYKz6hvOr+7oy7dds5vl87j8kE27yqZ5MDuuZnSZQH7IRhCgxnCKqxFcsa0CO64gUJXhFFclqGLD2HEFAWoMp7gawbHjCoITDKe4ggDZcQUBagynuBrBFb0cxjvZCBJVF05x1XEqOoodVxCgxnCKqxEc97iC4ATDu4y4Rt1ozm4DSnPeKFNuwtxRN2AWrG3RcFeJXjN33rxdRtzOQ8aVzECA4pqhCsyh3QQobruRMcAMBLqMuI5lxtz07qFhZXgk58bORuXRHpkSM/nnotrDS9exZvl0mFF5tAcuP9bYHlo6jzVKmPzruEbl0R68FLc9tHQea5QwFFfnwhaZvsvscSmueoHYcdWz0n0kxVWPmOKqZ6X7SIqrHjHFVc9K95EUVz1iiquele4jKa56xBRXPSvdR1Jc9YgprnpWuo+kuOoRU1z1rHQfSXHVI6a46lnpPpLiqkdMcdWz0n0kxVWPmOKqZ6X7SIqrHjHFVc9K95EUVz1iiquele4jKa56xBRXPSvdR1Jc9YgprnpWuo+kuOoRU1z1rHQfSXHVI6a46lnpPpLiqkdMcdWz0n0kxVWPmOKqZ6X7SIqrHjHFVc9K95EUVz1iiquele4jKa56xBRXPSvdR5av8CMkdf7t5vK/5VtS4zP9Te8oru46al8gnJSxtUlCsyRjw9EEnt4fR1IHr/PFtS/zwYDnT7tAUdx24TLX4IZgHK80pnAiKqE2IOOdY0lNnTJfXOUWTHo8QTqSHsXtSJomm2ubX8LvtofQLNlwKJJCQ6Rwu84X17nMh4QOnb0j8VDcjqRpkbmUbYDi5crDCfx8awj3n1uG+Tk3vSvj34DolEp2mTvZdAotFYvs9idwOG5DSgZu3hLCt3HztV92XBWF5JBWArGUjBcOxHEkKqPWl8TKI8m04J39oLidTbyLr7f5SAiPfQGEJRm7/UkcietzwBRXH66ctQABWZYxf3cM8+ui6d9m99paYFFcLdQY06EEjkUl7A/LaE6k8MDnYXwWOPX0FPfUjDjCQAKJZBJrv5WxI5DCwVACL3ydRLMEUFwDi8KluzcBXg7r3vW37NFTXMuWrnsnTnG7d/0te/QU17Kl696JU9zuXX/LHj3FtWzpunfiFLd719+yR29acYe84Uf9NVUYstKPPdOrYAdQF5BwZnkp6kMpnOO2IWWzwQ4ZjlIbokkZss2GpV9GMWOgE7VhGRN7llq2MEz8+wmYVtznD8QxprcDA2wy+nhK0NSUQJ8eDuwISBhVWYoVhxOob05hXWMC/72sHO8dS2JrUxKTqkpwUX8njktAL3rbZf03tbgrvoph4ThvWly7DJz1VgCrL/GmxZ25uRmDK0qx5lACj4314t91EYyutmNGz4y4Z6wJoOHqyi5buO5+YKYVt7sXhsdv0a0CC0cC30eAHZd+WJIAxbVk2Zg0xaUDliTQ7cRVvqx465lOQ4p1LJzCrqiMy3l9WZi/JcTt/7ofR2IyDlxbhUEOm+qDrvVJOL+69WLuYV8CA94N6fINgEI33Xvz0nJM7qu8dZJ5jF4XSH8bQa9vIOwJSBjkLYGnVD0j1TBNNtD84sqAbZkPk3uWonelHa9c4FaNUJEpX5J4CnCWqJ5C9UBlrY0TKzCxd2n6FkxNEQmnvRnEDYNdWHJ+a87Klxz18krJYdGlFbitb9d/58X04u75No7z/hfG55d4MHpzuGC32vhNAo/vj+N0Twn+2SLJ4oY4btkaxivjPGn55pyR2R5c90EIKyZ44WtO4p49cbwyNvP77GPa5lD6TY7s477aMPaFZUzu58C9g4tvMXLFzcbubEpi1Prmkzm/3xjH2mYZjwx1pYfM/iiEReO9+NfeKNaekLBqQuu6d20JoSEJTOrrwK/PyVtXljHtg3B6jpfHedDDYUP2eH8xtAwTq0owppcDoz2tnVc5LuVx4yAH5g5snW/t11Ek3Hac77Fh3rYoXhvvwdyPw3h5vBfenCf4grooenvsmHtG6xlE9bNah4GmF1cRYvUVFZjasxTK/2unVOEHOQW5ZmMQa45LeHCoC182p7D0SBLJGVX46YchLG1M4PoBjkyBx3vhLkF6jmwXzu/IL+6L4tbPo21+f+MZTowuL8Gz+2JIOktwbEpFwTIUElcZqPz8ugFOLL/Yg5+tC2JJWIY8PfOOXlmNDxN621HXnMIQjw3vXF4BZSekxNw52IUBTmBxQwIuhw07r8qs+8ahBKZ+FMJvh7rSn994fG8MJ2ZU444tmeO9sJcdZ7lsaeHnne3Eq1/FMfvTMO471wWnDfhHfQxOVwl8Le8qXrMmAFdvO5Y3xNPjbxrixp2bAriknxMv5ZzdlJx2XV2F89zm2IaYWtyEJMO5wo/YzOo09KnvBlAv2VA3KVPEQFRC1RtBxGdWpwue/yi0Vcj9mXe5D9MHuvDq2Myp/KK1fozs7cSiC9wYuCaAclcJ9lxVfnJaJbZxejX6F2g6xcQ9Z6UPo/s4sHyCt6C4PdwlOJzz1vT1HzTjuGzDhpyur8wtzaqG0gCdNT48PNKNPw3LdO3cR6GtgvKzF8d5MLfljJN9Mr14aQXm9i2FIu6aSNt996t7I5i9I3byCfxNIIF+6/R5baC1GZta3OcPxPDQrtjJwm5qjGPih2GkZlVD8XTBvhge2BVF8rqqol0wf4+bK+6vaiNY+EUsPV+2oNm5y5f78PfzPZjZ0rGV3w9c7cfdI9x4YnhhabJ73Nxk+tX4cHH/4uIuHO/FbQMzZ4VsDnef58b8nO1Br9V+PHNJBe7plznrZHM8lbjBhIzKVf7vbK+Grvbhh/2dWHShJyNu0gb52rZnEmWd6KxqKEc6ZVMQI3o6sGBkmVbPOjzO1OIq8Jx2G4Z7Wjdb2wMSNk+uwgSvDU/ui2H+3hh8Uwt/mOZUHTcriiL3+gNRXPVJ6zZB6WwPDi/DlX3attehlaUY6Ppue/++rcIvh7mxcKSrYMctJO6cwWW4/fS2647tZUdl3lbnVOKeiMtQpM9/8k5cF8CQHvbvFXfue0HsTACfXFmRfrJ8c20VTmvHFZ0ONzX/7CIr9/Yx4UNKpmBfGcD6y1pP1Uqaf/g0hI9CcroY/9kfw53bIkUvL6kR113jw48GubDtaDx9Cp7Xco23zyo/Hhrlxn1nq7vmW0jcxV/GcMtnrfkV2uPmi9tvpQ/XD3Lh2ZwrEfnbgbeurMRPenz30kj+ViEmyShb4UfjtCr0V/ZaLQ97jQ/3DnPjqZGuoh1394kERmwIIT61As7Xg7pdwtOqnmk77twtIbzZlMLRyW1PYfuCEoa+HUTzjOr0q16lWC9f7MUtAxz4JpJCvzWBNi+utv64AhdWlqa3FrkdNgts6cE45nwSgVLk5KxqZC8kPbczjLvq4tg3pRJDWjr+pm+TuKx34VfVSh6Lx3kxtkcpTsRSWN8Qx0NfxLH4Ii9mn57ZCqgR99FdUfx5TxT1UypxTsu6G44lcUVL5x/3dgA7ozIC06pgtwF3fdiMeWO86asCSg5VHjt8U8pxMCpjYJkNfVf5YXOV4NCkivRluNfqI7h5e+v+tdhWIctK+fepsV78ZlDrdkarbB0ZZ1pxlSLcP8qDJ4d+t+OV1vjw2gQvbujvwBdBCee+HURKeQUP4NExbjw8JLMHve/TEJ7+KpH+f2BGNSqKnGqVtUpsgDQzs9fNPu7cEsKig4mTt9hXREnkjcmOLV3mOxmn5KGMjc5oO99N7wSxJCQjlXNV4bnxXtyas8dVJnl0exh/qY8XXTf370zk5hSVZHhW+NNxyt685uLM5bXc2/sr8iovdrNP0Kkte9xU3h5XiXt+Rwi3700gNLMaORdyOtI/zXOZVlzNR8TADiPwxLYQfr8/YbptQvpsYNY9bofR50SaCShnotevqMQ1PXV4q1FzVplAiisIsKuG+8MS5tRG0+8y6vUWtQg7iitCj7GGEaC4hqHnwiIEKK4IPcYaRoDiGoaeC4sQoLgi9BhrGAGKaxh6LixCgOKK0GOsYQQormHoubAIAYorQo+xhhGguIah58IiBCiuCD3GGkaA4hqGnguLEKC4IvQYaxgBimsYei4sQoDiitBjrGEEKK5h6LmwCAGKK0KPsYYRoLiGoefCIgQorgg9xhpGgOIahp4LixCguCL0GGsYAYprGHouLEKA4orQY6xhBCiuYei5sAgBiitCj7GGEaC4hqHnwiIEKK4IPcYaRoDiGoaeC4sQoLgi9BhrGAGKaxh6LixCgOKK0GOsYQQormHoubAIAYorQo+xhhGguIah58IiBCiuCD3GGkaA4hqGnguLEKC4IvQYaxgBimsYei4sQuD/UVLFb/ZiRHAAAAAASUVORK5CYII= diff --git a/active-directory/1.0.0/requirements.txt b/active-directory/1.0.0/requirements.txt index 840fb84b..ad59907e 100644 --- a/active-directory/1.0.0/requirements.txt +++ b/active-directory/1.0.0/requirements.txt @@ -1,2 +1,3 @@ -requests==2.25.1 -ldap3 +shuffle-sdk +ldap3==2.9.1 +pycryptodome diff --git a/active-directory/1.0.0/src/app.py b/active-directory/1.0.0/src/app.py index f61bdb1a..67f8ed2c 100644 --- a/active-directory/1.0.0/src/app.py +++ b/active-directory/1.0.0/src/app.py @@ -1,13 +1,23 @@ import json +import hashlib import ldap3 import asyncio -from ldap3 import ( - Server, - Connection, - MODIFY_REPLACE, - ALL_ATTRIBUTES, +from ldap3 import Server, Connection, MODIFY_REPLACE, ALL_ATTRIBUTES, NTLM + +try: + from Crypto.Hash import MD4 as CryptoMD4 +except ImportError: + CryptoMD4 = None + +from ldap3.extend.microsoft.addMembersToGroups import ( + ad_add_members_to_groups as addUsersInGroups, +) +from ldap3.extend.microsoft.removeMembersFromGroups import ( + ad_remove_members_from_groups as removeUsersFromGroups, ) -from walkoff_app_sdk.app_base import AppBase + +from shuffle_sdk import AppBase + class ActiveDirectory(AppBase): __version__ = "1.0.1" @@ -23,12 +33,28 @@ def __init__(self, redis, logger, console_logger=None): super().__init__(redis, logger, console_logger) def __ldap_connection(self, server, port, domain, login_user, password, use_ssl): - use_SSL = False if use_ssl.lower() == "false" else False + use_SSL = False if use_ssl.lower() == "false" else True login_dn = domain + "\\" + login_user s = Server(server, port=int(port), use_ssl=use_SSL) - c = Connection(s, user=login_dn, password=password, auto_bind=True) + if CryptoMD4 and not getattr(hashlib, "__active_directory_md4_patch__", False): + try: + import ldap3.utils.ntlm as ldap3_ntlm + + def _md4_hash(data): + md4 = CryptoMD4.new() + md4.update(data) + return md4.digest() + + ldap3_ntlm.hashlib.md4 = _md4_hash + hashlib.__active_directory_md4_patch__ = True + except Exception: + pass + + c = Connection( + s, user=login_dn, password=password, authentication=NTLM, auto_bind=True + ) return c # Decode UserAccountControl code @@ -124,16 +150,36 @@ def user_attributes( c = self.__ldap_connection(server, port, domain, login_user, password, use_ssl) - c.search( - search_base=base_dn, - search_filter=f"(samAccountName={samaccountname})", - attributes=ALL_ATTRIBUTES, - ) - result = json.loads(c.response_to_json())["entries"][0] - result["attributes"][ - "userAccountControl" - ] = self.__getUserAccountControlAttributes( - result["attributes"]["userAccountControl"] + try: + c.search( + search_base=base_dn, + search_filter=f"(samAccountName={samaccountname})", + attributes=ALL_ATTRIBUTES, + ) + + result = json.loads(c.response_to_json()) + if len(result["entries"]) == 0: + return json.dumps( + { + "success": False, + "result": result, + "reason": "No user found for %s" % samaccountname, + } + ) + + except Exception as e: + return json.dumps( + { + "success": False, + "reason": "Failed to get users in user attributes: %s" % e, + } + ) + + result = result["entries"][0] + result["attributes"]["userAccountControl"] = ( + self.__getUserAccountControlAttributes( + result["attributes"]["userAccountControl"] + ) ) return json.dumps(result) @@ -163,7 +209,19 @@ def set_password( server, port, domain, login_user, password, use_ssl ) - result = json.loads( self.user_attributes( server, port, domain, login_user, password, base_dn, use_ssl, samaccountname, search_base,)) + result = json.loads( + self.user_attributes( + server, + port, + domain, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, + ) + ) user_dn = result["dn"] c.extend.microsoft.modify_password(user_dn, new_password) @@ -226,7 +284,6 @@ def enable_user( samaccountname, search_base, ): - if search_base: base_dn = search_base @@ -245,6 +302,7 @@ def enable_user( search_base, ) ) + userAccountControl = result["attributes"]["userAccountControl"] if "ACCOUNTDISABLED" in userAccountControl: @@ -281,7 +339,6 @@ def disable_user( samaccountname, search_base, ): - if search_base: base_dn = search_base @@ -300,28 +357,230 @@ def disable_user( search_base, ) ) - userAccountControl = result["attributes"]["userAccountControl"] - if "ACCOUNTDISABLED" in userAccountControl: - result = {} - result["samAccountName"] = samaccountname - result["status"] = "success" - result["description"] = "Account already disable" + try: + userAccountControl = result["attributes"]["userAccountControl"] + except Exception as e: + return { + "success": False, + "reason": "Failed to get result attributes: %s" % e, + } - return json.dumps(result) + if "ACCOUNTDISABLED" in userAccountControl: + try: + result = {} + result["samAccountName"] = samaccountname + result["status"] = "success" + result["description"] = "Account already disable" + result["success"] = True + + return json.dumps(result) + except Exception as e: + return { + "success": False, + "reason": "Failed to send baseresult in disable user: %s" % e, + } else: - userAccountControl.append("ACCOUNTDISABLED") - userAccountControl_code = self.__getUserAccountControlCode( - userAccountControl - ) - new_userAccountControl = { - "userAccountControl": (MODIFY_REPLACE, userAccountControl_code) + try: + userAccountControl.append("ACCOUNTDISABLED") + userAccountControl_code = self.__getUserAccountControlCode( + userAccountControl + ) + new_userAccountControl = { + "userAccountControl": (MODIFY_REPLACE, userAccountControl_code) + } + user_dn = result["dn"] + c.modify(dn=user_dn, changes=new_userAccountControl) + c.result["samAccountName"] = samaccountname + + return json.dumps(c.result) + except Exception as e: + return { + "success": False, + "reason": "Failed adding ACCOUNTDISABLED to user: %s" % e, + } + + def lock_user( + self, + server, + domain, + port, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, + ): + if search_base: + base_dn = search_base + + c = self.__ldap_connection(server, port, domain, login_user, password, use_ssl) + + c.search(base_dn, f"(SAMAccountName={samaccountname})") + + if len(c.entries) == 0: + return {"success": "false", "message": f"User {samaccountname} not found"} + + user_dn = c.entries[0].entry_dn + + c.modify(user_dn, {"userAccountControl": [(MODIFY_REPLACE, [514])]}) + + result = c.result + result["success"] = True + + return result + + def unlock_user( + self, + server, + domain, + port, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, + ): + if search_base: + base_dn = search_base + + c = self.__ldap_connection(server, port, domain, login_user, password, use_ssl) + + c.search(base_dn, f"(SAMAccountName={samaccountname})") + + if len(c.entries) == 0: + return {"success": "false", "message": f"User {samaccountname} not found"} + + user_dn = c.entries[0].entry_dn + + c.modify(user_dn, {"userAccountControl": [(MODIFY_REPLACE, [0])]}) + + result = c.result + result["success"] = True + + return result + + def change_user_password_at_next_login( + self, + server, + domain, + port, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, + new_user_password, + repeat_new_user_password, + ): + if search_base: + base_dn = search_base + + if str(new_user_password) != str(repeat_new_user_password): + return { + "success": "false", + "message": "new_user_password and repeat_new_user_password does not match.", } - user_dn = result["dn"] - c.modify(dn=user_dn, changes=new_userAccountControl) - c.result["samAccountName"] = samaccountname - return json.dumps(c.result) + c = self.__ldap_connection(server, port, domain, login_user, password, use_ssl) + + c.search(base_dn, f"(SAMAccountName={samaccountname})") + + if len(c.entries) == 0: + return {"success": "false", "message": f"User {samaccountname} not found"} + + user_dn = c.entries[0].entry_dn + + c.modify(user_dn, {"pwdLastSet": (MODIFY_REPLACE, [0])}) + c.extend.microsoft.modify_password( + user_dn, new_user_password.encode("utf-16-le") + ) + + result = c.result + result["success"] = True + + return result + + def add_user_to_group( + self, + server, + domain, + port, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, + group_name, + ): + if search_base: + base_dn = search_base + + c = self.__ldap_connection(server, port, domain, login_user, password, use_ssl) + + c.search(base_dn, f"(SAMAccountName={samaccountname})") + if len(c.entries) == 0: + return {"success": "false", "message": f"User {samaccountname} not found"} + user_dn = c.entries[0].entry_dn + + search_filter = f"(&(objectClass=group)(cn={group_name}))" + c.search(base_dn, search_filter, attributes=["distinguishedName"]) + if len(c.entries) == 0: + return {"success": "false", "message": f"Group {group_name} not found"} + group_dn = c.entries[0]["distinguishedName"] + print(group_dn) + + res = addUsersInGroups(c, user_dn, str(group_dn), fix=True) + if res == True: + return { + "success": "true", + "message": f"User {samaccountname} was added to group {group_name}", + } + else: + return {"success": "false", "message": f"Could not add user to group"} + + def remove_user_from_group( + self, + server, + domain, + port, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, + group_name, + ): + if search_base: + base_dn = search_base + + c = self.__ldap_connection(server, port, domain, login_user, password, use_ssl) + + c.search(base_dn, f"(SAMAccountName={samaccountname})") + if len(c.entries) == 0: + return {"success": "false", "message": f"User {samaccountname} not found"} + + user_dn = c.entries[0].entry_dn + search_filter = f"(&(objectClass=group)(cn={group_name}))" + c.search(base_dn, search_filter, attributes=["distinguishedName"]) + if len(c.entries) == 0: + return {"success": "false", "message": f"Group {group_name} not found"} + + group_dn = c.entries[0]["distinguishedName"] + print(group_dn) + res = removeUsersFromGroups(c, user_dn, str(group_dn), fix=True) + if res == True: + return { + "success": "true", + "message": f"User {samaccountname} was removed from group {group_name}", + } + else: + return {"success": "false", "message": f"Could not remove user to group"} if __name__ == "__main__": diff --git a/active-directory/1.0.0/src/sample.py b/active-directory/1.0.0/src/sample.py new file mode 100644 index 00000000..0f4c778c --- /dev/null +++ b/active-directory/1.0.0/src/sample.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +import json +import ldap3 +import asyncio +from ldap3 import ( + Server, + Connection, + MODIFY_REPLACE, + ALL_ATTRIBUTES, +) +def __ldap_connection( server, port, domain, login_user, password, use_ssl): + use_SSL = False if use_ssl.lower() == "false" else False + login_dn = domain + "\\" + login_user + + s = Server(server, port=int(port), use_ssl=use_SSL) + c = Connection(s, user=login_dn, password=password, auto_bind=True) + + return c + +def __getUserAccountControlCode(input_attributes): + userAccountControlFlags = { + "TRUSTED_TO_AUTH_FOR_DELEGATION": 16777216, + "PASSWORD_EXPIRED": 8388608, + "DONT_REQ_PREAUTH": 4194304, + "USE_DES_KEY_ONLY": 2097152, + "NOT_DELEGATED": 1048576, + "TRUSTED_FOR_DELEGATION": 524288, + "SMARTCARD_REQUIRED": 262144, + "MNS_LOGON_ACCOUNT": 131072, + "DONT_EXPIRE_PASSWORD": 65536, + "SERVER_TRUST_ACCOUNT": 8192, + "WORKSTATION_TRUST_ACCOUNT": 4096, + "INTERDOMAIN_TRUST_ACCOUNT": 2048, + "NORMAL_ACCOUNT": 512, + "TEMP_DUPLICATED_ACCOUNT": 256, + "ENCRYPTED_TEXT_PWD_ALLOWED": 128, + "PASSWD_CANT_CHANGE": 64, + "PASSWD_NOTREQD": 32, + "LOCKOUT": 16, + "HOMEDIR_REQUIRED": 8, + "ACCOUNTDISABLED": 2, + "SCRIPT": 1, + } + code = 0 + for attribute in input_attributes: + code += userAccountControlFlags[attribute] + + return code + + +# Decode UserAccountControl code +def __getUserAccountControlAttributes(input_code): + userAccountControlFlags = { + 16777216: "TRUSTED_TO_AUTH_FOR_DELEGATION", + 8388608: "PASSWORD_EXPIRED", + 4194304: "DONT_REQ_PREAUTH", + 2097152: "USE_DES_KEY_ONLY", + 1048576: "NOT_DELEGATED", + 524288: "TRUSTED_FOR_DELEGATION", + 262144: "SMARTCARD_REQUIRED", + 131072: "MNS_LOGON_ACCOUNT", + 65536: "DONT_EXPIRE_PASSWORD", + 8192: "SERVER_TRUST_ACCOUNT", + 4096: "WORKSTATION_TRUST_ACCOUNT", + 2048: "INTERDOMAIN_TRUST_ACCOUNT", + 512: "NORMAL_ACCOUNT", + 256: "TEMP_DUPLICATED_ACCOUNT", + 128: "ENCRYPTED_TEXT_PWD_ALLOWED", + 64: "PASSWD_CANT_CHANGE", + 32: "PASSWD_NOTREQD", + 16: "LOCKOUT", + 8: "HOMEDIR_REQUIRED", + 2: "ACCOUNTDISABLED", + 1: "SCRIPT", + } + lists = [] + attributes = {} + while input_code > 0: + for flag, flagName in userAccountControlFlags.items(): + temp = input_code - flag + if temp > 0: + attributes[userAccountControlFlags[flag]] = flag + input_code = temp + if temp == 0: + try: + if userAccountControlFlags[input_code]: + attributes[userAccountControlFlags[input_code]] = input_code + except KeyError: + pass + input_code = temp + for key, val in attributes.items(): + lists.append(key) + return lists + + + +# Disable User +def disable_user( + +server, +port, + domain, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, +): + + if search_base: + base_dn = search_base + + c = __ldap_connection(server, port, domain, login_user, password, use_ssl) + + result = json.loads( + user_attributes( + server, + port, + domain, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, + ) + ) + userAccountControl = result["attributes"]["userAccountControl"] + + if "ACCOUNTDISABLED" in userAccountControl: + result = {} + result["samAccountName"] = samaccountname + result["status"] = "success" + result["description"] = "Account already disable" + + return json.dumps(result) + else: + userAccountControl.append("ACCOUNTDISABLED") + userAccountControl_code = __getUserAccountControlCode( + userAccountControl + ) + new_userAccountControl = { + "userAccountControl": (MODIFY_REPLACE, userAccountControl_code) + } + user_dn = result["dn"] + c.modify(dn=user_dn, changes=new_userAccountControl) + c.result["samAccountName"] = samaccountname + + return json.dumps(c.result) + +# Get User Attributes +def user_attributes( + + server, + port, + domain, + login_user, + password, + base_dn, + use_ssl, + samaccountname, + search_base, +): + if search_base: + base_dn = search_base + + c =__ldap_connection(server, port, domain, login_user, password, use_ssl) + + print(c, base_dn, samaccountname) + c.search( + search_base=base_dn, + search_filter=f"(samAccountName={samaccountname})", + attributes=ALL_ATTRIBUTES, + ) + + result = json.loads(c.response_to_json()) + print(result) + result = result["entries"][0] + result["attributes"]["userAccountControl"] = __getUserAccountControlAttributes( + result["attributes"]["userAccountControl"] + ) + + return json.dumps(result) + + +disable_user( + '172.17.12.5', + 389, + 'ICPLAHD', + 'administrator', + 'PW', + 'CN=Users,DC=icplahd,DC=local', + 'false', + 'administrator', + 'CN=Users,DC=icplahd,DC=local', +) diff --git a/ad-ldap/1.0.0/requirements.txt b/ad-ldap/1.0.0/requirements.txt deleted file mode 100644 index 840fb84b..00000000 --- a/ad-ldap/1.0.0/requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -requests==2.25.1 -ldap3 diff --git a/analyze.py b/analyze.py index 6512eb9e..714619f4 100644 --- a/analyze.py +++ b/analyze.py @@ -33,6 +33,9 @@ if ret["app_version"] != version: print("Bad version (%s): %s vs %s" % (basename, version, ret["app_version"])) + + if "svg" in ret["large_image"]: + print("Unsupported large_image format: svg") #else: # print("%s:%s is valid" % (basename, version)) except (NotADirectoryError, FileNotFoundError) as e: diff --git a/archive-org/1.0.0/requirements.txt b/archive-org/1.0.0/requirements.txt index 01635895..95feca5f 100644 --- a/archive-org/1.0.0/requirements.txt +++ b/archive-org/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 +requests==2.32.4 savepagenow==1.1.1 \ No newline at end of file diff --git a/archive-today/1.0.0/requirements.txt b/archive-today/1.0.0/requirements.txt index 150b17f3..1f5f6ba3 100644 --- a/archive-today/1.0.0/requirements.txt +++ b/archive-today/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 +requests==2.32.4 archiveis==0.0.9 \ No newline at end of file diff --git a/aws-cloudwatch/1.0.0/requirements.txt b/aws-cloudwatch/1.0.0/requirements.txt index 9c1b76e6..f41ce43e 100644 --- a/aws-cloudwatch/1.0.0/requirements.txt +++ b/aws-cloudwatch/1.0.0/requirements.txt @@ -1,2 +1,2 @@ boto3==1.20.20 -requests==2.25.1 +requests==2.32.4 diff --git a/aws-dynamodb/1.0.0/requirements.txt b/aws-dynamodb/1.0.0/requirements.txt index 97f3f4de..f66253b2 100644 --- a/aws-dynamodb/1.0.0/requirements.txt +++ b/aws-dynamodb/1.0.0/requirements.txt @@ -1,3 +1,3 @@ boto3==1.16.59 bson==0.5.10 -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/aws-dynamodb/1.0.0/src/app.py b/aws-dynamodb/1.0.0/src/app.py index 92a3c5ae..538be935 100644 --- a/aws-dynamodb/1.0.0/src/app.py +++ b/aws-dynamodb/1.0.0/src/app.py @@ -28,7 +28,7 @@ def auth_dynamodb(self, access_key, secret_key, region): signature_version = "dynamodbv4", retries = { 'max_attempts': 10, - 'mode': 'standard' + 'mode': 'standard', }, ) @@ -76,4 +76,4 @@ def get_backups(self, access_key, secret_key, region, table_name): return "Error: %s" % e if __name__ == "__main__": - AWSDynamoDB.run() \ No newline at end of file + AWSDynamoDB.run() diff --git a/aws-ec2/1.0.0/requirements.txt b/aws-ec2/1.0.0/requirements.txt index 9c1b76e6..f41ce43e 100644 --- a/aws-ec2/1.0.0/requirements.txt +++ b/aws-ec2/1.0.0/requirements.txt @@ -1,2 +1,2 @@ boto3==1.20.20 -requests==2.25.1 +requests==2.32.4 diff --git a/aws-guardduty/1.0.0/requirements.txt b/aws-guardduty/1.0.0/requirements.txt index f9c46b04..70356370 100644 --- a/aws-guardduty/1.0.0/requirements.txt +++ b/aws-guardduty/1.0.0/requirements.txt @@ -1,2 +1,3 @@ boto3==1.16.59 -requests==2.25.1 +requests==2.32.4 +shuffle_sdk diff --git a/aws-guardduty/1.0.0/src/app.py b/aws-guardduty/1.0.0/src/app.py index 5ee9bac2..f818584f 100644 --- a/aws-guardduty/1.0.0/src/app.py +++ b/aws-guardduty/1.0.0/src/app.py @@ -7,7 +7,9 @@ import botocore from botocore.config import Config -from walkoff_app_sdk.app_base import AppBase +#from walkoff_app_sdk.app_base import AppBase +from shuffle_sdk import AppBase + class AWSGuardduty(AppBase): __version__ = "1.0.0" @@ -152,6 +154,7 @@ def create_threat_intel_set(self, access_key, secret_key, region, detectorId, na return f"Error: {e}" def delete_threat_intel_set(self, access_key, secret_key, region, detectorId, threatIntelSetId): + client = self.auth_guardduty(access_key, secret_key, region) try: return client.delete_threat_intel_set( DetectorId = detectorId, @@ -161,6 +164,7 @@ def delete_threat_intel_set(self, access_key, secret_key, region, detectorId, th return f"Error: {e}" def get_threat_intel_set(self, access_key, secret_key, region, detectorId, threatIntelSetId): + client = self.auth_guardduty(access_key, secret_key, region) try: return client.get_threat_intel_set( DetectorId = detectorId, @@ -183,7 +187,7 @@ def update_threat_intel_set(self, access_key, secret_key, region, detectorId, th try: return client.update_threat_intel_set( DetectorId = detectorId, - IpSetId = ipSetId, + ThreatIntelSetId = threatIntelSetId, Name = name, Location = location, Activate = bool(activate) diff --git a/aws-iam/1.0.0/api.yaml b/aws-iam/1.0.0/api.yaml index ec2615f3..5ffaf18e 100644 --- a/aws-iam/1.0.0/api.yaml +++ b/aws-iam/1.0.0/api.yaml @@ -9,8 +9,7 @@ tags: - Access - Users categories: - - Access - - Users + - IAM authentication: required: true parameters: diff --git a/aws-iam/1.0.0/requirements.txt b/aws-iam/1.0.0/requirements.txt index 06ef1c78..e2a84f1d 100644 --- a/aws-iam/1.0.0/requirements.txt +++ b/aws-iam/1.0.0/requirements.txt @@ -1,2 +1,2 @@ boto3==1.16.59 -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/aws-lambda/1.0.0/requirements.txt b/aws-lambda/1.0.0/requirements.txt index f9c46b04..423ace70 100644 --- a/aws-lambda/1.0.0/requirements.txt +++ b/aws-lambda/1.0.0/requirements.txt @@ -1,2 +1,2 @@ boto3==1.16.59 -requests==2.25.1 +requests==2.32.4 diff --git a/aws-s3/1.0.0/requirements.txt b/aws-s3/1.0.0/requirements.txt index 00eb0244..8c127e25 100644 --- a/aws-s3/1.0.0/requirements.txt +++ b/aws-s3/1.0.0/requirements.txt @@ -1,3 +1,3 @@ boto3==1.16.59 bson==0.5.10 -requests==2.25.1 +requests==2.32.4 diff --git a/aws-securityhub/1.0.0/requirements.txt b/aws-securityhub/1.0.0/requirements.txt index 06ef1c78..e2a84f1d 100644 --- a/aws-securityhub/1.0.0/requirements.txt +++ b/aws-securityhub/1.0.0/requirements.txt @@ -1,2 +1,2 @@ boto3==1.16.59 -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/aws-ses/1.0.0/requirements.txt b/aws-ses/1.0.0/requirements.txt index d46a14e7..216ec100 100644 --- a/aws-ses/1.0.0/requirements.txt +++ b/aws-ses/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 +requests==2.32.4 boto3==1.16.59 \ No newline at end of file diff --git a/aws-waf/1.0.0/requirements.txt b/aws-waf/1.0.0/requirements.txt index f9c46b04..423ace70 100644 --- a/aws-waf/1.0.0/requirements.txt +++ b/aws-waf/1.0.0/requirements.txt @@ -1,2 +1,2 @@ boto3==1.16.59 -requests==2.25.1 +requests==2.32.4 diff --git a/aws-waf/1.0.0/src/app.py b/aws-waf/1.0.0/src/app.py index 437a8acf..fcaeb0bc 100644 --- a/aws-waf/1.0.0/src/app.py +++ b/aws-waf/1.0.0/src/app.py @@ -1,3 +1,4 @@ +import sys import socket import asyncio import time diff --git a/azure-sentinel/1.0.0/api.yaml b/azure-sentinel/1.0.0/api.yaml deleted file mode 100644 index 7e8e1424..00000000 --- a/azure-sentinel/1.0.0/api.yaml +++ /dev/null @@ -1,269 +0,0 @@ -app_version: 1.0.0 -name: Azure Sentinel -description: Azure Sentinel Incidents -contact_info: - name: "@pemontto" - url: https://github.com/pemontto - email: "" -tags: - - SIEM - - Ticketing -categories: - - SIEM - - Ticketing -authentication: - required: true - parameters: - - name: tenant_id - description: The tenant of the OAuth client - example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" - multiline: false - required: true - schema: - type: string - - name: client_id - description: The client id to use - example: "*****" - multiline: false - required: true - schema: - type: string - - name: client_secret - description: The secret key to use - multiline: false - example: "*****" - required: true - schema: - type: string - - name: subscription_id - description: The subscription for Azure Sentinel - multiline: false - example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" - required: true - schema: - type: string - - name: resource_group_name - description: The resource group for Azure Sentinel - multiline: false - example: "SentinelResourceGroupName" - required: true - schema: - type: string - - name: workspace_name - description: The workspace name for Azure Sentinel - multiline: false - example: "SentinelWorkspace" - required: true - schema: - type: string -actions: - - name: get_incidents - description: Get incidents - parameters: - # - name: severity - # description: Comma separated list of severities to be exported - # multiline: false - # example: "High,Medium,Low,Informational" - # required: false - # schema: - # type: string - - name: status - description: Comma separated list of statuses to be exported - multiline: false - example: "New,Active,Closed" - # options: - # - New - # - Active - # - Closed - required: false - schema: - type: string - - name: last_modified - description: Only get events modified since this time (UTC) - multiline: false - example: "2021-01-23T01:30:00" - required: false - schema: - type: string - # - name: lookback - # description: Export events modified after this time period (d=days, h=hours, m=minutes) - # multiline: false - # example: "6h" - # required: false - # schema: - # type: string - - name: get_entities - description: "Include incident entites in output (default: false)" - multiline: false - options: - - True - - False - required: false - schema: - type: string - - name: get_comments - description: "Include incident comments in output (default: false)" - multiline: false - options: - - True - - False - required: false - schema: - type: string - returns: - schema: - type: string - - name: get_incident - description: Get incident - parameters: - - name: incident_id - description: The incident ID to get - multiline: false - example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" - required: true - schema: - type: string - - name: get_entities - description: "Include incident entites in output (default: false)" - multiline: false - options: - - True - - False - required: false - schema: - type: string - - name: get_comments - description: "Include incident comments in output (default: false)" - multiline: false - options: - - True - - False - required: false - schema: - type: string - returns: - schema: - type: string - - name: close_incident - description: | - Close an incident - parameters: - - name: incident_id - description: The incident ID to close - multiline: false - example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" - required: true - schema: - type: string - - name: close_reason - description: The close reason - required: true - multiline: false - options: - - Undetermined - - TruePositive - SuspiciousActivity - - BenignPositive - SuspiciousButExpected - - FalsePositive - IncorrectAlertLogic - - FalsePositive - InaccurateData - schema: - type: string - - name: close_comment - description: The close comment - required: false - multiline: false - example: "Incident investigated!" - schema: - type: string - returns: - schema: - type: string - - name: update_incident - description: | - Update an incident - parameters: - - name: incident_id - description: The incident ID to close - multiline: false - example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" - required: true - schema: - type: string - - name: severity - description: The incident severity - required: false - multiline: false - options: - - Informational - - Low - - Medium - - High - schema: - type: string - - name: status - description: The incident status - required: false - multiline: false - options: - - New - - Active - schema: - type: string - - name: owner - description: The user principal name of the incident owner - required: false - multiline: false - example: john.smith@example.com - schema: - type: string - returns: - schema: - type: string - - name: add_comment - description: Add comment to incident - parameters: - - name: incident_id - description: The incident ID to close - multiline: false - example: "1031" - required: true - schema: - type: string - - name: comment - description: The comment to add - multiline: false - example: "This is an example comment" - required: true - schema: - type: string - returns: - schema: - type: string - - name: run_query - description: Runs a KQL query in your tenant - parameters: - - name: query - description: The query to run - multiline: true - example: "SecurityEvent | where EventID == \"4688\" | where CommandLine contains \"-noni -ep bypass $\"" - required: true - schema: - type: string - - name: query_category - description: The comment to add - multiline: false - example: "Hunting Queries" - required: true - schema: - type: string - - name: query_name - description: The name to use for the query - multiline: false - example: "HuntingRule02" - required: true - schema: - type: string - returns: - returns: - schema: - type: string -large_image: data:image/svg+xml;base64,PHN2ZyBpZD0iYTc1ZTNmM2EtMjY2MS00MTBiLTgyZmItZDMwMGQzN2RlYTJkIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxOCIgaGVpZ2h0PSIxOCIgdmlld0JveD0iMCAwIDE4IDE4Ij48ZGVmcz48bGluZWFyR3JhZGllbnQgaWQ9ImFmZjYwZGRmLWVlYzEtNDBiZi04YmY1LWYzZTNiNTBlODgxOCIgeDE9IjkiIHkxPSIxNi4yMSIgeDI9IjkiIHkyPSIwLjYyIiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSI+PHN0b3Agb2Zmc2V0PSIwIiBzdG9wLWNvbG9yPSIjMWI5M2ViIiAvPjxzdG9wIG9mZnNldD0iMC4yMSIgc3RvcC1jb2xvcj0iIzIwOTVlYiIgLz48c3RvcCBvZmZzZXQ9IjAuNDQiIHN0b3AtY29sb3I9IiMyZTljZWQiIC8+PHN0b3Agb2Zmc2V0PSIwLjY5IiBzdG9wLWNvbG9yPSIjNDVhN2VmIiAvPjxzdG9wIG9mZnNldD0iMC45NSIgc3RvcC1jb2xvcj0iIzY0YjZmMSIgLz48c3RvcCBvZmZzZXQ9IjEiIHN0b3AtY29sb3I9IiM2YmI5ZjIiIC8+PC9saW5lYXJHcmFkaWVudD48L2RlZnM+PHRpdGxlPkljb24tc2VjdXJpdHktMjQ4PC90aXRsZT48cGF0aCBkPSJNMTYsOC40NGMwLDQuNTctNS41Myw4LjI1LTYuNzMsOWEuNDMuNDMsMCwwLDEtLjQ2LDBDNy41NywxNi42OSwyLDEzLDIsOC40NFYyLjk0YS40NC40NCwwLDAsMSwuNDMtLjQ0QzYuNzcsMi4zOSw1Ljc4LjUsOSwuNXMyLjIzLDEuODksNi41MywyYS40NC40NCwwLDAsMSwuNDMuNDRaIiBmaWxsPSIjMWI5M2ViIiAvPjxwYXRoIGQ9Ik0xNS4zOCw4LjQ4YzAsNC4yLTUuMDcsNy41Ny02LjE3LDguMjVhLjQuNCwwLDAsMS0uNDIsMGMtMS4xLS42OC02LjE3LTQuMDUtNi4xNy04LjI1di01QS40MS40MSwwLDAsMSwzLDNjMy45NC0uMTEsMy0xLjgzLDYtMS44M1MxMS4wNSwyLjkzLDE1LDNhLjQxLjQxLDAsMCwxLC4zOS40WiIgZmlsbD0idXJsKCNhZmY2MGRkZi1lZWMxLTQwYmYtOGJmNS1mM2UzYjUwZTg4MTgpIiAvPjxwYXRoIGQ9Ik05LDYuNTNBMi44OCwyLjg4LDAsMCwxLDExLjg0LDlhLjQ5LjQ5LDAsMCwwLC40OS40aDEuNGEuNDkuNDksMCwwLDAsLjUtLjUzLDUuMjYsNS4yNiwwLDAsMC0xMC40NiwwLC40OS40OSwwLDAsMCwuNS41M2gxLjRBLjQ5LjQ5LDAsMCwwLDYuMTYsOSwyLjg4LDIuODgsMCwwLDEsOSw2LjUzWiIgZmlsbD0iI2MzZjFmZiIgLz48Y2lyY2xlIGN4PSI5IiBjeT0iOS40IiByPSIxLjkxIiBmaWxsPSIjZmZmIiAvPjwvc3ZnPg== diff --git a/azure-sentinel/1.0.0/requirements.txt b/azure-sentinel/1.0.0/requirements.txt deleted file mode 100644 index 153ab3a1..00000000 --- a/azure-sentinel/1.0.0/requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -uuid==1.30 -requests==2.25.1 \ No newline at end of file diff --git a/azure-sentinel/1.0.0/src/app.py b/azure-sentinel/1.0.0/src/app.py deleted file mode 100644 index 88ccb9da..00000000 --- a/azure-sentinel/1.0.0/src/app.py +++ /dev/null @@ -1,284 +0,0 @@ -import socket -import asyncio -import time -import json -import uuid -import requests - -from walkoff_app_sdk.app_base import AppBase - - -class AzureSentinel(AppBase): - __version__ = "1.0.0" - app_name = "Azure Sentinel" - - def __init__(self, redis, logger, console_logger=None): - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - self.azure_url = "https://management.azure.com" - - def authenticate(self, tenant_id, client_id, client_secret): - - self.s = requests.Session() - auth_url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token" - auth_data = { - "grant_type": "client_credentials", - "client_id": client_id, - "client_secret": client_secret, - "scope": f"{self.azure_url}/.default", - } - auth_headers = { - "Content-Type": "application/x-www-form-urlencoded", - "cache-control": "no-cache", - } - - self.logger.debug(f"Making request to: {auth_url}") - res = self.s.post(auth_url, data=auth_data, headers=auth_headers) - - # Auth failed, raise exception with the response - if res.status_code != 200: - raise ConnectionError(res.text) - - access_token = res.json().get("access_token") - self.s.headers = {"Authorization": f"Bearer {access_token}", "cache-control": "no-cache"} - - def extract_entities(self, incident_uri): - - entities_url = f"{self.azure_url}{incident_uri}/entities" - params = {"api-version": "2019-01-01-preview"} - self.logger.debug(f"Making request to: {entities_url}") - res = self.s.post(entities_url, params=params) - if res.status_code != 200: - self.logger.error(f"Failed to get entities for {incident_uri}") - - return res.json().get("entities", []) - - def extract_comments(self, incident_uri): - - comments_url = f"{self.azure_url}{incident_uri}/comments" - params = {"api-version": "2020-01-01"} - self.logger.debug(f"Making request to: {comments_url}") - res = self.s.get(comments_url, params=params) - if res.status_code != 200: - self.logger.error(f"Failed to get comments for {incident_uri}") - - return res.json().get("value", []) - - def get_incidents(self, **kwargs): - - # Get a client credential access token - self.authenticate(kwargs["tenant_id"], kwargs["client_id"], kwargs["client_secret"]) - - incidents_url = f"{self.azure_url}/subscriptions/{kwargs['subscription_id']}/resourceGroups/{kwargs['resource_group_name']}/providers/Microsoft.OperationalInsights/workspaces/{kwargs['workspace_name']}/providers/Microsoft.SecurityInsights/incidents" - params = {"api-version": "2020-01-01"} - - query_filter = "" - # Add filter for statuses - if kwargs["status"]: - status_filters = [ - f"properties/status eq '{x.strip()}'" for x in kwargs["status"].split(",") - ] - query_filter = f"( {' or '.join(status_filters)} )" - self.logger.debug(f"Adding query filter for status: {query_filter}") - - # Add filter for last modified - if kwargs["last_modified"]: - last_modified = f"(properties/lastModifiedTimeUtc ge {kwargs['last_modified']}Z)" - if query_filter: - query_filter = f"{query_filter} and {last_modified}" - else: - query_filter = last_modified - self.logger.debug(f"Adding query filter for last_modified: {query_filter}") - - if query_filter: - params["$filter"] = query_filter - - incidents = [] - self.logger.info(f"Making request to: {incidents_url}") - res = self.s.get(incidents_url, params=params) - if res.status_code != 200: - raise ConnectionError(res.text) - incidents += res.json()["value"] - - while "nextLink" in res.json(): - self.logger.info(f"Making request to nextLink: {res.json()['nextLink']}") - res = self.s.get(res.json()["nextLink"]) - if res.status_code != 200: - raise ConnectionError(res.text) - incidents += res.json()["value"] - - - self.logger.info(f"Making request to: {incidents_url}") - res = self.s.get(incidents_url, params=params) - if res.status_code != 200: - raise ConnectionError(res.text) - incidents = res.json()["value"] - - # Get incident entities - if kwargs.get("get_entities", "").lower() == "true": - for incident in incidents: - self.logger.warning(f"Getting entities for {incident['id']}") - incident["entities"] = self.extract_entities(incident["id"]) - - # Get incident comments - if kwargs.get("get_comments", "").lower() == "true": - for incident in incidents: - self.logger.warning(f"Getting entities for {incident['id']}") - incident["comments"] = self.extract_comments(incident["id"]) - - return json.dumps(incidents) - - def get_incident(self, **kwargs): - - if not kwargs.get("incident_id"): - return '{"success": false, "error": "No incident ID supplied"}' - - # Get a client credential access token - auth = self.authenticate( - kwargs["tenant_id"], kwargs["client_id"], kwargs["client_secret"] - ) - - incident_url = f"{self.azure_url}/subscriptions/{kwargs['subscription_id']}/resourceGroups/{kwargs['resource_group_name']}/providers/Microsoft.OperationalInsights/workspaces/{kwargs['workspace_name']}/providers/Microsoft.SecurityInsights/incidents/{kwargs['incident_id']}" - params = {"api-version": "2020-01-01"} - - res = self.s.get(incident_url, params=params) - if res.status_code != 200: - raise ConnectionError(res.text) - incident = res.json() - - # Get incident entities - if kwargs.get("get_entities", "").lower() == "true": - incident["entities"] = self.extract_entities(incident["id"]) - - # Get incident comments - if kwargs.get("get_comments", "").lower() == "true": - incident["comments"] = self.extract_comments(incident["id"]) - - return json.dumps(incident) - - def close_incident(self, **kwargs): - incident = json.loads(self.get_incident(**kwargs)) - if "error" in incident: - return json.dumps(incident) - - # Get classification and classificationReason - close_reason = [x.strip() for x in kwargs["close_reason"].split("-")] - - close_data = { - "etag": incident.get("etag", "").strip('"'), - "properties": { - "title": incident["properties"]["title"], - "status": "Closed", - "severity": incident["properties"]["severity"], - "classification": close_reason[0], - "classificationComment": kwargs["close_comment"], - }, - } - if len(close_reason) > 1: - close_data["properties"]["classificationReason"] = close_reason[1] - - incident_url = f"{self.azure_url}/subscriptions/{kwargs['subscription_id']}/resourceGroups/{kwargs['resource_group_name']}/providers/Microsoft.OperationalInsights/workspaces/{kwargs['workspace_name']}/providers/Microsoft.SecurityInsights/incidents/{kwargs['incident_id']}" - params = {"api-version": "2020-01-01"} - - res = self.s.put(incident_url, json=close_data, params=params) - if res.status_code != 200: - raise ConnectionError(res.text) - - return res.text - - def update_incident(self, **kwargs): - incident = json.loads(self.get_incident(**kwargs)) - if "error" in incident: - return json.dumps(incident) - - update_data = { - "etag": incident.get("etag", "").strip('"'), - "properties": { - "title": incident["properties"]["title"], - "severity": incident["properties"]["severity"], - }, - } - if kwargs["severity"]: - update_data["properties"]["severity"] = kwargs["severity"] - - if kwargs["status"]: - update_data["properties"]["status"] = kwargs["status"] - - if kwargs["owner"]: - update_data["properties"]["owner"] = {"userPrincipalName": kwargs["owner"]} - - incident_url = f"{self.azure_url}/subscriptions/{kwargs['subscription_id']}/resourceGroups/{kwargs['resource_group_name']}/providers/Microsoft.OperationalInsights/workspaces/{kwargs['workspace_name']}/providers/Microsoft.SecurityInsights/incidents/{kwargs['incident_id']}" - params = {"api-version": "2020-01-01"} - - res = self.s.put(incident_url, json=update_data, params=params) - if res.status_code != 200: - raise ConnectionError(res.text) - - return res.text - - def add_comment(self, **kwargs): - - # Get a client credential access token - auth = self.authenticate( - kwargs["tenant_id"], kwargs["client_id"], kwargs["client_secret"] - ) - if not auth["success"]: - return {"error": auth["message"]} - - comment_url = f"{self.azure_url}/subscriptions/{kwargs['subscription_id']}/resourceGroups/{kwargs['resource_group_name']}/providers/Microsoft.OperationalInsights/workspaces/{kwargs['workspace_name']}/providers/Microsoft.SecurityInsights/incidents/{kwargs['incident_id']}/comments" - params = {"api-version": "2020-01-01"} - - comment_id = str(uuid.uuid4()) - comment_data = {"properties": {"message": kwargs["comment"]}} - - res = self.s.put(f"{comment_url}/{comment_id}", json=comment_data, params=params) - if res.status_code != 200: - raise ConnectionError(res.text) - - return res.text - - def run_query(self, **kwargs): - # Get a client credential access token - auth = self.authenticate( - kwargs["tenant_id"], kwargs["client_id"], kwargs["client_secret"] - ) - - if not auth["success"]: - return {"error": auth["message"]} - - query_url = f"{self.azure_url}/subscriptions/{kwargs['subscription_id']}/resourceGroups/{kwargs['resource_group_name']}/providers/Microsoft.OperationalInsights/workspaces/{kwargs['workspace_name']}/savedSearches" - - #providers/Microsoft.SecurityInsights/incidents/{kwargs['incident_id']}/comments" - - #PUT https://management.azure.com/subscriptions/{subscriptionId} _ - #/resourcegroups/{resourceGroupName} _ - #/providers/Microsoft.OperationalInsights/workspaces/{workspaceName} _ - #/savedSearches/{savedSearchId}?api-version=2020-03-01-preview - - - params = {"api-version": "2020-01-01"} - - comment_id = str(uuid.uuid4()) - comment_data = { - "properties": { - "Category": kwargs["query_category"], - "DisplayName": kwargs["query_name"], - "Query": kwargs['query'], - } - } - - - res = self.s.put(f"{comment_url}/{comment_id}", json=comment_data, params=params) - if res.status_code != 200: - raise ConnectionError(res.text) - - return res.text - - -if __name__ == "__main__": - AzureSentinel.run() diff --git a/breachsense/1.0.0/api.yaml b/breachsense/1.0.0/api.yaml index 6c54e6f9..32ea3a8f 100644 --- a/breachsense/1.0.0/api.yaml +++ b/breachsense/1.0.0/api.yaml @@ -9,7 +9,7 @@ tags: - Darkweb - Data breach Monitor categories: - - Testing + - Assets authentication: required: true parameters: diff --git a/breachsense/1.0.0/requirements.txt b/breachsense/1.0.0/requirements.txt index fd7d3e06..480d0c4b 100644 --- a/breachsense/1.0.0/requirements.txt +++ b/breachsense/1.0.0/requirements.txt @@ -1 +1 @@ -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/checkpoint/1.0.0/api.yaml b/checkpoint/1.0.0/api.yaml index 997eb2a5..395d8dd7 100644 --- a/checkpoint/1.0.0/api.yaml +++ b/checkpoint/1.0.0/api.yaml @@ -8,7 +8,7 @@ contact_info: tags: - Firewall categories: - - Testing + - Network authentication: required: true parameters: diff --git a/checkpoint/1.0.0/requirements.txt b/checkpoint/1.0.0/requirements.txt index fd7d3e06..480d0c4b 100644 --- a/checkpoint/1.0.0/requirements.txt +++ b/checkpoint/1.0.0/requirements.txt @@ -1 +1 @@ -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/cortex/1.0.0/api.yaml b/cortex/1.0.0/api.yaml index b1a94ca7..8ffd05ab 100644 --- a/cortex/1.0.0/api.yaml +++ b/cortex/1.0.0/api.yaml @@ -7,8 +7,7 @@ tags: - Threat intel - Search categories: - - Threat intel - - Search + - Intel contact_info: name: "@frikkylikeme" url: https://github.com/frikky diff --git a/cortex/1.0.0/requirements.txt b/cortex/1.0.0/requirements.txt index 1f296044..fbca76ef 100644 --- a/cortex/1.0.0/requirements.txt +++ b/cortex/1.0.0/requirements.txt @@ -1,3 +1,3 @@ -requests==2.25.1 +requests==2.32.4 python-magic==0.4.18 cortex4py==2.0.1 diff --git a/cylance/1.0.0/requirements.txt b/cylance/1.0.0/requirements.txt deleted file mode 100644 index d7aa9605..00000000 --- a/cylance/1.0.0/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -cryptography==3.3.2 -requests==2.25.1 -PyJWT==1.7.1 diff --git a/databasemanager/1.0.0/api.yaml b/databasemanager/1.0.0/api.yaml index 43faa4cf..7e405a13 100644 --- a/databasemanager/1.0.0/api.yaml +++ b/databasemanager/1.0.0/api.yaml @@ -10,7 +10,7 @@ tags: - SQL - PostgreSQL categories: - - Testing + - Other actions: - name: query_mysql_database description: Query MySQL database diff --git a/databasemanager/1.0.0/requirements.txt b/databasemanager/1.0.0/requirements.txt index fcb1a934..3edf3f44 100644 --- a/databasemanager/1.0.0/requirements.txt +++ b/databasemanager/1.0.0/requirements.txt @@ -1,3 +1,3 @@ -requests==2.25.1 -mysql-connector-python==8.0.26 +requests==2.32.4 +mysql-connector-python==9.1.0 diff --git a/email/1.1.0/api.yaml b/email/1.1.0/api.yaml deleted file mode 100644 index 7259f92f..00000000 --- a/email/1.1.0/api.yaml +++ /dev/null @@ -1,253 +0,0 @@ -walkoff_version: 1.1.0 -app_version: 1.1.0 -name: email -description: Email app -tags: - - email -categories: - - communication -contact_info: - name: "@frikkylikeme" - url: https://github.com/frikky - email: "frikky@shuffler.io" -actions: - - name: send_email_shuffle - description: Send an email from Shuffle - parameters: - - name: apikey - description: Your https://shuffler.io apikey - multiline: false - example: "https://shuffler.io apikey" - required: true - schema: - type: string - - name: recipients - description: The recipients of the email - multiline: false - example: "test@example.com,frikky@shuffler.io" - required: true - schema: - type: string - - name: subject - description: The subject to use - multiline: false - example: "SOS this is an alert :o" - required: true - schema: - type: string - - name: body - description: The body to add to the email - multiline: true - example: "This is an email alert from Shuffler.io :)" - required: true - schema: - type: string - returns: - schema: - type: string - - name: send_email_smtp - description: Send an email with SMTP - parameters: - - name: username - description: The SMTP login username - multiline: false - example: "frikky@shuffler.io" - required: true - schema: - type: string - - name: password - description: The password to log in with SMTP - multiline: false - example: "******************" - required: true - schema: - type: string - - name: smtp_host - description: The host of the SMTP - multiline: false - example: "smtp-mail.outlook.com" - required: true - schema: - type: string - - name: smtp_port - description: The port to use for SMTP - multiline: false - example: "587" - required: true - schema: - type: string - - name: recipient - description: The receiver(s) of the email - multiline: false - example: "frikky@shuffler.io,frikky@shuffler.io" - required: true - schema: - type: string - - name: subject - description: The subject of the email - multiline: false - example: "This is a subject, hello there :)" - required: true - schema: - type: string - - name: body - description: The body to add to the email - multiline: true - example: "This is an email alert from Shuffler.io :)" - required: true - schema: - type: string - - name: attachments - description: Send files from shuffle as part of the email - multiline: false - example: "file_id1,file_id2,file_id3" - required: false - schema: - type: string - - name: ssl_verify - description: Whether to use TLS or not - example: "true" - required: false - options: - - true - - false - schema: - type: string - returns: - schema: - type: string - - name: get_emails_imap - description: Get emails using IMAP (e.g. imap.gmail.com / Outlook.office365.com) - parameters: - - name: username - description: The SMTP login username - multiline: false - example: "frikky@shuffler.io" - required: true - schema: - type: string - - name: password - description: The password to log in with SMTP - multiline: false - example: "******************" - required: true - schema: - type: string - - name: imap_server - description: The imap server host - multiline: false - example: "Outlook.office365.com" - required: true - schema: - type: string - - name: foldername - description: The folder to use, e.g. "inbox" - multiline: false - example: "inbox" - required: true - schema: - type: string - - name: amount - description: Amount of emails to retrieve - multiline: false - example: "10" - required: true - schema: - type: string - - name: unread - description: Retrieve just unread emails - multiline: false - options: - - "false" - - "true" - required: true - schema: - type: bool - - name: fields - description: Comma separated list of fields to be exported - multiline: false - example: "body, header.subject, header.header.message-id" - required: false - schema: - type: string - - name: include_raw_body - description: Include raw body in email export - multiline: false - options: - - "false" - - "true" - required: true - schema: - type: bool - - name: include_attachment_data - description: Include raw attachments in email export - multiline: false - options: - - "false" - - "true" - required: true - schema: - type: bool - - name: upload_email_shuffle - description: Upload email in shuffle, return uid - multiline: false - options: - - "false" - - "true" - required: true - schema: - type: bool - - name: upload_attachments_shuffle - description: Upload attachments in shuffle, return uids - multiline: false - options: - - "false" - - "true" - required: true - schema: - type: bool - - name: ssl_verify - description: Whether to use TLS or not - example: "true" - required: false - options: - - true - - false - schema: - type: string - - name: parse_email_file - description: Takes a file from shuffle and analyzes it if it's a valid .eml or .msg - parameters: - - name: file_id - description: file id - required: true - multiline: true - example: 'adf5e3d0fd85633be17004735a0a119e' - schema: - type: string - - name: file_extension - description: Extension of file you want to convert - required: true - options: - - eml - - msg - example: 'eml' - schema: - type: string - - name: parse_email_headers - description: - parameters: - - name: email_headers - description: Email headers - required: true - multiline: true - example: 'Email Headers' - schema: - type: string - returns: - schema: - type: string - returns: - schema: - type: string -large_image: data:image/png;base64,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 diff --git a/email/1.1.0/requirements.txt b/email/1.1.0/requirements.txt deleted file mode 100644 index b18be475..00000000 --- a/email/1.1.0/requirements.txt +++ /dev/null @@ -1,8 +0,0 @@ -requests==2.25.1 -glom==20.11.0 -requests==2.25.1 -eml-parser==1.17.0 -msg-parser==1.2.0 -mail-parser==3.15.0 -extract-msg==0.23.1 -jsonpickle==2.0.0 diff --git a/email/1.1.0/src/app.py b/email/1.1.0/src/app.py deleted file mode 100644 index 8b2868c8..00000000 --- a/email/1.1.0/src/app.py +++ /dev/null @@ -1,360 +0,0 @@ -import json -import uuid -import socket -import asyncio -import requests -import datetime -import base64 -import imaplib -import smtplib -import eml_parser -import time -import random -import eml_parser -import mailparser -import extract_msg -import jsonpickle - -from glom import glom -from msg_parser import MsOxMessage -from email.mime.multipart import MIMEMultipart -from email.mime.text import MIMEText -from email.mime.application import MIMEApplication - -from walkoff_app_sdk.app_base import AppBase - -def json_serial(obj): - if isinstance(obj, datetime.datetime): - serial = obj.isoformat() - return serial - -def default(o): - """helpers to store item in json - arguments: - - o: field of the object to serialize - returns: - - valid serialized value for unserializable fields - """ - if isinstance(o, (datetime.date, datetime.datetime)): - return o.isoformat() - if isinstance(o, set): - return list(o) - if isinstance(o, bytes): - return o.decode("utf-8") - - -class Email(AppBase): - __version__ = "1.1.0" - app_name = "email" - - def __init__(self, redis, logger, console_logger=None): - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - # This is an email function of Shuffle - def send_email_shuffle(self, apikey, recipients, subject, body): - targets = [recipients] - if ", " in recipients: - targets = recipients.split(", ") - elif "," in recipients: - targets = recipients.split(",") - - data = {"targets": targets, "body": body, "subject": subject, "type": "alert"} - - url = "https://shuffler.io/functions/sendmail" - headers = {"Authorization": "Bearer %s" % apikey} - return requests.post(url, headers=headers, json=data).text - - def send_email_smtp( - self, username, password, smtp_host, recipient, subject, body, smtp_port, attachments="", ssl_verify="True" - ): - if type(smtp_port) == str: - try: - smtp_port = int(smtp_port) - except ValueError: - return "SMTP port needs to be a number (Current: %s)" % smtp_port - - try: - s = smtplib.SMTP(host=smtp_host, port=smtp_port) - except socket.gaierror as e: - return f"Bad SMTP host or port: {e}" - - if ssl_verify == "false" or ssl_verify == "False": - pass - else: - s.starttls() - - if len(username) > 0 or len(password) > 0: - try: - s.login(username, password) - except smtplib.SMTPAuthenticationError as e: - return f"Bad username or password: {e}" - - # setup the parameters of the message - msg = MIMEMultipart() - msg["From"] = username - msg["To"] = recipient - msg["Subject"] = subject - msg.attach(MIMEText(body, "html")) - - # Read the attachments - attachment_count = 0 - try: - if attachments != None and len(attachments) > 0: - print("Got attachments: %s" % attachments) - attachmentsplit = attachments.split(",") - - #attachments = parse_list(attachments, splitter=",") - #print("Got attachments2: %s" % attachmentsplit) - print("Before loop") - files = [] - for file_id in attachmentsplit: - print(f"Looping {file_id}") - file_id = file_id.strip() - new_file = self.get_file(file_id) - print(f"New file: {new_file}") - try: - part = MIMEApplication( - new_file["data"], - Name=new_file["filename"], - ) - part["Content-Disposition"] = f"attachment; filename=\"{new_file['filename']}\"" - msg.attach(part) - attachment_count += 1 - except Exception as e: - print(f"[WARNING] Failed to attach {file_id}: {e}") - - - #files.append(new_file) - - #return files - #data["attachments"] = files - except Exception as e: - print(f"Error in attachment parsing for email: {e}") - - - try: - s.send_message(msg) - except smtplib.SMTPDataError as e: - return { - "success": False, - "reason": f"Failed to send mail: {e}" - } - - print("Successfully sent email with subject %s to %s" % (subject, recipient)) - return { - "success": True, - "reason": "Email sent to %s!" % recipient, - "attachments": attachment_count - } - - def get_emails_imap( - self, - username, - password, - imap_server, - foldername, - amount, - unread, - fields, - include_raw_body, - include_attachment_data, - upload_email_shuffle, - upload_attachments_shuffle, - ssl_verify="True" - ): - def path_to_dict(path, value=None): - def pack(parts): - return ( - {parts[0]: pack(parts[1:]) if len(parts) > 1 else value} - if len(parts) > 1 - else {parts[0]: value} - ) - - return pack(path.split(".")) - - def merge(d1, d2): - for k in d2: - if k in d1 and isinstance(d1[k], dict) and isinstance(d2[k], dict): - merge(d1[k], d2[k]) - else: - d1[k] = d2[k] - - if type(amount) == str: - try: - amount = int(amount) - except ValueError: - return "Amount needs to be a number, not %s" % amount - - try: - email = imaplib.IMAP4_SSL(imap_server) - except ConnectionRefusedError as error: - try: - email = imaplib.IMAP4(imap_server) - - if ssl_verify == "false" or ssl_verify == "False": - pass - else: - email.starttls() - except socket.gaierror as error: - return "Can't connect to IMAP server %s: %s" % (imap_server, error) - except socket.gaierror as error: - return "Can't connect to IMAP server %s: %s" % (imap_server, error) - - try: - email.login(username, password) - except imaplib.IMAP4.error as error: - return "Failed to log into %s: %s" % (username, error) - - email.select(foldername) - unread = True if unread.lower().strip() == "true" else False - try: - # IMAP search queries, e.g. "seen" or "read" - # https://www.rebex.net/secure-mail.net/features/imap-search.aspx - mode = "(UNSEEN)" if unread else "ALL" - thistype, data = email.search(None, mode) - except imaplib.IMAP4.error as error: - return "Couldn't find folder %s." % (foldername) - - email_ids = data[0] - id_list = email_ids.split() - if id_list == None: - return "Couldn't retrieve email. Data: %s" % data - - try: - print("LIST: ", len(id_list)) - except TypeError: - return "Error getting email. Data: %s" % data - - include_raw_body = True if include_raw_body.lower().strip() == "true" else False - include_attachment_data = ( - True if include_attachment_data.lower().strip() == "true" else False - ) - upload_email_shuffle = ( - True if upload_email_shuffle.lower().strip() == "true" else False - ) - upload_attachments_shuffle = ( - True if upload_attachments_shuffle.lower().strip() == "true" else False - ) - - # Convert of mails in json - emails = [] - ep = eml_parser.EmlParser( - include_attachment_data=include_attachment_data - or upload_attachments_shuffle, - include_raw_body=include_raw_body, - ) - try: - for i in range(len(id_list) - 1, len(id_list) - amount - 1, -1): - resp, data = email.fetch(id_list[i], "(RFC822)") - error = None - - if resp != "OK": - print("Failed getting %s" % id_list[i]) - continue - - if data == None: - continue - - output_dict = {} - parsed_eml = ep.decode_email_bytes(data[0][1]) - - if fields and fields.strip() != "": - for field in fields.split(","): - field = field.strip() - merge( - output_dict, - path_to_dict( - field, - glom(parsed_eml, field, default=None), - ), - ) - else: - output_dict = parsed_eml - - # Add message-id as top returned field - output_dict["message-id"] = parsed_eml["header"]["header"][ - "message-id" - ][0] - - if upload_email_shuffle: - email_up = [{"filename": "email.msg", "data": data[0][1]}] - email_id = self.set_files(email_up) - output_dict["email_uid"] = email_id[0] - - if upload_attachments_shuffle: - atts_up = [ - { - "filename": x["filename"], - "data": base64.b64decode(x["raw"]), - } - for x in parsed_eml["attachment"] - ] - atts_ids = self.set_files(atts_up) - output_dict["attachments_uids"] = atts_ids - - emails.append(output_dict) - except Exception as err: - return "Error during email processing: {}".format(err) - return json.dumps(emails, default=default) - - def parse_email_file(self, file_id, file_extension): - file_path = self.get_file(file_id) - if file_path["success"] == False: - return { - "success": False, - "reason": "Couldn't get file with ID %s" % file_id - } - - print("File: %s" % file_path) - if file_extension.lower() == 'eml': - print('working with .eml file') - ep = eml_parser.EmlParser() - try: - parsed_eml = ep.decode_email_bytes(file_path['data']) - return json.dumps(parsed_eml, default=json_serial) - except Exception as e: - return {"Success":"False","Message":f"Exception occured: {e}"} - elif file_extension.lower() == 'msg': - print('working with .msg file') - try: - msg = MsOxMessage(file_path['data']) - msg_properties_dict = msg.get_properties() - print(msg_properties_dict) - frozen = jsonpickle.encode(msg_properties_dict) - return frozen - except Exception as e: - return {"Success":"False","Message":f"Exception occured: {e}"} - else: - return {"Success":"False","Message":f"No file handler for file extension {file_extension}"} - - def parse_email_headers(self, email_headers): - try: - email_headers = bytes(email_headers,'utf-8') - ep = eml_parser.EmlParser() - parsed_headers = ep.decode_email_bytes(email_headers) - return json.dumps(parsed_headers, default=json_serial) - except Exception as e: - raise Exception(e) - - -# Run the actual thing after we've checked params -def run(request): - action = request.get_json() - authorization_key = action.get("authorization") - current_execution_id = action.get("execution_id") - - if action and "name" in action and "app_name" in action: - Email.run(action) - return f'Attempting to execute function {action["name"]} in app {action["app_name"]}' - else: - return f"Invalid action" - - -if __name__ == "__main__": - Email.run() diff --git a/email/1.2.0/requirements.txt b/email/1.2.0/requirements.txt deleted file mode 100644 index 926027e8..00000000 --- a/email/1.2.0/requirements.txt +++ /dev/null @@ -1,8 +0,0 @@ -requests==2.25.1 -glom==20.11.0 -eml-parser==1.17.0 -msg-parser==1.2.0 -mail-parser==3.15.0 -extract-msg==0.30.9 -jsonpickle==2.0.0 - diff --git a/email/1.2.0/src/app.py b/email/1.2.0/src/app.py deleted file mode 100644 index 8aad91be..00000000 --- a/email/1.2.0/src/app.py +++ /dev/null @@ -1,448 +0,0 @@ -import json -import uuid -import socket -import asyncio -import requests -import datetime -import base64 -import imaplib -import smtplib -import time -import random -import eml_parser -import mailparser -import extract_msg -import jsonpickle - -from glom import glom -from msg_parser import MsOxMessage -from email.mime.multipart import MIMEMultipart -from email.mime.text import MIMEText -from email.mime.application import MIMEApplication - -from walkoff_app_sdk.app_base import AppBase - -def json_serial(obj): - if isinstance(obj, datetime.datetime): - serial = obj.isoformat() - return serial - -def default(o): - """helpers to store item in json - arguments: - - o: field of the object to serialize - returns: - - valid serialized value for unserializable fields - """ - if isinstance(o, (datetime.date, datetime.datetime)): - return o.isoformat() - if isinstance(o, set): - return list(o) - if isinstance(o, bytes): - try: - return o.decode("utf-8") - except: - print("Failed parsing utf-8 string") - return o - - -class Email(AppBase): - __version__ = "1.2.0" - app_name = "email" - - def __init__(self, redis, logger, console_logger=None): - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - # This is an email function of Shuffle - def send_email_shuffle(self, apikey, recipients, subject, body): - targets = [recipients] - if ", " in recipients: - targets = recipients.split(", ") - elif "," in recipients: - targets = recipients.split(",") - - data = {"targets": targets, "body": body, "subject": subject, "type": "alert"} - - url = "https://shuffler.io/functions/sendmail" - headers = {"Authorization": "Bearer %s" % apikey} - return requests.post(url, headers=headers, json=data).text - - def send_email_smtp( - self, username, password, smtp_host, recipient, subject, body, smtp_port, attachments="", ssl_verify="True" - ): - if type(smtp_port) == str: - try: - smtp_port = int(smtp_port) - except ValueError: - return "SMTP port needs to be a number (Current: %s)" % smtp_port - - try: - s = smtplib.SMTP(host=smtp_host, port=smtp_port) - except socket.gaierror as e: - return f"Bad SMTP host or port: {e}" - - # This is not how it should work.. - # Port 465 & 587 = TLS - if ssl_verify == "false" or ssl_verify == "False": - pass - else: - s.starttls() - - if len(username) > 0 or len(password) > 0: - try: - s.login(username, password) - except smtplib.SMTPAuthenticationError as e: - return f"Bad username or password: {e}" - - # setup the parameters of the message - msg = MIMEMultipart() - msg["From"] = username - msg["To"] = recipient - msg["Subject"] = subject - msg.attach(MIMEText(body, "html")) - - # Read the attachments - attachment_count = 0 - try: - if attachments != None and len(attachments) > 0: - print("Got attachments: %s" % attachments) - attachmentsplit = attachments.split(",") - - #attachments = parse_list(attachments, splitter=",") - #print("Got attachments2: %s" % attachmentsplit) - print("Before loop") - files = [] - for file_id in attachmentsplit: - print(f"Looping {file_id}") - file_id = file_id.strip() - new_file = self.get_file(file_id) - print(f"New file: {new_file}") - try: - part = MIMEApplication( - new_file["data"], - Name=new_file["filename"], - ) - part["Content-Disposition"] = f"attachment; filename=\"{new_file['filename']}\"" - msg.attach(part) - attachment_count += 1 - except Exception as e: - print(f"[WARNING] Failed to attach {file_id}: {e}") - - - #files.append(new_file) - - #return files - #data["attachments"] = files - except Exception as e: - self.logger.info(f"Error in attachment parsing for email: {e}") - - - try: - s.send_message(msg) - except smtplib.SMTPDataError as e: - return { - "success": False, - "reason": f"Failed to send mail: {e}" - } - - self.logger.info("Successfully sent email with subject %s to %s" % (subject, recipient)) - return { - "success": True, - "reason": "Email sent to %s!" % recipient, - "attachments": attachment_count - } - - def get_emails_imap( - self, - username, - password, - imap_server, - foldername, - amount, - unread, - fields, - include_raw_body, - include_attachment_data, - upload_email_shuffle, - upload_attachments_shuffle, - ssl_verify="True", - mark_as_read="False", - ): - def path_to_dict(path, value=None): - def pack(parts): - return ( - {parts[0]: pack(parts[1:]) if len(parts) > 1 else value} - if len(parts) > 1 - else {parts[0]: value} - ) - - return pack(path.split(".")) - - def merge(d1, d2): - for k in d2: - if k in d1 and isinstance(d1[k], dict) and isinstance(d2[k], dict): - merge(d1[k], d2[k]) - else: - d1[k] = d2[k] - - #if isinstance(mark_as_read, str): - # if str(mark_as_read).lower() == "true": - # mark_as_read = True - # else: - # mark_as_read = False - - if type(amount) == str: - try: - amount = int(amount) - except ValueError: - return { - "success": False, - "reason": "Amount needs to be a number, not %s" % amount, - } - - try: - email = imaplib.IMAP4_SSL(imap_server) - except ConnectionRefusedError as error: - try: - email = imaplib.IMAP4(imap_server) - - if ssl_verify == "false" or ssl_verify == "False" or ssl_verify == False: - pass - else: - email.starttls() - except socket.gaierror as error: - return { - "success": False, - "reason": "Can't connect to IMAP server %s: %s" % (imap_server, error), - } - except socket.gaierror as error: - return { - "success": False, - "reason": "Can't connect to IMAP server %s: %s" % (imap_server, error), - } - - try: - email.login(username, password) - except imaplib.IMAP4.error as error: - return { - "success": False, - "reason": "Failed to log into %s: %s" % (username, error), - } - - email.select(foldername) - unread = True if unread.lower().strip() == "true" else False - - try: - # IMAP search queries, e.g. "seen" or "read" - # https://www.rebex.net/secure-mail.net/features/imap-search.aspx - mode = "(UNSEEN)" if unread else "ALL" - thistype, data = email.search(None, mode) - except imaplib.IMAP4.error as error: - return { - "success": False, - "reason": "Couldn't find folder %s." % (foldername), - } - - email_ids = data[0] - id_list = email_ids.split() - if id_list == None: - return { - "success": False, - "reason": f"Couldn't retrieve email. Data: {data}", - } - - #try: - # self.logger.info(f"LIST: {id_list}") - #except TypeError: - # return { - # "success": False, - # "reason": "Error getting email. Data: %s" % data, - # } - - mark_as_read = True if str(mark_as_read).lower().strip() == "true" else False - include_raw_body = True if str(include_raw_body).lower().strip() == "true" else False - include_attachment_data = ( - True if str(include_attachment_data).lower().strip() == "true" else False - ) - upload_email_shuffle = ( - True if str(upload_email_shuffle).lower().strip() == "true" else False - ) - upload_attachments_shuffle = ( - True if str(upload_attachments_shuffle).lower().strip() == "true" else False - ) - - # Convert of mails in json - emails = [] - ep = eml_parser.EmlParser( - include_attachment_data=include_attachment_data - or upload_attachments_shuffle, - include_raw_body=include_raw_body, - ) - - if len(id_list) == 0: - return { - "success": True, - "messages": [], - } - - try: - amount = len(id_list) if len(id_list) 1 or len(password) > 1: + try: + s.login(username, password) + except Exception as e: + if len(password) == 0: + self.logger.info("[WARNING] Auth failed (2). No password provided. Continuing as auth may not be necessary.") + else: + return { + "success": False, + "reason": f"General login exception: {e}" + } + + except smtplib.SMTPAuthenticationError as e: + if len(password) == 0: + self.logger.info("[WARNING] Auth failed. No password provided. Continuing as auth may not be necessary.") + else: + return { + "success": False, + "reason": f"Bad username or password: {e}" + } + + if body_type == "" or len(body_type) < 3: + body_type = "html" + + # setup the parameters of the message + self.logger.info("Pre mime multipart") + msg = MIMEMultipart() + msg["From"] = username + if len(username) == 0: + return { + "success": False, + "reason": "No username provided (sender). Please provide a username. Required since January 2025." + } + + msg["To"] = recipient + msg["Subject"] = subject + + if cc_emails: + msg["Cc"] = cc_emails + + self.logger.info("Pre mime check") + msg.attach(MIMEText(body, body_type)) + + # Read the attachments + attachment_count = 0 + self.logger.info("Pre attachments") + try: + if attachments != None and len(attachments) > 0: + print("Got attachments: %s" % attachments) + attachmentsplit = attachments.split(",") + + #attachments = parse_list(attachments, splitter=",") + #print("Got attachments2: %s" % attachmentsplit) + print("Before loop") + files = [] + for file_id in attachmentsplit: + print(f"Looping {file_id}") + file_id = file_id.strip() + new_file = self.get_file(file_id) + print(f"New file: {new_file}") + try: + part = MIMEApplication( + new_file["data"], + Name=new_file["filename"], + ) + part["Content-Disposition"] = f"attachment; filename=\"{new_file['filename']}\"" + msg.attach(part) + attachment_count += 1 + except Exception as e: + print(f"[WARNING] Failed to attach {file_id}: {e}") + + + #files.append(new_file) + + #return files + #data["attachments"] = files + except Exception as e: + self.logger.info(f"Error in attachment parsing for email: {e}") + + self.logger.info(f"Pre send msg: {msg}") + try: + s.send_message(msg) + except smtplib.SMTPDataError as e: + return { + "success": False, + "reason": f"Failed to send mail: {e}" + } + except Exception as e: + return { + "success": False, + "reason": f"Failed to send mail (2): {e}" + } + + self.logger.info("Successfully sent email with subject %s to %s" % (subject, recipient)) + return { + "success": True, + "reason": "Email sent to %s, %s!" % (recipient, cc_emails) if cc_emails else "Email sent to %s!" % recipient, + "attachments": attachment_count + } + + def get_emails_imap( + self, + username, + password, + imap_server, + foldername, + amount, + unread, + fields, + include_raw_body, + include_attachment_data, + upload_email_shuffle, + upload_attachments_shuffle, + ssl_verify="True", + mark_as_read="False", + ): + def path_to_dict(path, value=None): + def pack(parts): + return ( + {parts[0]: pack(parts[1:]) if len(parts) > 1 else value} + if len(parts) > 1 + else {parts[0]: value} + ) + + return pack(path.split(".")) + + def merge(d1, d2): + for k in d2: + if k in d1 and isinstance(d1[k], dict) and isinstance(d2[k], dict): + merge(d1[k], d2[k]) + else: + d1[k] = d2[k] + + #if isinstance(mark_as_read, str): + # if str(mark_as_read).lower() == "true": + # mark_as_read = True + # else: + # mark_as_read = False + + if type(amount) == str: + try: + amount = int(amount) + except ValueError: + return { + "success": False, + "reason": "Amount needs to be a number, not %s" % amount, + } + + try: + email = imaplib.IMAP4_SSL(imap_server) + except ConnectionRefusedError as error: + try: + email = imaplib.IMAP4(imap_server) + + if ssl_verify == "false" or ssl_verify == "False" or ssl_verify == False: + pass + else: + email.starttls() + except socket.gaierror as error: + return { + "success": False, + "reason": "Can't connect to IMAP server %s: %s" % (imap_server, error), + } + except socket.gaierror as error: + return { + "success": False, + "reason": "Can't connect to IMAP server %s: %s" % (imap_server, error), + } + + try: + email.login(username, password) + except imaplib.IMAP4.error as error: + return { + "success": False, + "reason": "Failed to log into %s: %s" % (username, error), + } + + email.select(foldername) + unread = True if unread.lower().strip() == "true" else False + + try: + # IMAP search queries, e.g. "seen" or "read" + # https://www.rebex.net/secure-mail.net/features/imap-search.aspx + mode = "(UNSEEN)" if unread else "ALL" + thistype, data = email.search(None, mode) + except imaplib.IMAP4.error as error: + return { + "success": False, + "reason": "Couldn't find folder %s." % (foldername), + } + + email_ids = data[0] + id_list = email_ids.split() + if id_list == None: + return { + "success": False, + "reason": f"Couldn't retrieve email. Data: {data}", + } + + #try: + # self.logger.info(f"LIST: {id_list}") + #except TypeError: + # return { + # "success": False, + # "reason": "Error getting email. Data: %s" % data, + # } + + mark_as_read = True if str(mark_as_read).lower().strip() == "true" else False + include_raw_body = True if str(include_raw_body).lower().strip() == "true" else False + include_attachment_data = ( + True if str(include_attachment_data).lower().strip() == "true" else False + ) + upload_email_shuffle = ( + True if str(upload_email_shuffle).lower().strip() == "true" else False + ) + upload_attachments_shuffle = ( + True if str(upload_attachments_shuffle).lower().strip() == "true" else False + ) + + # Convert of mails in json + emails = [] + ep = eml_parser.EmlParser( + include_attachment_data=include_attachment_data + or upload_attachments_shuffle, + include_raw_body=include_raw_body, + ) + + if len(id_list) == 0: + return { + "success": True, + "messages": [], + } + + try: + amount = len(id_list) if len(id_list) 0: + + for i in range(len(parsed_eml["body"])): + if "uri" in parsed_eml["body"][i] and len(parsed_eml["body"][i]["uri"]) > 0: + parsed_eml["body"][i]["uri"] = self.remove_similar_items(parsed_eml["body"][i]["uri"]) + + if "email" in parsed_eml["body"][i] and len(parsed_eml["body"][i]["email"]) > 0: + parsed_eml["body"][i]["email"] = self.remove_similar_items(parsed_eml["body"][i]["email"]) + + if "domain" in parsed_eml["body"][i] and len(parsed_eml["body"][i]["domain"]) > 0: + parsed_eml["body"][i]["domain"] = self.remove_similar_items(parsed_eml["body"][i]["domain"]) + + except Exception as e: + self.logger.info(f"[ERROR] Failed to remove similar items: {e}") + + parsed_eml["success"] = True + return json.dumps(parsed_eml, default=json_serial) + except Exception as e: + return {"success":False, "reason": f"An exception occured during EML parsing: {e}. Please contact support"} + + return {"success": False, "reason": "No email has been defined for this file type"} + + + def parse_email_headers(self, email_headers): + try: + email_headers = bytes(email_headers,'utf-8') + ep = eml_parser.EmlParser() + parsed_headers = ep.decode_email_bytes(email_headers) + return json.dumps(parsed_headers, default=json_serial) + except Exception as e: + raise Exception(e) + + # Basic function to check headers in an email + # Can be dumped in in pretty much any format + def analyze_headers(self, headers): + self.logger.info("Input headers: %s" % headers) + + # Raw + if isinstance(headers, str): + headers = self.parse_email_headers(headers) + if isinstance(headers, str): + headers = json.loads(headers) + + headers = headers["header"]["header"] + + # Just a way to parse out shitty email formats + if "header" in headers: + headers = headers["header"] + if "header" in headers: + headers = headers["header"] + + if "headers" in headers: + headers = headers["headers"] + if "headers" in headers: + headers = headers["headers"] + + if not isinstance(headers, list): + newheaders = [] + for key, value in headers.items(): + if isinstance(value, list): + newheaders.append({ + "key": key, + "value": value[0], + }) + else: + newheaders.append({ + "key": key, + "value": value, + }) + + headers = newheaders + + #self.logger.info("Parsed headers: %s" % headers) + + spf = False + dkim = False + dmarc = False + spoofed = False + + analyzed_headers = { + "success": True, + "sender": "", + "receiver": "", + "subject": "", + "date": "", + "details": { + "spf": "", + "dkim": "", + "dmarc": "", + "spoofed": "", + }, + } + + for item in headers: + if "name" in item: + item["key"] = item["name"] + + item["key"] = item["key"].lower() + + # Handle sender/receiver + if item["key"] == "from" or item["key"] == "sender" or item["key"] == "delivered-to": + analyzed_headers["sender"] = item["value"] + + if item["key"] == "to" or item["key"] == "receiver" or item["key"] == "delivered-to": + analyzed_headers["receiver"] = item["value"] + + if item["key"] == "subject" or item["key"] == "title": + analyzed_headers["subject"] = item["value"] + + if item["key"] == "date": + analyzed_headers["date"] = item["value"] + + if "spf" in item["key"]: + analyzed_headers["details"]["spf"] = spf + if "pass " in item["value"].lower(): + spf = True + + if "dkim" in item["key"]: + analyzed_headers["details"]["dkim"] = dkim + if "pass " in item["value"].lower(): + dkim = True + + if "dmarc" in item["key"]: + analyzed_headers["details"]["dmarc"] = dmarc + print("dmarc: ", item["key"]) + + if item["key"].lower() == "authentication-results": + if "spf" in item["value"].lower(): + analyzed_headers["details"]["spf"] = spf + + if "dkim" in item["value"].lower(): + analyzed_headers["details"]["dkim"] = dkim + + if "dmarc" in item["value"].lower(): + analyzed_headers["details"]["dmarc"] = dmarc + + if "spf=pass" in item["value"]: + spf = True + if "dkim=pass" in item["value"]: + dkim = True + if "dmarc=pass" in item["value"]: + dmarc = True + + # Fix spoofed! + if item["key"] == "from": + print("From: " + item["value"]) + + if "<" in item["value"]: + item["value"] = item["value"].split("<")[1] + + for subitem in headers: + if "name" in subitem: + subitem["key"] = subitem["name"] + + subitem["key"] = subitem["key"].lower() + + if subitem["key"] == "reply-to": + + if "<" in subitem["value"]: + subitem["value"] = subitem["value"].split("<")[1] + + if item["value"] != subitem["value"]: + spoofed = True + analyzed_headers["spoofed_reason"] = "Reply-To is different than From" + analyzed_headers["details"]["spoofed"] = subitem["value"] + break + + + if subitem["key"] == "mail-reply-to": + print("Reply-To: " + subitem["value"], item["value"]) + + if "<" in subitem["value"]: + subitem["value"] = subitem["value"].split("<")[1] + + if item["value"] != subitem["value"]: + spoofed = True + analyzed_headers["spoofed_reason"] = "Mail-Reply-To is different than From" + analyzed_headers["details"]["spoofed"] = subitem["value"] + break + + analyzed_headers["spf"] = spf + analyzed_headers["dkim"] = dkim + analyzed_headers["dmarc"] = dmarc + analyzed_headers["spoofed"] = spoofed + + # Should be a dictionary + return analyzed_headers + + # This is an SMS function of Shuffle + def send_sms_shuffle(self, apikey, phone_numbers, body): + phone_numbers = phone_numbers.replace(" ", "") + targets = phone_numbers.split(",") + + data = {"numbers": targets, "body": body} + + url = "https://shuffler.io/api/v1/functions/sendsms" + headers = {"Authorization": "Bearer %s" % apikey} + return requests.post(url, headers=headers, json=data, verify=False).text + + +# Run the actual thing after we've checked params +def run(request): + action = request.get_json() + authorization_key = action.get("authorization") + current_execution_id = action.get("execution_id") + + if action and "name" in action and "app_name" in action: + Email.run(action) + return f'Attempting to execute function {action["name"]} in app {action["app_name"]}' + else: + return f"Invalid action" + + +if __name__ == "__main__": + Email.run() diff --git a/email/README.md b/email/README.md index 46a9922e..22855529 100644 --- a/email/README.md +++ b/email/README.md @@ -1,9 +1,15 @@ -## Using curl to test whether you SMPT mails are getting delivered. +# Mail +This apps is used to interact with SMTP, IMAP and contains other basic email tools + +## eml parsing +You can parse eml files by running the "Parse email file" action + +### Using curl to test whether you SMPT mails are getting delivered. ``` curl --ssl smtp://1.1.1.1:587 --mail-from example@example.com --mail-rcpt example1@example.com --upload-file email.txt --user 'example:Password123' -k -v ``` -## email.txt : Should contain the below +### email.txt : Should contain the below ``` From: To: diff --git a/exchange-powershell/1.0.0/src/app.py b/exchange-powershell/1.0.0/src/app.py index bd3d31de..acdf8648 100644 --- a/exchange-powershell/1.0.0/src/app.py +++ b/exchange-powershell/1.0.0/src/app.py @@ -30,6 +30,8 @@ def __init__(self, redis, logger, console_logger=None): def cleanup(self, item): newlines = [] + print(f"Cleanup item: {item}") + record = False skipped = 0 for line in item.split("\n"): @@ -62,6 +64,7 @@ def replace_and_run(self, username, password, parsed_command): data = data.replace("{USERNAME}", username) data = data.replace("{PASSWORD}", password) data = data.replace("{COMMAND}", parsed_command) + print(f"DATA: {data}") with open(self.filename, "w+") as tmp: tmp.write(data) @@ -122,8 +125,7 @@ def export_quarantine_message(self, username, password, message_id, skip_upload= ret = self.replace_and_run(username, password, parsed_command) print("RET: %s" % ret) try: - if not isinstance(ret, list) and not isinstance(ret, object) and not isinstance(ret, dict): - ret = json.loads(ret) + ret = json.loads(ret) except json.decoder.JSONDecodeError: return ret @@ -143,7 +145,6 @@ def export_quarantine_message(self, username, password, message_id, skip_upload= "success": True, "file_id": fileinfo[0] } - return fileinfo # Write your data inside this function @@ -162,7 +163,10 @@ def get_quarantine_message(self, username, password, message_id): # Write your data inside this function def get_quarantine_messages(self, username, password, time_from, time_to): - parsed_command = f"Get-QuarantineMessage -StartReceivedDate {time_from} -EndReceivedDate {time_to} | ConvertTo-Json" + #parsed_command = f"Get-QuarantineMessage -StartReceivedDate {time_from} -EndReceivedDate {time_to} | ConvertTo-Json" + #parsed_command = f"Get-QuarantineMessage -StartReceivedDate {time_from} -EndReceivedDate {time_to}" + parsed_command = f"Get-QuarantineMessage -PageSize 50 -Page 1" + ret = self.replace_and_run(username, password, parsed_command) return ret diff --git a/exchange-powershell/1.1.0/Dockerfile b/exchange-powershell/1.1.0/Dockerfile new file mode 100644 index 00000000..cc6e4d1e --- /dev/null +++ b/exchange-powershell/1.1.0/Dockerfile @@ -0,0 +1,67 @@ +# Base our app image off of the WALKOFF App SDK image +FROM frikky/shuffle:app_sdk as base + +# We're going to stage away all of the bloat from the build tools so lets create a builder stage +FROM base as builder + +# Install all alpine build tools needed for our pip installs +RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev + +# Install all of our pip packages in a single directory that we can copy to our base image later +RUN mkdir /install +WORKDIR /install +COPY requirements.txt /requirements.txt +RUN pip install --prefix="/install" -r /requirements.txt + +# Switch back to our base image and copy in all of our built packages and source code +FROM base +COPY --from=builder /install /usr/local +COPY src /app + +# Install any binary dependencies needed in our final image +# RUN apk --no-cache add --update my_binary_dependency +RUN apk add --no-cache \ + ca-certificates \ + less \ + ncurses-terminfo-base \ + krb5-libs \ + libgcc \ + libintl \ + libssl1.1 \ + libstdc++ \ + tzdata \ + userspace-rcu \ + zlib \ + icu-libs \ + curl + +RUN apk -X https://dl-cdn.alpinelinux.org/alpine/edge/main add --no-cache \ + lttng-ust + +# Download the powershell '.tar.gz' archive +RUN curl -L https://github.com/PowerShell/PowerShell/releases/download/v7.2.3/powershell-7.2.3-linux-alpine-x64.tar.gz -o /tmp/powershell.tar.gz + +# Create the target folder where powershell will be placed +RUN mkdir -p /opt/microsoft/powershell/7 + +# Expand powershell to the target folder +RUN tar zxf /tmp/powershell.tar.gz -C /opt/microsoft/powershell/7 + +# Set execute permissions +RUN chmod +x /opt/microsoft/powershell/7/pwsh + +# Create the symbolic link that points to pwsh +RUN ln -s /opt/microsoft/powershell/7/pwsh /usr/bin/pwsh +RUN pwsh -Command Install-Module -Name ExchangeOnlineManagement -AllowPrerelease -Force -RequiredVersion 2.0.6-Preview5 +RUN sh -c "yes | pwsh -Command 'Install-Module -Name PSWSMan'" +RUN pwsh -Command 'Install-WSMan' +RUN pwsh -Command Import-Module 'Microsoft.PowerShell.Security' -Force + +# Adds a replacement file which will be used to run the powershell script from python +COPY replacementfile.ps1 /app/replacementfile.ps1 +#COPY password.ps1 password.ps1 +#RUN pwsh -file password.ps1 + +# Finally, lets run our app! +WORKDIR /app +CMD python app.py --log-level DEBUG diff --git a/exchange-powershell/1.1.0/README.md b/exchange-powershell/1.1.0/README.md new file mode 100644 index 00000000..e23727c5 --- /dev/null +++ b/exchange-powershell/1.1.0/README.md @@ -0,0 +1,45 @@ +docker run -it mcr.microsoft.com/powershell:ubuntu-18.04 + + +### https://docs.microsoft.com/en-us/powershell/module/exchange/connect-exchangeonline?view=exchange-ps +Install-Module -Name ExchangeOnlineManagement -Force + +Connect-ExchangeOnline -Device + +* Go to https://microsoft.com/devicelogin and type in the code they give + +Get-QuarantineMessage +Get-QuarantineMessageHeader +Delete-QuarantineMessage +Export-QuarantineMessage +Preview-QuarantineMessage +Release-QuarantineMessage + +############### Otherwise: +Install-Module -Name ExchangeOnlineManagement -Force +Connect-ExchangeOnline -InlineCredential + +$userCredential = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList "frikky@shufflertest2.onmicrosoft.com", $(ConvertTo-SecureString -String "MyPassword" -AsPlainText -Force) + +$Session = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://outlook.office365.com/powershell-liveid/ -Authentication Basic -AllowRedirection -Credential $(New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList "frikky@shufflertest2.onmicrosoft.com", $(ConvertTo-SecureString -String "MyPassword" -AsPlainText -Force)) + +Import-PSSession $Session -AllowClobber + + +############### USAGE +$msg = Get-QuarantineMessage -StartReceivedDate 06/13/2016 -EndReceivedDate 01/01/2025 +$msg[0].MessageID +$msg[0].Identity + +Get-QuarantineMessage -MessageID "<5c695d7e-6642-4681-a4b0-9e7a86613cb7@contoso.com>" +Get-QuarantineMessage -Identity $msg.identity + +Get-QuarantineMessageHeader $msg.identity +$exported = Export-QuarantineMessage -Identity $msg.identity +$exported.eml + + + +############## EXTRA PSWSMan +Install-Module -Name PSWSMan -Force +Install-WSMan diff --git a/exchange-powershell/1.1.0/api.yaml b/exchange-powershell/1.1.0/api.yaml new file mode 100644 index 00000000..02cad4fc --- /dev/null +++ b/exchange-powershell/1.1.0/api.yaml @@ -0,0 +1,161 @@ +app_version: 1.1.0 +name: Exchange Powershell +description: An app to interact with emails to be downloaded and release quarantined emails from office365 using Powershell +contact_info: + name: "@frikkylikeme" + url: https://github.com/vlegoy/rcATT + email: frikky@shuffler.io +tags: + - Communication +categories: + - Communication +authentication: + required: true + parameters: + - name: certificate + description: The File ID of the certificate to use + required: true + example: 'file_1231231231232' + schema: + type: string + - name: password + description: The password for the certificate + required: true + example: 'app_password' + schema: + type: string + - name: app_id + description: The app ID from azure + required: true + example: 'app_id_from_azure' + schema: + type: string + - name: organization + description: Your organization as an onmicrosoft.com account + required: true + example: 'shufflertest2.onmicrosoft.com' + schema: + type: string +actions: + - name: run_custom + description: Runs a python script defined by YOU + parameters: + - name: command + description: The organization + multiline: true + required: true + example: 'ls; echo "hi"; Get-Mailbox' + schema: + type: string + returns: + schema: + type: string + - name: get_quarantine_messages + description: Predicts the + parameters: + - name: time_from + description: Start time + required: true + multiline: true + example: '06/13/2016' + schema: + type: string + - name: time_to + description: End time + required: true + multiline: true + example: '01/01/2025' + schema: + type: string + returns: + schema: + type: string + - name: release_quarantine_message + description: Releases quarantine message back to the original user + parameters: + - name: message_id + description: The message to get + required: true + multiline: false + example: '' + schema: + type: string + returns: + schema: + type: string + - name: preview_quarantine_message + description: Previews a quarantine message + parameters: + - name: message_id + description: The message to get + required: true + multiline: false + example: '{"data": "testing"}' + schema: + type: string + returns: + schema: + type: string + - name: export_quarantine_message + description: Exports a quarantine message + parameters: + - name: message_id + description: The message to get + required: true + multiline: false + example: '{"data": "testing"}' + schema: + type: string + - name: skip_upload + description: Decides if you should upload the file or not + required: true + multiline: false + options: + - false + - true + example: '{"data": "testing"}' + schema: + type: string + returns: + schema: + type: string + - name: delete_quarantine_message + description: Deletes a quarantine message + parameters: + - name: message_id + description: The message to get + required: true + multiline: false + example: '{"data": "testing"}' + schema: + type: string + returns: + schema: + type: string + - name: get_quarantine_message + description: Predicts the + parameters: + - name: message_id + description: The message to get + required: true + multiline: false + example: '{"data": "testing"}' + schema: + type: string + returns: + schema: + type: string + - name: get_quarantine_messageheaders + description: Predicts the + parameters: + - name: message_id + description: The message to get + required: true + multiline: false + example: '' + schema: + type: string + returns: + schema: + type: string +large_image: data:image/png;base64,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 diff --git a/exchange-powershell/1.1.0/replacementfile.ps1 b/exchange-powershell/1.1.0/replacementfile.ps1 new file mode 100644 index 00000000..854ffceb --- /dev/null +++ b/exchange-powershell/1.1.0/replacementfile.ps1 @@ -0,0 +1,6 @@ +# This file is used to run powershell-remote commands from within Shuffle from python. +# Fields using { } are to be replaced (username, password, command) +Connect-ExchangeOnline -CertificateFilePath "./cert.pfx" -AppID "{APP_ID}" -Organization "{ORGANIZATION}" -CertificatePassword (ConvertTo-SecureString -String "{PASSWORD}" -AsPlainText -Force) + +echo "ANYTHING BEFORE THIS LINE IS NOT A PART OF THE RESULT AND SHOULD BE IGNORED. IF YOU SEE THIS TEXT IT IS PROBABLY DUE TO GETTING NO RESULTS" +{COMMAND} diff --git a/exchange-powershell/1.1.0/requirements.txt b/exchange-powershell/1.1.0/requirements.txt new file mode 100644 index 00000000..e69de29b diff --git a/exchange-powershell/1.1.0/src/app.py b/exchange-powershell/1.1.0/src/app.py new file mode 100644 index 00000000..d368a44a --- /dev/null +++ b/exchange-powershell/1.1.0/src/app.py @@ -0,0 +1,244 @@ +import socket +import asyncio +import time +import random +import json +import subprocess +import base64 + +from walkoff_app_sdk.app_base import AppBase + +# 1. Generate the api.yaml based on downloaded files +# 2. Add a way to choose the rule and the target platform for it +# 3. Add the possibility of translating rules back and forth + +# 4. Make it so you can start with Mitre Att&ck techniques +# and automatically get the right rules set up with your tools :O +class exchange_powershell(AppBase): + __version__ = "1.0.0" + app_name = "exchange-powershell" + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + self.filename = "replacementfile.ps1" + super().__init__(redis, logger, console_logger) + + def cleanup(self, item): + newlines = [] + record = False + skipped = 0 + for line in item.split("\n"): + if line.startswith("{") or line.startswith("["): + record = True + + if not record and not line.startswith("{") and not line.startswith("["): + skipped += 1 + + if record: + newlines.append(line) + + #if "SHFFL_START" in line: + # record = True + + self.logger.info(f"SKIPPED {skipped} lines") + if len(newlines) == 0: + return item + + item = "\n".join(newlines) + + return item + + def replace_and_run(self, password, app_id, organization, command): + data = "" + with open(self.filename, "r") as tmp: + data = tmp.read() + + if len(data) == 0: + return "" + + data = data.replace("{PASSWORD}", password) + data = data.replace("{APP_ID}", app_id) + data = data.replace("{ORGANIZATION}", organization) + data = data.replace("{COMMAND}", command) + + with open(self.filename, "w+") as tmp: + tmp.write(data) + + command = f"pwsh -file {self.filename}" + self.logger.info(f"PRE POPEN: {command}") + process = subprocess.Popen( + command, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + shell=True, # nosec + ) + self.logger.info("POST STDOUT") + stdout = process.communicate() + self.logger.info(f"STDOUT: {stdout}") + item = "" + if len(stdout[0]) > 0: + item = stdout[0] + self.logger.info("Succesfully ran bash. Stdout: %s" % item) + else: + item = stdout[1] + self.logger.info("FAILED to run bash. Stdout: %s!" % item) + #return item + + try: + new_cleanup = self.cleanup(item) + if len(new_cleanup) > 0: + item = new_cleanup + except Exception as e: + pass + + try: + return item.decode("utf-8") + except Exception as e: + return item + + return item + + + + def handle_filewriting(self, certificate): + filedata = self.get_file(certificate) + if filedata["success"] == False: + return filedata + + cert = "cert.pfx" + self.logger.info("Writing cert to file %s" % cert) + with open(cert, "wb+") as tmp: + tmp.write(filedata["data"]) + + return filedata + + def run_custom(self, certificate, password, app_id, organization, command): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = command + #if "convertto-json" not in parsed_command.lower(): + # parsed_command = parsed_command + "| ConvertTo-Json -Depth 9" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + + # Write your data inside this function + def release_quarantine_message(self, certificate, password, app_id, organization, message_id): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = f"Release-QuarantineMessage -Identity {message_id} | ConvertTo-Json" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + + # Write your data inside this function + def preview_quarantine_message(self, certificate, password, app_id, organization, message_id): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = f"Preview-QuarantineMessage -Identity {message_id} | ConvertTo-Json" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + + # Write your data inside this function + def export_quarantine_message(self, certificate, password, app_id, organization, message_id, skip_upload="false"): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = f"Export-QuarantineMessage -Identity {message_id} | ConvertTo-Json" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + print("RET: %s" % ret) + try: + ret = json.loads(ret) + except json.decoder.JSONDecodeError: + return ret + + file_eml = ret["Eml"] + if skip_upload == "true": + return file_eml + + message_bytes = base64.b64decode(file_eml) + + fileinfo = self.set_files({ + "filename": f"{message_id}.eml", + "data": message_bytes + }) + + if len(fileinfo) == 1: + return { + "success": True, + "file_id": fileinfo[0] + } + return fileinfo + + # Write your data inside this function + def delete_quarantine_message(self, certificate, password, app_id, organization, message_id): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = f"Delete-QuarantineMessage -Identity {message_id} | ConvertTo-Json" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + + # Write your data inside this function + def get_quarantine_message(self, certificate, password, app_id, organization, message_id): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = f"Get-QuarantineMessage {message_id} | ConvertTo-Json" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + + # Write your data inside this function + def get_quarantine_messages(self, certificate, password, app_id, organization, time_from, time_to): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + #parsed_command = f"Get-QuarantineMessage -StartReceivedDate {time_from} -EndReceivedDate {time_to} | ConvertTo-Json" + #parsed_command = f"Get-QuarantineMessage -StartReceivedDate {time_from} -EndReceivedDate {time_to}" + parsed_command = f"Get-QuarantineMessage -PageSize 50 -Page 1" + + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + + # Write your data inside this function + def get_quarantine_messageheaders(self, certificate, password, app_id, organization, message_id): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = f"Get-QuarantineMessageHeader {message_id} | ConvertTo-Json" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + +if __name__ == "__main__": + exchange_powershell.run() diff --git a/gitguardian/1.0.0/requirements.txt b/gitguardian/1.0.0/requirements.txt index 7a453b65..ab60beb1 100644 --- a/gitguardian/1.0.0/requirements.txt +++ b/gitguardian/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 +requests==2.32.4 pygitguardian==1.1.2 \ No newline at end of file diff --git a/google-chat/1.0.0/requirements.txt b/google-chat/1.0.0/requirements.txt index 9d84d358..bd6f2345 100644 --- a/google-chat/1.0.0/requirements.txt +++ b/google-chat/1.0.0/requirements.txt @@ -1 +1 @@ -requests==2.25.1 +requests==2.32.4 diff --git a/gpg-tools/1.0.0/requirements.txt b/gpg-tools/1.0.0/requirements.txt index e5ff88aa..1edb807d 100644 --- a/gpg-tools/1.0.0/requirements.txt +++ b/gpg-tools/1.0.0/requirements.txt @@ -1,2 +1,2 @@ python-gnupg==0.4.6 -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/gpg-tools/1.0.0/src/app.py b/gpg-tools/1.0.0/src/app.py index d92b9e53..7db1c28b 100644 --- a/gpg-tools/1.0.0/src/app.py +++ b/gpg-tools/1.0.0/src/app.py @@ -79,9 +79,7 @@ def encrypt_file( ) ) - gpg = gnupg.GPG( - gnupghome=os.path.join("/app/local/", gpg_home), gpgbinary="/usr/bin/gpg" - ) + gpg = gnupg.GPG(gnupghome=os.path.join("/app/local/", gpg_home), gpgbinary="/usr/bin/gpg") with tempfile.NamedTemporaryFile(delete=False) as tmpfile: with open(tmpfile.name, "wb") as f: diff --git a/thehive/1.1.3/Dockerfile b/gpg-tools/1.1.0/Dockerfile similarity index 93% rename from thehive/1.1.3/Dockerfile rename to gpg-tools/1.1.0/Dockerfile index bfa83edc..370fb0d4 100644 --- a/thehive/1.1.3/Dockerfile +++ b/gpg-tools/1.1.0/Dockerfile @@ -5,7 +5,7 @@ FROM frikky/shuffle:app_sdk as base FROM base as builder # Install all alpine build tools needed for our pip installs -RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev +RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev # Install all of our pip packages in a single directory that we can copy to our base image later RUN mkdir /install @@ -19,7 +19,7 @@ COPY --from=builder /install /usr/local COPY src /app # Install any binary dependencies needed in our final image -RUN apk --no-cache add --update libmagic +RUN apk --no-cache add --update gnupg # Finally, lets run our app! WORKDIR /app diff --git a/gpg-tools/1.1.0/api.yaml b/gpg-tools/1.1.0/api.yaml new file mode 100644 index 00000000..1a1ba296 --- /dev/null +++ b/gpg-tools/1.1.0/api.yaml @@ -0,0 +1,124 @@ +app_version: 1.1.0 +name: Gpg Tools +description: A gpg app for Shuffle +contact_info: + name: "@deb-alex" +authentication: + required: true + parameters: + - name: zip_file_id + description: FileID for the ZIP file containing the GNUPG home directory + required: true + multiline: false + schema: + type: string + - name: password + description: Password to use for key store decryption + required: true + multiline: false + schema: + type: string +tags: + - Encryption +categories: + - Encryption +actions: + - name: encrypt_text + description: Encrypt text with gpg + parameters: + - name: clear_text + description: Clear text to encrypt + required: true + multiline: false + schema: + type: string + - name: recipients + description: List of key fingerprints separated by comma (,) + required: true + multiline: false + schema: + type: string + - name: always_trust + description: Skip key validation and assume that used keys are always fully trusted. + required: true + options: + - "false" + - "true" + schema: + type: bool + + - name: decrypt_text + description: Decrypt text with gpg + parameters: + - name: encrypted_text + description: Encrypted text message to decrypt + required: true + multiline: false + schema: + type: string + - name: always_trust + description: Skip key validation and assume that used keys are always fully trusted. + required: true + options: + - "false" + - "true" + schema: + type: bool + + - name: encrypt_file + description: Encrypt file with gpg + parameters: + - name: file_id + description: FileID of the clear text file to encrypt + required: true + multiline: false + schema: + type: file + - name: output_name + description: Name of the encrypted output file + required: true + multiline: false + schema: + type: string + - name: recipients + description: List of key fingerprints separated by comma (,) + required: true + multiline: false + schema: + type: string + - name: always_trust + description: Skip key validation and assume that used keys are always fully trusted. + required: true + options: + - "false" + - "true" + schema: + type: bool + - name: decrypt_file + description: Decrypt file with gpg + parameters: + - name: file_id + description: FileID of the encrypted file to decrypt + required: true + multiline: false + schema: + type: file + - name: output_name + description: Name of the decrypted output file + required: true + multiline: false + schema: + type: string + - name: always_trust + description: Skip key validation and assume that used keys are always fully trusted. + required: true + options: + - "false" + - "true" + schema: + type: bool + + returns: + schema: + type: string +large_image: data:image/png;base64,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 diff --git a/shuffle-tools/1.0.0/docker-compose.yml b/gpg-tools/1.1.0/docker-compose.yml similarity index 58% rename from shuffle-tools/1.0.0/docker-compose.yml rename to gpg-tools/1.1.0/docker-compose.yml index 40ee05f6..02b32361 100644 --- a/shuffle-tools/1.0.0/docker-compose.yml +++ b/gpg-tools/1.1.0/docker-compose.yml @@ -1,10 +1,10 @@ -version: '3.4' +version: "3.4" services: hello_world: build: context: . dockerfile: Dockerfile -# image: walkoff_registry:5000/walkoff_app_HelloWorld-v1-0 + # image: walkoff_registry:5000/walkoff_app_HelloWorld-v1-0 deploy: mode: replicated replicas: 10 @@ -13,8 +13,8 @@ services: restart: "no" secrets: - secret1 -secrets: - secret1: - file: ./secret_data - labels: - foo: bar +# secrets: +# secret1: +# file: ./secret_data +# labels: +# foo: bar diff --git a/gpg-tools/1.1.0/requirements.txt b/gpg-tools/1.1.0/requirements.txt new file mode 100644 index 00000000..1edb807d --- /dev/null +++ b/gpg-tools/1.1.0/requirements.txt @@ -0,0 +1,2 @@ +python-gnupg==0.4.6 +requests==2.32.4 \ No newline at end of file diff --git a/gpg-tools/1.1.0/src/app.py b/gpg-tools/1.1.0/src/app.py new file mode 100644 index 00000000..e8932462 --- /dev/null +++ b/gpg-tools/1.1.0/src/app.py @@ -0,0 +1,285 @@ +import os +import socket +import asyncio +import time +import random +import json +import subprocess +import requests +import tempfile +import gnupg +import zipfile +import shutil + + +from walkoff_app_sdk.app_base import AppBase + + +class Gpg(AppBase): + """ + An example of a Walkoff App. + Inherit from the AppBase class to have Redis, logging, and console logging set up behind the scenes. + """ + + __version__ = "1.1.0" + app_name = "Gpg Tools" + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def extract_archive(self, zip_file_id, fileformat="zip", password=None): + try: + return_data = {"success": False, "files": []} + to_be_uploaded = [] + item = self.get_file(zip_file_id) + return_ids = None + + self.logger.info("Working with fileformat %s" % fileformat) + with tempfile.TemporaryDirectory() as tmpdirname: + + # Get archive and save phisically + with open(os.path.join(tmpdirname, "archive"), "wb") as f: + f.write(item["data"]) + + # Grab files before, upload them later + + # Zipfile for zipped archive + if fileformat.strip().lower() == "zip": + try: + self.logger.info("Starting zip extraction") + with zipfile.ZipFile(os.path.join(tmpdirname, "archive")) as z_file: + if password: + self.logger.info("In zip extraction with password") + z_file.setpassword(bytes(password.encode())) + + self.logger.info("Past zip extraction") + for member in z_file.namelist(): + filename = os.path.basename(member) + if not filename: + continue + + source = z_file.open(member) + to_be_uploaded.append( + {"filename": source.name.split("/")[-1], "data": source.read()} + ) + + return_data["success"] = True + except (zipfile.BadZipFile, Exception): + return_data["files"].append( + { + "success": False, + "file_id": zip_file_id, + "filename": item["filename"], + "message": "File is not a valid zip archive", + } + ) + else: + return "No such format: %s" % fileformat + + self.logger.info("Breaking as this only handles one archive at a time.") + if len(to_be_uploaded) > 0: + return_ids = self.set_files(to_be_uploaded) + self.logger.info(f"Got return ids from files: {return_ids}") + + for i in range(len(return_ids)): + return_data["archive_id"] = zip_file_id + try: + return_data["files"].append( + { + "success": True, + "file_id": return_ids[i], + "filename": to_be_uploaded[i]["filename"], + } + ) + except: + return_data["files"].append( + { + "success": True, + "file_id": return_ids[i], + } + ) + else: + self.logger.info(f"No file ids to upload.") + return_data["success"] = False + return_data["files"].append( + { + "success": False, + "filename": "No data in archive", + "message": "Archive is empty", + } + ) + + return return_data + + except Exception as excp: + return {"success": False, "message": "%s" % excp} + + def get_auth(self, file_id): + item = self.get_file(file_id) + tmpdirname = f"/tmp/{file_id}" + + # Clean up all old stuff + if os.path.exists(tmpdirname): + shutil.rmtree(tmpdirname, ) + + # Get archive and save physically + os.mkdir(tmpdirname) + with open(os.path.join(tmpdirname, "archive"), "wb") as f: + f.write(item["data"]) + + # Grab files before, upload them later + gpgfound = False + with zipfile.ZipFile(os.path.join(tmpdirname, "archive")) as z_file: + print("Past zip extraction") + for member in z_file.namelist(): + print(member) + if member == ".gnupg/": + gpgfound = True + + z_file.extract(member, tmpdirname) + + os.remove(os.path.join(tmpdirname, "archive")) + + if gpgfound: + tmpdirname = os.path.join(tmpdirname, ".gnupg") + + try: + gpg = gnupg.GPG(gnupghome=tmpdirname) + except TypeError: + gpg = gnupg.GPG(homedir=tmpdirname) + + return gpg + + def cleanup(self, zip_file_id): + + tmpdirname = f"/tmp/{zip_file_id}" + + if os.path.exists(tmpdirname): + shutil.rmtree(tmpdirname) + self.logger.debug(">> Cleanup complete") + + return + + + def decrypt_text( + self, zip_file_id, encrypted_text, password, always_trust + ): + gpg = self.get_auth(zip_file_id) + self.logger.debug(">> Created GPG instance") + + decrypted_text = gpg.decrypt( + encrypted_text, + passphrase=password, + always_trust=always_trust + ) + + # Delete the downloaded keystore + self.cleanup(zip_file_id) + + if decrypted_text.ok: + return {"success": True, "data": decrypted_text.data.decode('utf-8')} + else: + return {"success": False, "error": decrypted_text.stderr } + + + + def encrypt_text( + self, zip_file_id, clear_text, recipients, always_trust + ): + gpg = self.get_auth(zip_file_id) + self.logger.debug(">> Created GPG instance") + + # Build list of recipients from comma-separated string + recipients = recipients.split(',') + + self.logger.debug(f">> Recipients: {recipients}") + + encrypted_text = gpg.encrypt( + clear_text, + recipients=recipients, + always_trust=always_trust + ) + + # Delete the downloaded keystore + self.cleanup(zip_file_id) + + if encrypted_text.ok: + return {"success": True, "data": encrypted_text.data.decode('utf-8')} + else: + return {"success": False, "error": encrypted_text.stderr } + + + def decrypt_file( + self, zip_file_id, password, file_id, output_name, always_trust + ): + gpg = self.get_auth(zip_file_id) + self.logger.debug(">> Created GPG instance") + + if file_id["success"] == False: + return "Error managing files." + + always_trust = True if always_trust.lower() == "true" else False + + ret_decrypt = gpg.decrypt( + file_id["data"], + passphrase=password, + always_trust=always_trust, + ) + + # Delete the downloaded keystore + self.cleanup(zip_file_id) + + if ret_decrypt.ok: + self.logger.debug(">> File decrypted") + + file_id = self.set_files([{"filename": output_name, "data": ret_decrypt.data}]) + if len(file_id) == 1: + file_id = file_id[0] + return {"success": True, "id": file_id} + else: + return {"success": False, "error": ret_decrypt.stderr} + + def encrypt_file( + self, zip_file_id, file_id, output_name, recipients, always_trust + ): + gpg = self.get_auth(zip_file_id) + self.logger.debug(">> Created GPG instance") + + if file_id["success"] == False: + return "Error managing files." + + always_trust = True if always_trust.lower() == "true" else False + + # Build list of recipients from comma-separated string + recipients = recipients.split(',') + + self.logger.debug(f">> Recipients: {recipients}") + + ret_encrypt = gpg.encrypt( + file_id['data'], + recipients=recipients, + always_trust=always_trust + ) + + # Delete the downloaded keystore + self.cleanup(zip_file_id) + + if ret_encrypt.ok: + self.logger.debug(">> File encrypted") + + file_id = self.set_files([{"filename": output_name, "data": ret_encrypt.data}]) + if len(file_id) == 1: + file_id = file_id[0] + return {"success": True, "id": file_id} + else: + return {"success": False, "error": ret_encrypt.stderr} + + +if __name__ == "__main__": + Gpg.run() diff --git a/gpg-tools/README.md b/gpg-tools/README.md new file mode 100644 index 00000000..16d42d28 --- /dev/null +++ b/gpg-tools/README.md @@ -0,0 +1,18 @@ +# GPG Tools +GPG tools is a utility app can help with encryption and decryption of text and files. +It requires your own GPG keystore containing private and public keys, along with the password to access the keystore. + +## Authentication +Authentication for the app is necessary in order to decrypt or encrypt files or data. +How this is handled from version 1.1.0 is through a Zip file with all your resources, uploaded to the Shuffle File storage. +The ZIP archive must contain the entire GnuPG Home Directory, named '.gnupg' + +**Required Authentication Arguments:** +- Zip_File_ID: Points to the File ID of the Zip file containing your Private & Public key(s) +- Password: The password that protects your Private Key + +Getting the ZIP's File ID: +1. Create your public & Private key with `gpg --full-gen-key` +2. A GPG Home Dir is created, under `~/.gnupg` +3. Compress the GPH Home Dir `zip -r gpg.zip .gnupg/` +4. Upload the ZIP file `gpg.zip` to Shuffle Files and obtain the FileID for the Zip file. \ No newline at end of file diff --git a/ad-ldap/1.0.0/Dockerfile b/gws/1.0.0/Dockerfile similarity index 100% rename from ad-ldap/1.0.0/Dockerfile rename to gws/1.0.0/Dockerfile diff --git a/gws/1.0.0/README.md b/gws/1.0.0/README.md new file mode 100644 index 00000000..5c8eb2e4 --- /dev/null +++ b/gws/1.0.0/README.md @@ -0,0 +1,40 @@ +## Google Workspace +An app for interacting with Google Workspace or GWS. +## Requirements +1) Enable the Admin SDK API from GCP console. + - Login to Google cloud (Make sure you are using the same administrator acount that you're using for Google Workspace) and In the navigation menu on the left-hand side, click on “APIs & Services” > “Library”. + - In the API Library, use the search bar to find the "Admin SDK". Click on it to open the API page. + - Click the “Enable” button to activate the Admin SDK API for your project. + 2) Create a Service account. + - Go to the navigation menu, and select “IAM & Admin” > “Service Accounts”. + - Click on “Create Service Account” at the top of the page. + - Enter a service account name and description, then click “Create”. + - You can skip the permission part here as we will be adding persmissions from GWS console later on. + - In the service account details page, click on “Keys”. + - Click on “Add Key” and select “Create new key”. + - Choose “JSON” as the key type and click “Create”. This will download the JSON key file which contains the “client_id”. Note down this client ID. + + 3) Subject (Email address associated with the service account) + - Note down the email address associated with the service account you just created it'll be used in the authentication in Shuffle. + 4) Adding permissions to the service account from GWS console. + - Signin to the Google Workspace admin console. + - In the Admin console, locate the sidebar and navigate to Security > API controls. This area allows you to manage third-party and internal application access to your Google Workspace data. + - Under the Domain-wide delegation section, click on “Manage Domain Wide Delegation” to view and configure client access. + - If the service account client ID is not listed, you will add it; if it is already listed but you need to update permissions, click on the service account’s client ID. To add a new client ID: + - Click on Add new. + - Enter the Client ID of the service account you noted earlier when creating the service account in GCP. + - In the OAuth Scopes field, enter the scopes required for your service account to function correctly. OAuth Scopes specify the permissions that your application requests. + - Depending on the actions you want to use below are the OAuth scopes required. + +| Action | OAuth Scope | +|---------------------|---------------------------------------------------------------------------------------------------------------------------------------------| +| Reset User Password | `https://www.googleapis.com/auth/admin.directory.user` | +| Suspend User | `https://www.googleapis.com/auth/admin.directory.user` | +| Get User Devices |`https://www.googleapis.com/auth/admin.directory.device.mobile` | +| Reactivate User | `https://www.googleapis.com/auth/admin.directory.user` + +## Authentication +1) Upload the Service account JSON file in to the Shuffle files and copy the file id. +2) Now, Inside the GWS app authentication in Shuffle; use the file id you just copied and in subject use the email address asscoitate with your service account. + + diff --git a/gws/1.0.0/api.yaml b/gws/1.0.0/api.yaml new file mode 100644 index 00000000..a879728b --- /dev/null +++ b/gws/1.0.0/api.yaml @@ -0,0 +1,106 @@ +app_version: 1.0.0 +name: Google Workspace +description: Manage Google Workspace with Shuffle +contact_info: + name: "dhaval055" + url: https://github.com/dhaval055 +tags: + - Assets +categories: + - Assets +authentication: + required: true + parameters: + - name: service_account_file_id + description: Upload a service account file to Shuffle and use the file ID here. + example: "file_id" + required: true + schema: + type: string + - name: subject + description: User email associated with service account. + example: "admin@org.com" + required: true + schema: + type: string +actions: + - name: reset_user_password + description: Change GWS user password. + parameters: + - name: user_email + description: User email you want to reset password of. + required: true + multiline: false + example: 'testuser@testorg.com' + schema: + type: string + - name: new_password + description: Password you want to set. If you do not provide this value then a random password will be generated. + required: false + multiline: false + example: "*******" + schema: + type: string + returns: + schema: + type: string + - name: get_user_devices + description: Get GWS user devices. + parameters: + - name: user_email + description: User email you want to reset password of. + required: true + multiline: false + example: 'testuser@testorg.com' + schema: + type: string + - name: customer_id + description: Customer ID of the account. Can be found in admin console under account -> account settings. + required: true + multiline: false + example: "C02dnh9vw" + schema: + type: string + returns: + schema: + type: string + - name: suspend_user + description: Suspend GWS user. + parameters: + - name: user_email + description: User email you want to reset password of. + required: true + multiline: false + example: 'testuser@testorg.com' + schema: + type: string + returns: + schema: + type: string + - name: reactivate_user + description: Reactivate the suspended GWS user. + parameters: + - name: service_account_file_id + description: Upload a service account file to Shuffle and use the file ID here. + example: "file_id" + required: true + schema: + type: string + - name: subject + description: User email associated with service account. + required: true + multiline: false + example: 'adminuser@testorg.com' + schema: + type: string + - name: user_email + description: User email you want to reset password of. + required: true + multiline: false + example: 'testuser@testorg.com' + schema: + type: string + returns: + schema: + type: string +large_image: data:image/png;base64,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 diff --git a/gws/1.0.0/requirements.txt b/gws/1.0.0/requirements.txt new file mode 100644 index 00000000..a3b996d6 --- /dev/null +++ b/gws/1.0.0/requirements.txt @@ -0,0 +1,6 @@ +requests==2.32.4 +google-auth==1.28.0 +google-auth-oauthlib==0.4.3 +google-auth-httplib2==0.0.4 +google-api-python-client==2.0.2 + diff --git a/gws/1.0.0/src/app.py b/gws/1.0.0/src/app.py new file mode 100644 index 00000000..211055c3 --- /dev/null +++ b/gws/1.0.0/src/app.py @@ -0,0 +1,130 @@ +import socket +import asyncio +import time +import random +import json +import requests +import secrets +import string + +from walkoff_app_sdk.app_base import AppBase + +from google.oauth2 import service_account +from googleapiclient.discovery import build + + +class Gws(AppBase): + __version__ = "1.0.0" + app_name = "Google Workspace" + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def reset_user_password(self, service_account_file_id, subject ,user_email,new_password): + service_account_file = self.get_file(service_account_file_id) + service_account_info = service_account_file['data'].decode() + + def generate_secure_password(length=12): + characters = string.ascii_letters + string.digits + string.punctuation + secure_password = ''.join(secrets.choice(characters) for i in range(length)) + return secure_password + + if new_password == "": + print("Generating new password") + new_password = generate_secure_password() + + try: + service_account_info = json.loads(service_account_info) + except Exception as e: + print(f"Error loading service account file: {e}") + return {"success": False, "message": f"Error loading service account file: {e}"} + + SCOPES = ['https://www.googleapis.com/auth/admin.directory.user'] + + creds = service_account.Credentials.from_service_account_info(service_account_info, scopes=SCOPES,subject=subject) + service = build('admin', 'directory_v1', credentials=creds) + + try: + result = service.users().update(userKey=user_email, body={'password': new_password}).execute() + return {"success": True, "message": f"Password for {user_email} reset successfully.", "new_password": new_password} + except Exception as e: + return {"success": False, "message": f"Error resetting password: {e}"} + + def get_user_devices(self, service_account_file_id, subject ,user_email, customer_id): + service_account_file = self.get_file(service_account_file_id) + service_account_info = service_account_file['data'].decode() + + try: + service_account_info = json.loads(service_account_info) + except Exception as e: + print(f"Error loading service account file: {e}") + return {"success": False, "message": f"Error loading service account file: {e}"} + + SCOPES = ['https://www.googleapis.com/auth/admin.directory.device.mobile'] + + creds = service_account.Credentials.from_service_account_info(service_account_info, scopes=SCOPES,subject=subject) + service = build('admin', 'directory_v1', credentials=creds) + + query = f'email:{user_email}' + + try: + results = service.mobiledevices().list(customerId=customer_id, query=query).execute() + devices = results.get('mobiledevices', []) + except Exception as e: + return {"success": False, "message": f"Error getting devices: {e}"} + + return {"success": True, "message": f"Devices for {user_email} retrieved successfully.", "devices": devices} + + def suspend_user(self, service_account_file_id, subject ,user_email): + service_account_file = self.get_file(service_account_file_id) + service_account_info = service_account_file['data'].decode() + + try: + service_account_info = json.loads(service_account_info) + except Exception as e: + print(f"Error loading service account file: {e}") + return {"success": False, "message": f"Error loading service account file: {e}"} + + SCOPES = ['https://www.googleapis.com/auth/admin.directory.user'] + + creds = service_account.Credentials.from_service_account_info(service_account_info, scopes=SCOPES,subject=subject) + service = build('admin', 'directory_v1', credentials=creds) + + try: + result = service.users().update(userKey=user_email,body={'suspended': True}).execute() + except Exception as e: + return {"success": False, "message": f"Error suspending user: {e}"} + + return {"success": True, "message": f"{user_email} suspended successfully."} + + def reactivate_user(self, service_account_file_id, subject ,user_email): + service_account_file = self.get_file(service_account_file_id) + service_account_info = service_account_file['data'].decode() + + try: + service_account_info = json.loads(service_account_info) + except Exception as e: + print(f"Error loading service account file: {e}") + return {"success": False, "message": f"Error loading service account file: {e}"} + + SCOPES = ['https://www.googleapis.com/auth/admin.directory.user'] + + creds = service_account.Credentials.from_service_account_info(service_account_info, scopes=SCOPES,subject=subject) + service = build('admin', 'directory_v1', credentials=creds) + + try: + result = service.users().update(userKey=user_email,body={'suspended': False}).execute() + except Exception as e: + return {"success": False, "message": f"Error reactivating user: {e}"} + + return {"success": True, "message": f"{user_email} reactivated successfully."} + + +if __name__ == "__main__": + Gws.run() diff --git a/azure-sentinel/1.0.0/Dockerfile b/harfanglab-edr/1.0.0/Dockerfile similarity index 100% rename from azure-sentinel/1.0.0/Dockerfile rename to harfanglab-edr/1.0.0/Dockerfile diff --git a/harfanglab-edr/1.0.0/api.yaml b/harfanglab-edr/1.0.0/api.yaml new file mode 100644 index 00000000..938b0dd7 --- /dev/null +++ b/harfanglab-edr/1.0.0/api.yaml @@ -0,0 +1,974 @@ +app_version: 1.0.0 +name: HarfangLab EDR +description: The HarfangLab EDR app allows to manage an external HarfangLab EDR stack. +contact_info: + name: "HarfangLab Support Team" + url: https://harfanglab.io + email: support@harfanglab.fr +tags: + - Testing +categories: + - Other +authentication: + required: true + parameters: + - name: base_url + description: URL of the HarfangLab EDR Manager + example: "https://hurukai:8443" + required: true + schema: + type: string + - name: api_key + description: API key + example: "xxxx-xxxx-xxxx-xxxx" + required: true + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string +actions: + - name: isolate_endpoint + description: Isolate an endpoint + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: agent_id + description: EDR agent identifier + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + returns: + schema: + type: string + - name: unisolate_endpoint + description: Reconnect an endpoint + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: agent_id + description: EDR agent identifier + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + returns: + schema: + type: string + - name: run_job + description: Run a job + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: job_name + description: HarfangLab EDR's job name + required: true + multiline: false + example: 'getProcesses' + options: + - getProcesses + - getServices + - getPipes + - getDrivers + - getPrefetches + - getScheduledTasks + - getRunKeys + - getStartupFiles + - getPersistence + - getWMI + - getNetworkShares + - getSessions + - getArtifactMFT + - getArtifactHives + - getArtifactEvtx + - getArtifactLogs + - getArtifactFilesystem + - getArtifactUSN + - getArtifactPrefetch + - getArtifactAll + - getArtifactRamdump + schema: + type: string + - name: agent_id + description: EDR agent identifier + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: job_title + description: Job title + required: false + multiline: false + example: 'Job title' + schema: + type: string + - name: job_description + description: Job description + required: false + multiline: true + example: 'Job description' + schema: + type: string + - name: job_timeout + description: Job timeout (in seconds) + required: false + multiline: false + example: '600' + schema: + type: string + returns: + schema: + type: string + + - name: dump_process + description: Dump a process' memory + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: agent_id + description: EDR agent identifier + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: process_uuid + description: Process unique identifier + required: true + multiline: false + example: '' + schema: + type: string + - name: job_timeout + description: Job timeout (in seconds) + required: false + multiline: false + example: '600' + schema: + type: string + returns: + schema: + type: string + + - name: kill_process + description: Kill a process + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: agent_id + description: EDR agent identifier + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: process_uuid + description: Process unique identifier + required: true + multiline: false + example: '' + schema: + type: string + - name: job_timeout + description: Job timeout (in seconds) + required: false + multiline: false + example: '600' + schema: + type: string + returns: + schema: + type: string + + - name: telemetry_search_hash + description: Search a hash in HarfangLab EDR's telemetry + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: hash + description: File hash + required: true + multiline: false + example: '' + schema: + type: string + - name: process_name + description: Process name + required: false + multiline: false + example: '' + schema: + type: string + - name: image_name + description: Image name + required: false + multiline: false + example: '' + schema: + type: string + - name: limit + description: Maximum number of items to collect from telemetry searches + required: false + multiline: false + example: '10' + schema: + type: string + + returns: + schema: + type: string + + - name: telemetry_search_driver_by_hash + description: Search a driver load in HarfangLab EDR's telemetry per hash + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: hash + description: File hash + required: true + multiline: false + example: '' + schema: + type: string + - name: limit + description: Maximum number of items to collect from telemetry searches + required: false + multiline: false + example: '10' + schema: + type: string + returns: + schema: + type: string + + - name: telemetry_search_driver_by_filename + description: Search a driver load in HarfangLab EDR's telemetry per filename + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: filename + description: File name + required: true + multiline: false + example: '' + schema: + type: string + - name: limit + description: Maximum number of items to collect from telemetry searches + required: false + multiline: false + example: '10' + schema: + type: string + returns: + schema: + type: string + + - name: telemetry_search_destination_ip + description: Search an IP as a destination in HarfangLab EDR's telemetry + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: ip + description: IP address to search + required: true + multiline: false + example: '' + schema: + type: string + - name: limit + description: Maximum number of items to collect from telemetry searches + required: false + multiline: false + example: '10' + schema: + type: string + returns: + schema: + type: string + + - name: telemetry_search_source_ip + description: Search an IP as a source in HarfangLab EDR's telemetry + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: ip + description: IP address to search + required: true + multiline: false + example: '' + schema: + type: string + - name: limit + description: Maximum number of items to collect from telemetry searches + required: false + multiline: false + example: '10' + schema: + type: string + returns: + schema: + type: string + + - name: telemetry_get_binary + description: Get binary information and download link + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: hash + description: File hash + required: true + multiline: false + example: '' + schema: + type: string + returns: + schema: + type: string + + - name: add_ioc_to_source + description: Add an IOC to a Threat Intelligence source + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: ioc_type + description: IOC type + required: true + multiline: false + example: '' + options: + - ip_src + - ip_dst + - ip_both + - hash + - filename + - filepath + schema: + type: string + - name: ioc_value + description: IOC value + required: true + multiline: false + example: '1.1.1.1, 1.1.1.1|80, 0123456789ABCDEF, filename.docx' + schema: + type: string + - name: ioc_comment + description: IOC comment + required: false + multiline: false + example: '' + schema: + type: string + - name: ioc_status + description: Image name + required: false + multiline: false + example: '' + options: + - stable + - testing + schema: + type: string + - name: source_name + description: Threat Intelligence source name + required: true + multiline: false + example: '' + schema: + type: string + returns: + schema: + type: string + + - name: change_security_event_status + description: Change the status of a security event + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: event_id + description: HarfangLab event id + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: status + description: Event status + required: true + multiline: false + example: 'new' + options: + - New + - Investigating + - False Positive + - Closed + schema: + type: string + returns: + schema: + type: string + + - name: fetch_incidents + description: Fetches security events from the EDR Manager + parameters: + - name: base_url + description: HarfangLab EDR Manager's URL + required: true + multiline: false + example: 'https://hurukai:8443/' + schema: + type: string + - name: api_key + description: HarfangLab EDR's API Key + required: true + multiline: false + example: 'xyzawxkjnsdkfjnsdf' + schema: + type: string + - name: verify_certificate + description: Certificate verification + required: true + example: 'true' + options: + - false + - true + schema: + type: string + - name: http_proxy + description: HTTP proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: https_proxy + description: HTTPS proxy + required: false + example: 'http://my-proxy:3128' + schema: + type: string + - name: first_fetch + description: Start fetching alerts whose creation date is higher than now minus days. + required: false + multiline: false + example: '10' + schema: + type: string + - name: alert_status + description: Alert status + required: false + multiline: false + example: 'ACTIVE' + options: + - ALL + - ACTIVE + - CLOSED + schema: + type: string + - name: alert_type + description: Comma-separated list of types of alerts to fetch (sigma, yara, hlai, vt, ransom, ioc, glimps, orion...). + required: false + multiline: false + example: 'sigma,yara,hlai,ioc,ransom' + schema: + type: string + - name: min_severity + description: Minimum severity of alerts to fetch + required: false + multiline: false + example: 'High' + options: + - Informational + - Low + - Medium + - High + - Critical + schema: + type: string + - name: max_fetch + description: Maximum number of alerts to fetch + required: false + multiline: false + example: '10' + schema: + type: string + - name: only_new_alerts + description: Fetches only never fetched alerts + required: false + multiline: false + example: 'true' + options: + - false + - true + schema: + type: string + - name: delay + description: Number of seconds back in the past for the upper limit of security event timestamps (keep a value of minimum 120 secondes) + required: true + multiline: false + example: 'true' + schema: + type: string + - name: exclude_rules + description: Do not take these rule names into account + required: false + multiline: true + example: 'Windows Defender has taken action from malware' + schema: + type: string + + returns: + schema: + type: string + +large_image: data:image/jpg;base64,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 diff --git a/harfanglab-edr/1.0.0/requirements.txt b/harfanglab-edr/1.0.0/requirements.txt new file mode 100644 index 00000000..b26fe9ce --- /dev/null +++ b/harfanglab-edr/1.0.0/requirements.txt @@ -0,0 +1,4 @@ +requests==2.32.4 +python-dateutil==2.8.2 +DateTime==4.7 +Markdown==3.4.1 diff --git a/harfanglab-edr/1.0.0/src/app.py b/harfanglab-edr/1.0.0/src/app.py new file mode 100644 index 00000000..dfe7889c --- /dev/null +++ b/harfanglab-edr/1.0.0/src/app.py @@ -0,0 +1,221 @@ +import socket +import asyncio +import time +import random +import json +from datetime import datetime, timedelta, timezone +import requests +import dateutil.parser +from harfanglab_sdk import * + +from walkoff_app_sdk.app_base import AppBase + + +class HarfangLabEDR(AppBase): + __version__ = "1.0.0" + app_name = "HarfangLab EDR" # this needs to match "name" in api.yaml + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def fetch_incidents(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, first_fetch = None, alert_status = None, alert_type = None, min_severity = None, max_fetch = None, only_new_alerts = None, delay = 0, exclude_rules = None): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + try: + + excluded_rules = None + + last_fetch = None + + if only_new_alerts == 'true': + last_fetch = self.get_cache('last_fetch').get('value', None) + + if exclude_rules: + excluded_rules = exclude_rules.lower().split('\n') + + (latest_created_time_us, events) = conn.fetch_security_events(first_fetch, alert_status, alert_type, min_severity, max_fetch, last_fetch, delay, excluded_rules) + + if only_new_alerts == 'true': + self.set_cache('last_fetch', latest_created_time_us) + + return events + + except Exception as e: + raise Exception(f'Failed to fetch incidents: {str(e)}') + + + def add_ioc_to_source(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, ioc_value, ioc_type, ioc_comment, ioc_status, source_name): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + try: + return conn.add_ioc_to_source(ioc_value, ioc_type, ioc_comment, ioc_status, source_name) + except Exception as e: + return f'Failed to add IOC {ioc_value} to source {source_name}: %s' % (str(e)) + + def change_security_event_status(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, event_id, status): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + try: + return conn.change_security_event_status(event_id, status) + except Exception as e: + return f'Failed to change the status of the security incident: %s' % (str(e)) + + def isolate_endpoint(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, agent_id): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + try: + self.logger.debug(f'verify: {conn.verify}') + return conn.isolate_endpoint(agent_id) + except Exception as e: + return f'Failed to isolate endpoint: %s' % (str(e)) + + def unisolate_endpoint(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, agent_id): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + try: + return conn.unisolate_endpoint(agent_id) + except Exception as e: + return f'Failed to unisolate endpoint: %s' % (str(e)) + + def run_job(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, job_name, agent_id, job_title, job_description, job_timeout): + if not job_timeout or job_timeout == '': + job_timeout = '600' + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + + try: + return conn.run_job(job_name, agent_id, job_title, job_description, int(job_timeout)) + except Exception as e: + return f'Failed to run job: %s' % (str(e)) + + def dump_process(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, agent_id, process_uuid, job_timeout): + if not job_timeout or job_timeout == '': + job_timeout = '600' + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + + try: + return conn.dump_process(agent_id, process_uuid, int(job_timeout)) + except Exception as e: + return f'Failed to dump process: %s' % (str(e)) + + def kill_process(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, agent_id, process_uuid, job_timeout): + if not job_timeout or job_timeout == '': + job_timeout = '600' + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + + try: + return conn.kill_process(agent_id, process_uuid, int(job_timeout)) + except Exception as e: + return f'Failed to kill process: %s' % (str(e)) + + + def telemetry_search_hash(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, hash, process_name, image_name, limit): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + if not limit or limit == '': + limit = None + else: + limit = int(limit) + + args = { + 'hash': hash, + 'process_name': process_name, + 'image_name': image_name, + 'limit': limit + } + try: + return conn.search_telemetry('searchHash', args) + except Exception as e: + return f'Failed to search in telemetry: %s' % (str(e)) + + def telemetry_search_driver_by_hash(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, hash, limit): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + if not limit or limit == '': + limit = None + else: + limit = int(limit) + + args = { + 'hash': hash, + 'limit': limit + } + try: + return conn.search_telemetry('searchDriverByHash', args) + except Exception as e: + return f'Failed to search in telemetry: %s' % (str(e)) + + def telemetry_search_driver_by_filename(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, filename, limit): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + if not limit or limit == '': + limit = None + else: + limit = int(limit) + + args = { + 'filename': filename, + 'limit': limit + } + try: + return conn.search_telemetry('searchDriverByFileName', args) + except Exception as e: + return f'Failed to search in telemetry: %s' % (str(e)) + + def telemetry_search_destination_ip(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, ip, limit): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + if not limit or limit == '': + limit = None + else: + limit = int(limit) + + args = { + 'ip': ip, + 'limit': limit + } + try: + return conn.search_telemetry('searchDestinationIP', args) + except Exception as e: + return f'Failed to search in telemetry: %s' % (str(e)) + + def telemetry_search_source_ip(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, ip, limit): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + if not limit or limit == '': + limit = None + else: + limit = int(limit) + + args = { + 'ip': ip, + 'limit': limit + } + try: + return conn.search_telemetry('searchSourceIP', args) + except Exception as e: + return f'Failed to search in telemetry: %s' % (str(e)) + + def telemetry_get_binary(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, hash): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + + args = { + 'hash': hash + } + try: + return conn.search_telemetry('getBinary', args) + except Exception as e: + return f'Failed to search in telemetry: %s' % (str(e)) + + def telemetry_search_iocs(self, base_url, api_key, verify_certificate, http_proxy, https_proxy, iocs, limit, search_types): + conn = HarfangLabConnector(base_url, api_key, verify_certificate, http_proxy, https_proxy, self.logger) + if not limit or limit == '': + limit = None + else: + limit = int(limit) + + iocs_json = json.loads(iocs) + search_types_array = search_types.split(',') + try: + return conn.search_multiple_iocs_in_telemetry(iocs_json, limit, search_types_array) + except Exception as e: + return f'Failed to search IOCs in telemetry: %s' % (str(e)) + + +if __name__ == "__main__": + HarfangLabEDR.run() diff --git a/harfanglab-edr/1.0.0/src/harfanglab_sdk.py b/harfanglab-edr/1.0.0/src/harfanglab_sdk.py new file mode 100644 index 00000000..9a07c504 --- /dev/null +++ b/harfanglab-edr/1.0.0/src/harfanglab_sdk.py @@ -0,0 +1,1951 @@ +import requests +import json +from datetime import datetime, timedelta, timezone +import requests +import dateutil.parser +import time +import logging +import markdown + +STRING_TYPES = (str, bytes) +MARKDOWN_CHARS = r"\`*_{}[]()#+-!|" + +def get_params(params): + res = [] + if params: + for k, v in params.items(): + res.append(f'{k}={v}') + return '?' + '&'.join(res) + else: + return '' + + +def string_escape(st): + """ + Escape any chars that might break a markdown string + + :type st: ``str`` + :param st: The string to be modified (required) + + :return: A modified string + :rtype: ``str`` + """ + st = st.replace('\r\n', '
') # Windows + st = st.replace('\r', '
') # old Mac + st = st.replace('\n', '
') # Unix + + for c in ('|', '`'): + st = st.replace(c, '\\' + c) + + return st + +def get_markdown_from_table(name, t, headers=None, headerTransform=None, url_keys=None): + """ + Converts a JSON table to a Markdown table + + :type name: ``str`` + :param name: The name of the table (required) + + :type t: ``dict`` or ``list`` + :param t: The JSON table - List of dictionaries with the same keys or a single dictionary (required) + + :type headers: ``list`` or ``string`` + :param headers: A list of headers to be presented in the output table (by order). If string will be passed + then table will have single header. Default will include all available headers. + + :type headerTransform: ``function`` + :param headerTransform: A function that formats the original data headers (optional) + + :type url_keys: ``list`` + :param url_keys: a list of keys in the given JSON table that should be turned in to clickable + + :return: A string representation of the markdown table + :rtype: ``str`` + """ + # Turning the urls in the table to clickable + if url_keys: + t = url_to_clickable_markdown(t, url_keys) + + result = '' + if name: + result = '### ' + name + '\n' + + if not t or len(t) == 0: + result += '**No entries.**\n' + return result + + if not headers and isinstance(t, dict) and len(t.keys()) == 1: + # in case of a single key, create a column table where each element is in a different row. + headers = list(t.keys()) + t = list(t.values())[0] + + if not isinstance(t, list): + t = [t] + + if headers and isinstance(headers, STRING_TYPES): + headers = [headers] + + if not isinstance(t[0], dict): + # the table contains only simple objects (strings, numbers) + # should be only one header + if headers and len(headers) > 0: + header = headers[0] + t = [{header: item} for item in t] + else: + raise Exception( + "Missing headers param for get_markdown_from_table. Example: headers=['Some Header']") + + # in case of headers was not provided (backward compatibility) + if not headers: + headers = list(t[0].keys()) + headers.sort() + + if t and len(headers) > 0: + newHeaders = [] + if headerTransform is None: # noqa + def headerTransform(s): return string_escape(s.title()) # noqa + for header in headers: + newHeaders.append(headerTransform(header)) + result += '|' + if len(newHeaders) == 1: + result += newHeaders[0] + else: + result += '|'.join(newHeaders) + result += '|\n' + sep = '---' + result += '|' + '|'.join([sep] * len(headers)) + '|\n' + for entry in t: + entry_copy = entry.copy() + + vals = [string_escape(str(entry_copy.get(h, '') if entry_copy.get( + h) is not None else '')) for h in headers] + + # this pipe is optional + result += '| ' + try: + result += ' | '.join(vals) + except UnicodeDecodeError: + vals = [str(v) for v in vals] + result += ' | '.join(vals) + result += ' |\n' + + else: + result += '**No entries.**\n' + + return result + +def url_to_clickable_markdown(data, url_keys): + """ + Transform the urls fields into clickable url in markdown. + + :type data: ``[Union[str, List[Any], Dict[str, Any]]]`` + :param data: a dictionary or a list containing data with some values that are urls + + :type url_keys: ``Dict[str, str]`` + :param url_keys: a dict whose keys correspond to the url fields to turn into clickable, and values correspond to the link texts + + :return: markdown format for clickable url + :rtype: ``[Union[str, List[Any], Dict[str, Any]]]`` + """ + + if isinstance(data, list): + data = [url_to_clickable_markdown(item, url_keys) for item in data] + + elif isinstance(data, dict): + data = {key: get_clickable_url(value, url_keys.get(key, None)) if key in url_keys else url_to_clickable_markdown(data[key], url_keys) + for key, value in data.items()} + + return data + +def get_clickable_url(url, text=None): + """ + Make the given url clickable in markdown format + + :type url: ``Union[List[str], str]`` + :param url: the url of interest or a list of urls + + :type text: ``str`` + :param text: the link text to print + + :return: markdown format for clickable url + :rtype: ``str`` + + """ + if not url: + return None + elif isinstance(url, list): + if text: + return ['[{}]({})'.format(text, item) for item in url] + else: + return ['[{}]({})'.format(item, item) for item in url] + + if text: + return '[{}]({})'.format(text, url) + else: + return '[{}]({})'.format(url, url) + +class HarfangLabConnector: + + SEVERITIES = ['Informational', 'Low', 'Medium', 'High', 'Critical'] + MAX_NUMBER_OF_ALERTS_PER_CALL = 200 + MAX_NUMBER_OF_ITEMS = 10000 + + def __init__(self, base_url, api_key, verify_certificate=True, http_proxy=None, https_proxy=None, logger=logging.getLogger('HarfangLab SDK')): + """ + Initialize a HarfangLab EDR connector + + :param base_url: The base_url of the HarfangLab EDR manager (https://hurukai:8443) + :param api_key: The API key to use to connect to the EDR Manager + :param verify_certificate: Either a boolean True or False or a string 'true' or 'false' + :param http_proxy: Proxy to use for HTTP connections + :param https_proxy: Proxy to use for HTTPS connections + :param logger: Logger to use + """ + + self.base_url = base_url.rstrip('/') + self.api_key = api_key + self.hlSession = requests.Session() + self.logger = logger + + self.verify = True + if type(verify_certificate) == bool: + self.verify = verify_certificate + elif isinstance(verify_certificate, str) and verify_certificate.lower() == 'false': + self.verify = False + else: + self.verify = True + + self.logger.debug(f'Verify: {self.verify}') + + self.hlSession.verify = self.verify + self.hlSession.headers.update( + { + 'Authorization': f'Token {self.api_key}' + } + ) + proxies = {} + if http_proxy and len(http_proxy) > 4: + proxies['http'] = http_proxy + if https_proxy and len(http_proxy) > 5: + proxies['https'] = https_proxy + self.hlSession.proxies = proxies + self.logger = logger + + def __get_first_element(self, table): + """ + Return the first element of a table + + :type table: ``List[Any]`` + :param table: The table to extract the first element of + + :return: The first element of the table + :rtype: ``Any`` + """ + + if table and isinstance(table, list) and len(table) > 0: + return table[0] + else: + return None + + def __flatten_table(self, table): + """ + Return a flattened string of all elements of a table joined with a ',' + + :type table: ``List[Any]`` + :param table: The table to flatten + + :return: The flattened table + :rtype: ``str`` + """ + + if table and isinstance(table, list) and len(table) > 0: + return ', '.join(table) + else: + return None + + def __get_hash_parameter(self, binary_hash): + """ + Return a tuple (hash filter name, hash value) to be used as filter for the HarfangLab API + + :type binary_hash: ``str`` + :param str: The raw binary hash (either MD5, SHA1 or SHA256) + + :return: A tuple (hash filter name, hash value) + :rtype: ``Tuple(str,str)`` + """ + + hash_type = None + if binary_hash is not None: + if len(binary_hash) == 64: + hash_type = "sha256" + elif len(binary_hash) == 40: + hash_type = "sha1" + elif len(binary_hash) == 32: + hash_type = "md5" + + return (f'hashes.{hash_type}__exact', binary_hash) + + return (None, None) + + def __generate_link_for_binary(self, v): + """ + Return a HarfangLab download link for a binary including a temporary api token + + :type v: ``str`` + :param v: The binary SHA256 hash + + :return: A download link + :rtype: ``str`` + """ + + url = f'{self.base_url}/api/user/api_token/' + api_token = None + + try: + token = self.hlSession.post( + url=url, data={'is_expirable': True}).json() + if 'api_token' in token: + api_token = token['api_token'] + link = f'{self.base_url}/api/data/telemetry/Binary/download/{v}' + if api_token: + link += f'?hl_expiring_key={api_token}' + return link + + except Exception as e: + return 'N/A' + + def __generate_link_for_artifact(self, v): + """ + Return a HarfangLab download link for a job artifact from its id + + :type v: ``str`` + :param v: The artifact id + + :return: A download link + :rtype: ``str`` + """ + + url = f'{self.base_url}/api/user/api_token/' + api_token = None + + try: + token = self.hlSession.post( + url=url, data={'is_expirable': True}).json() + if 'api_token' in token: + api_token = token['api_token'] + link = f'{self.base_url}/api/data/investigation/artefact/Artefact/{v}/download/' + if api_token: + link += f'?hl_expiring_key={api_token}' + + return link + except Exception as e: + return 'N/A' + + def __get_destination_ip(self, v): + """ + Return a tuple (hash filter name, hash value) to be used as filter for the HarfangLab API for a destination IP filter + + :type v: ``str`` + :param v: The IP address + + :return: A tuple (hash filter name, hash value) + :rtype: ``Tuple(str,str)`` + """ + + return ('daddr', v) + + def __get_source_ip(self, v): + """ + Return a tuple (hash filter name, hash value) to be used as filter for the HarfangLab API for a source IP filter + + :type v: ``str`` + :param v: The IP address + + :return: A tuple (hash filter name, hash value) + :rtype: ``Tuple(str,str)`` + """ + return ('saddr', v) + + def __generate_view_link_for_source_ip(self, filters): + """ + Return a HarfangLab view link for an IP IOC + + :type filters: ``Dict[str,str]`` + :param filters: The filters with their associated value to pass as query parameters + + :return: A view link + :rtype: ``str`` + """ + f = [] + for filter, v in filters.items(): + f.append(f'{filter}={v}') + return f'{self.base_url}/telemetry/network-connections?offset=0&{"&".join(f)}&ordering=-event_create_date' + + def __generate_view_link_for_destination_ip(self, filters): + """ + Return a HarfangLab view link for an IP IOC + + :type filters: ``Dict[str,str]`` + :param filters: The filters with their associated value to pass as query parameters + + :return: A view link + :rtype: ``str`` + """ + f = [] + for filter, v in filters.items(): + f.append(f'{filter}={v}') + return f'{self.base_url}/telemetry/network-connections?offset=0&{"&".join(f)}&ordering=-event_create_date' + + def __generate_view_link_for_hash(self, filters): + """ + Return a HarfangLab view link for an IP IOC + + :type filters: ``List[str]`` + :param filters: The list of parameters required to generate the link + + :return: A view link + :rtype: ``str`` + """ + + f = [] + for filter, v in filters.items(): + f.append(f'{filter}={v}') + return f'{self.base_url}/telemetry/processes?limit=25&offset=0&{"&".join(f)}&ordering=-event_create_date' + + + """ + The JOBS dict contains all the job services and their description. Its keys correspond to the service names in the service description file in JSON format. + Each job is associated to a responder flavor. When called from a TheHive case, it generates a dedicated task in TheHive whose description contains the job result in Markdown. + + Job description structure: + * request_api_endpoint: HarfangLab API endpoint to start a job and get its status + * result_api_endpoint: HarfangLab API endpoint to get job results + * title: Title associated to the job result, that is provided in the task description + * task_title: Description of the TheHive task + * action: Job action that is transmitted to the HarfangLab API + * ordering: Value ordering field (format corresponding to HarfangLab API) + * fields: List of output fields to provide in the resulting markdown table. + + Each output field is described with the following parameters: + * name: Name of the field as provided in the result table headers + * path: Path of the field value for extraction from the job results. The path is composed of all dict keys separated by a '.' + * default: Default value to use if the path does not exist + * transform: Function to use to transform the field before inserting into the resulting table + * is_url: Indicates whether the field must be rendered as a markdown URL + * link_text: Corresponds to the link text to show if the field must be rendered as a markdown URL. It not specified, the URL will be used as the text to show. + """ + + JOBS = { + 'getProcesses': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/Process/', + 'title': 'Process list', + 'task_title': 'Review process list', + 'action': 'getProcessList', + 'ordering': 'name', + 'fields': [ + {'name': 'name', 'path': 'name', 'default': None}, + {'name': 'session', 'path': 'session', 'default': None}, + {'name': 'username', 'path': 'username', 'default': None}, + {'name': 'integrity', 'path': 'integrity_level', 'default': None}, + {'name': 'pid', 'path': 'pid', 'default': None}, + {'name': 'ppid', 'path': 'ppid', 'default': None}, + {'name': 'cmdline', 'path': 'cmdline', 'default': None}, + {'name': 'fullpath', 'path': 'binaryinfo.fullpath', 'default': None}, + {'name': 'signed', 'path': 'binaryinfo.binaryinfo.signed', + 'default': False}, + {'name': 'md5', 'path': 'binaryinfo.binaryinfo.md5', 'default': None}, + {'name': 'sha1', 'path': 'binaryinfo.binaryinfo.sha1', + 'default': None}, + {'name': 'sha256', 'path': 'binaryinfo.binaryinfo.sha256', + 'default': None} + ] + }, + 'getServices': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/Service/', + 'title': 'Service list', + 'task_title': 'Review service list', + 'action': 'getHives', + 'ordering': 'service_name', + 'fields': [ + {'name': 'name', 'path': 'service_name', 'default': None}, + {'name': 'image path', 'path': 'image_path', 'default': None}, + {'name': 'fullpath', 'path': 'binaryinfo.fullpath', 'default': None}, + {'name': 'signed', 'path': 'binaryinfo.binaryinfo.signed', + 'default': False}, + {'name': 'md5', 'path': 'binaryinfo.binaryinfo.md5', 'default': None}, + {'name': 'sha1', 'path': 'binaryinfo.binaryinfo.sha1', + 'default': None}, + {'name': 'sha256', 'path': 'binaryinfo.binaryinfo.sha256', + 'default': None} + ] + }, + 'getPipes': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/Pipe/', + 'title': 'Pipe list', + 'task_title': 'Review pipe list', + 'action': 'getPipeList', + 'ordering': 'name', + 'fields': [ + {'name': 'name', 'path': 'name', 'default': None} + ] + }, + 'getDrivers': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/Driver/', + 'title': 'Loaded driver list', + 'task_title': 'Review loaded driver list', + 'action': 'getLoadedDriverList', + 'ordering': 'short_name', + 'fields': [ + {'name': 'fullpath', 'path': 'binaryinfo.fullpath', 'default': None}, + {'name': 'signed', 'path': 'binaryinfo.binaryinfo.signed', + 'default': False}, + {'name': 'md5', 'path': 'binaryinfo.binaryinfo.md5', 'default': None}, + {'name': 'sha1', 'path': 'binaryinfo.binaryinfo.sha1', + 'default': None}, + {'name': 'sha256', 'path': 'binaryinfo.binaryinfo.sha256', + 'default': None} + ] + }, + 'getPrefetches': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/Prefetch/', + 'title': 'Prefetch list', + 'task_title': 'Review prefetch list', + 'action': 'getPrefetch', + 'ordering': '-last_executed', + 'fields': [ + {'name': 'executable name', + 'path': 'executable_name', 'default': None}, + {'name': 'last executed', 'path': 'last_executed', + 'default': None, 'transform': __get_first_element}, + ] + }, + 'getScheduledTasks': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/ScheduledTaskXML/', + 'title': 'Scheduled task list', + 'task_title': 'Review scheduled task list', + 'action': 'getScheduledTasks', + 'ordering': 'short_name', + 'fields': [ + {'name': 'name', 'path': 'short_name', 'default': None}, + {'name': 'fullpath', 'path': 'binaryinfo.fullpath', 'default': None}, + {'name': 'signed', 'path': 'binaryinfo.binaryinfo.signed', + 'default': False}, + {'name': 'md5', 'path': 'binaryinfo.binaryinfo.md5', 'default': None}, + {'name': 'sha1', 'path': 'binaryinfo.binaryinfo.sha1', + 'default': None}, + {'name': 'sha256', 'path': 'binaryinfo.binaryinfo.sha256', + 'default': None} + ] + }, + 'getRunKeys': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/RunKey/', + 'title': 'Run key list', + 'task_title': 'Review run key list', + 'action': 'getHives', + 'ordering': '-last_executed', + 'fields': [ + {'name': 'name', 'path': 'short_name', 'default': None}, + {'name': 'fullpath', 'path': 'binaryinfo.fullpath', 'default': None}, + {'name': 'signed', 'path': 'binaryinfo.binaryinfo.signed', + 'default': False}, + {'name': 'md5', 'path': 'binaryinfo.binaryinfo.md5', 'default': None}, + {'name': 'sha1', 'path': 'binaryinfo.binaryinfo.sha1', + 'default': None}, + {'name': 'sha256', 'path': 'binaryinfo.binaryinfo.sha256', + 'default': None} + ] + }, + 'getStartupFiles': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/Startup/', + 'title': 'Startup file list', + 'task_title': 'Review startup file list', + 'action': 'getStartupFileList', + 'ordering': 'filename', + 'fields': [ + {'name': 'startup file name', + 'path': 'filename', 'default': None}, + {'name': 'startup file full path', + 'path': 'fullpathfilename', 'default': None}, + {'name': 'fullpath', 'path': 'binaryinfo.fullpath', 'default': None}, + {'name': 'signed', 'path': 'binaryinfo.binaryinfo.signed', + 'default': False}, + {'name': 'md5', 'path': 'binaryinfo.binaryinfo.md5', 'default': None}, + {'name': 'sha1', 'path': 'binaryinfo.binaryinfo.sha1', + 'default': None}, + {'name': 'sha256', 'path': 'binaryinfo.binaryinfo.sha256', + 'default': None} + ] + }, + 'getPersistence': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/PersistanceFile/', + 'title': 'Persistence list', + 'task_title': 'Review persistence list', + 'action': 'persistanceScanner', + 'ordering': 'short_name', + 'fields': [ + {'name': 'type', 'path': 'persistance_type', 'default': None}, + {'name': 'filename', 'path': 'binaryinfo.filename', 'default': None}, + {'name': 'fullpath', 'path': 'binaryinfo.fullpath', 'default': None}, + ] + }, + 'getWMI': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/Wmi/', + 'title': 'WMI list', + 'task_title': 'Review list', + 'action': 'getWMI', + 'ordering': 'filename', + 'fields': [ + {'name': 'filter to consumer type', + 'path': 'filtertoconsumertype', 'default': None}, + {'name': 'event filter name', + 'path': 'eventfiltername', 'default': None}, + {'name': 'event consumer name', + 'path': 'eventconsumername', 'default': None}, + {'name': 'event filter', 'path': 'eventfilter', 'default': None}, + {'name': 'consumer data', 'path': 'consumerdata', 'default': None}, + ] + }, + 'getNetworkShares': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/NetworkShare/', + 'title': 'Network share list', + 'task_title': 'Review network share list', + 'action': 'getNetworkShare', + 'ordering': 'name', + 'fields': [ + {'name': 'name', 'path': 'name', 'default': None}, + {'name': 'caption', 'path': 'caption', 'default': None}, + {'name': 'description', 'path': 'description', 'default': None}, + {'name': 'path', 'path': 'path', 'default': None}, + {'name': 'status', 'path': 'status', 'default': None}, + {'name': 'share type val', + 'path': 'sharetypeval', 'default': None}, + {'name': 'share type', 'path': 'sharetype', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + ] + }, + 'getSessions': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/hunting/Session/', + 'title': 'Session list', + 'task_title': 'Review session list', + 'action': 'getSessions', + 'ordering': 'name', + 'fields': [ + {'name': 'logon id', 'path': 'logonid', 'default': None}, + {'name': 'authentication package', + 'path': 'authenticationpackage', 'default': None}, + {'name': 'logon type', 'path': 'logontype', 'default': None}, + {'name': 'logon type str', + 'path': 'logontypestr', 'default': None}, + {'name': 'session start time', + 'path': 'sessionstarttime', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + ] + }, + 'getArtifactMFT': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'MFT', + 'task_title': 'Analyze MFT', + 'action': 'collectRAWEvidences', + 'parameters': {'hives': False, 'evt': False, 'mft': True, + 'prefetch': False, 'usn': False, 'logs': False, 'fs': False}, + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'getArtifactHives': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'Hives', + 'task_title': 'Analyze Hives', + 'action': 'collectRAWEvidences', + 'parameters': {'hives': True, 'evt': False, 'mft': False, + 'prefetch': False, 'usn': False, 'logs': False, 'fs': False}, + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'getArtifactEvtx': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'Windows event logs', + 'task_title': 'Analyze event logs', + 'action': 'collectRAWEvidences', + 'parameters': {'hives': False, 'evt': True, 'mft': False, + 'prefetch': False, 'usn': False, 'logs': False, 'fs': False}, + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'getArtifactLogs': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'Linux logs', + 'task_title': 'Analyze logs', + 'action': 'collectRAWEvidences', + 'parameters': {'hives': False, 'evt': False, 'mft': False, + 'prefetch': False, 'usn': False, 'logs': True, 'fs': False}, + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'getArtifactFilesystem': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'Linux filesystem', + 'task_title': 'Analyze filesystem', + 'action': 'collectRAWEvidences', + 'parameters': {'hives': False, 'evt': False, 'mft': False, + 'prefetch': False, 'usn': False, 'logs': False, 'fs': True}, + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'getArtifactUSN': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'USN logs', + 'task_title': 'Analyze USN logs', + 'action': 'collectRAWEvidences', + 'parameters': {'hives': False, 'evt': False, 'mft': False, + 'prefetch': False, 'usn': True, 'logs': False, 'fs': False}, + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'getArtifactPrefetch': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'USN logs', + 'task_title': 'Analyze prefetches', + 'action': 'collectRAWEvidences', + 'parameters': {'hives': False, 'evt': False, 'mft': False, + 'prefetch': True, 'usn': False, 'logs': False, 'fs': False}, + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'getArtifactAll': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'All raw artifacts', + 'task_title': 'Analyze all raw artifacts', + 'action': 'collectRAWEvidences', + 'parameters': {'hives': True, 'evt': True, 'mft': True, + 'prefetch': True, 'usn': True, 'logs': True, 'fs': True}, + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'getArtifactRamdump': { + 'request_api_endpoint': '/api/data/Job/', + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'RAM Dump', + 'task_title': 'Analyze RAM dump', + 'action': 'memoryDumper', + 'ordering': 'name', + 'fields': [ + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'killProcess': { + 'request_api_endpoint': None, + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/job/Simple/', + 'title': 'Killed process', + 'task_title': 'Review process kill report', + 'action': 'knownProcessFinderKiller', + 'ordering': 'name', + 'fields': [ + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'date', 'path': 'date', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None} + ] + }, + 'dumpProcess': { + 'request_api_endpoint': None, + 'status_api_endpoint': '/api/data/Job/', + 'result_api_endpoint': '/api/data/investigation/artefact/Artefact/', + 'title': 'Dumped process', + 'task_title': 'Analyze dumped process', + 'action': 'processDumper', + 'ordering': '-date', + 'fields': [ + {'name': 'message', 'path': 'msg', 'default': None}, + {'name': 'date', 'path': 'date', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'download_link', 'path': 'id', 'default': None, + 'transform': __generate_link_for_artifact, 'is_url': True, 'link_text': 'Download'} + ] + }, + } + + TELEMETRY_SEARCHES = { + 'searchHash': { + 'api_endpoint': '/api/data/telemetry/Processes/', + 'title': 'Hash search', + 'task_title': 'Review hash search in telemetry', + 'inputs': [ + {'name': 'hash', 'filter': 'hash', + 'transform': __get_hash_parameter, 'mandatory': True}, + {'name': 'process_name', 'filter': 'process_name'}, + {'name': 'image_name', 'filter': 'image_name'}, + {'name': 'limit', 'filter': 'limit'} + ], + 'fields': [ + {'name': 'name', 'path': 'name', 'default': None}, + {'name': 'creation date', + 'path': '@event_create_date', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'process name', 'path': 'process_name', 'default': None}, + {'name': 'image name', 'path': 'image_name', 'default': None}, + {'name': 'command line', 'path': 'commandline', 'default': None}, + {'name': 'integrity level', + 'path': 'integrity_level', 'default': None}, + {'name': 'parent image', 'path': 'parent_image', 'default': None}, + {'name': 'parent command line', + 'path': 'parent_commandline', 'default': None}, + {'name': 'username', 'path': 'username', 'default': None}, + {'name': 'signed', 'path': 'signed', 'default': None}, + {'name': 'signer', 'path': 'signature_info.signer_info.display_name', + 'default': None}, + {'name': 'md5', 'path': 'hashes.md5', 'default': None}, + {'name': 'sha1', 'path': 'hashes.sha1', 'default': None}, + {'name': 'sha256', 'path': 'hashes.sha256', 'default': None}, + {'name': 'process UUID', 'path': 'process_unique_id', 'default': None}, + {'name': 'agent id', 'path': 'agent.agentid', 'default': None} + ], + 'link': { + 'link_href': None, + 'transform': __generate_view_link_for_hash + } + }, + 'getBinary': { + 'api_endpoint': '/api/data/telemetry/Binary/', + 'title': 'Binary download', + 'task_title': 'Analyze binary', + 'inputs': [ + {'name': 'hash', 'filter': 'hash', + 'transform': __get_hash_parameter, 'mandatory': True} + ], + 'fields': [ + {'name': 'path', 'path': 'paths', 'default': None, + 'transform': __flatten_table}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'signed', 'path': 'signed', 'default': None}, + {'name': 'signer', 'path': 'signature_info.signer_info.display_name', + 'default': None}, + {'name': 'md5', 'path': 'hashes.md5', 'default': None}, + {'name': 'sha1', 'path': 'hashes.sha1', 'default': None}, + {'name': 'sha256', 'path': 'hashes.sha256', 'default': None}, + {'name': 'download_link', 'path': 'hashes.sha256', 'default': None, + 'transform': __generate_link_for_binary, 'is_url': True, 'link_text': 'Download'} + ] + }, + 'searchSourceIP': { + 'api_endpoint': '/api/data/telemetry/Network/', + 'title': 'IP search', + 'task_title': 'Review Source IP search in telemetry', + 'inputs': [ + {'name': 'ip', 'filter': 'saddr', + 'transform': __get_source_ip, 'mandatory': True}, + {'name': 'limit', 'filter': 'limit'} + ], + 'fields': [ + {'name': 'creation date', + 'path': '@event_create_date', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'image name', 'path': 'image_name', 'default': None}, + {'name': 'username', 'path': 'username', 'default': None}, + {'name': 'source address', 'path': 'saddr', 'default': None}, + {'name': 'source port', 'path': 'sport', 'default': None}, + {'name': 'destination address', + 'path': 'daddr', 'default': None}, + {'name': 'destination port', 'path': 'dport', 'default': None}, + {'name': 'direction', 'path': 'direction', 'default': None}, + ], + 'link': { + 'link_href': None, + 'transform': __generate_view_link_for_source_ip + } + }, + 'searchDestinationIP': { + 'api_endpoint': '/api/data/telemetry/Network/', + 'title': 'IP search', + 'task_title': 'Review Destination IP search in telemetry', + 'inputs': [ + {'name': 'ip', 'filter': 'daddr', + 'transform': __get_destination_ip, 'mandatory': True}, + {'name': 'limit', 'filter': 'limit'} + ], + 'fields': [ + {'name': 'creation date', + 'path': '@event_create_date', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'image name', 'path': 'image_name', 'default': None}, + {'name': 'username', 'path': 'username', 'default': None}, + {'name': 'source address', 'path': 'saddr', 'default': None}, + {'name': 'source port', 'path': 'sport', 'default': None}, + {'name': 'destination address', + 'path': 'daddr', 'default': None}, + {'name': 'destination port', 'path': 'dport', 'default': None}, + {'name': 'direction', 'path': 'direction', 'default': None}, + ], + 'link': { + 'link_href': None, + 'transform': __generate_view_link_for_destination_ip + } + }, + 'searchDriverByFileName': { + 'api_endpoint': '/api/data/telemetry/DriverLoad/', + 'title': 'Driver load search', + 'task_title': 'Review driver load search in telemetry', + 'inputs': [ + {'name': 'filename', 'filter': 'imagename', 'mandatory': True}, + {'name': 'limit', 'filter': 'limit'} + ], + 'fields': [ + {'name': 'loading time', 'path': '@timestamp', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'image name', 'path': 'imagename', 'default': None}, + {'name': 'image path', 'path': 'imagepath', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'signed', 'path': 'signed', 'default': None}, + {'name': 'signer', 'path': 'signature_info.signer_info.display_name', + 'default': None}, + {'name': 'md5', 'path': 'hashes.md5', 'default': None}, + {'name': 'sha1', 'path': 'hashes.sha1', 'default': None}, + {'name': 'sha256', 'path': 'hashes.sha256', 'default': None} + ] + }, + 'searchDriverByHash': { + 'api_endpoint': '/api/data/telemetry/DriverLoad/', + 'title': 'Driver load search', + 'task_title': 'Review driver load search in telemetry', + 'inputs': [ + {'name': 'hash', 'filter': 'hash', + 'transform': __get_hash_parameter, 'mandatory': True}, + {'name': 'limit', 'filter': 'limit'} + ], + 'fields': [ + {'name': 'loading time', 'path': '@timestamp', 'default': None}, + {'name': 'hostname', 'path': 'agent.hostname', 'default': None}, + {'name': 'image name', 'path': 'imagename', 'default': None}, + {'name': 'image path', 'path': 'imagepath', 'default': None}, + {'name': 'size', 'path': 'size', 'default': None}, + {'name': 'signed', 'path': 'signed', 'default': None}, + {'name': 'signer', 'path': 'signature_info.signer_info.display_name', + 'default': None}, + {'name': 'md5', 'path': 'hashes.md5', 'default': None}, + {'name': 'sha1', 'path': 'hashes.sha1', 'default': None}, + {'name': 'sha256', 'path': 'hashes.sha256', 'default': None} + ] + } + + } + + """ + Fetches security events from a HarfangLab EDR manager + + :type first_fetch: ``int`` + :param first_fetch: The number of days to look back for alerts + + :type alert_status: ``str`` + :param alert_status: Status of alerts to fetch ('ACTIVE' for alerts in the new, probable_false_positive or investigating statuses, 'CLOSED' for alerts in the closed or false_positive states, None for all alerts + + :type alert_type: ``str`` + :param alert_type: A comma-separated list of alert types (e.g. 'sigma,yara,hlai') or None to fetch all types + + :type min_severity: ``int`` + :param min_severity: The minimum severity of alerts to fetch ('Informational' or None for Informational and higher, 'Low' for Low and higher, 'Medium' for Medium and higer, 'High' for High and higher, 'Critical' for Critical) + + :type max_fetch: ``int`` + :param max_fetch: The maximum number of alerts to fetch (None to remove the limit) + + :type last_fetch: ``int`` + :param last_fetch: The timestamp in micro-seconds of the last fetch time + + :type delay: ``int`` + :param delay: Number of seconds back in the past for the upper limit of security event timestamps (keep a value of minimum 120 secondes) + + :type exclude_rules: ``List[str]`` + :param exclude_rules: The list of rule names to exclude (case insensitive) + + :return: A tuple with the last fetch time in micro-seconds since epoch and the list of security events + :rtype: ``(int,List[Any])`` + """ + + def fetch_security_events(self, first_fetch = None, alert_status = None, alert_type = None, min_severity = None, max_fetch = None, last_fetch = None, delay = 0, exclude_rules = None): + + url = f'{self.base_url}/api/data/alert/alert/Alert/' + last_fetch = None + max_results = None + days = 0 + excluded_rules = set() + + if exclude_rules: + excluded_rules = [x.lower() for x in exclude_rules] + + if first_fetch: + try: + days = int(first_fetch) + except Exception as e: + days = 0 + + first_fetch_time = int(datetime.timestamp( + datetime.now() - timedelta(days=days)) * 1000000) + + if not min_severity: + min_severity = HarfangLabConnector.SEVERITIES[0] + + if max_fetch: + try: + max_results = int(max_fetch) + except Exception as e: + max_results = None + + severity = ','.join(HarfangLabConnector.SEVERITIES[HarfangLabConnector.SEVERITIES.index(min_severity):]).lower() + + if last_fetch is None: + # if missing, use what provided via first_fetch_time + last_fetch = first_fetch_time + else: + # otherwise use the stored last fetch + try: + last_fetch = int(last_fetch) + except Exception as e: + last_fetch = first_fetch_time + + if alert_status == 'ACTIVE': + status = ['new', 'probable_false_positive', 'investigating'] + elif alert_status == 'CLOSED': + status = ['closed', 'false_positive'] + else: + status = None + + latest_created_time_us = int(last_fetch) + + incidents = [] + total_number_of_alerts = 0 + + date_min = datetime.fromtimestamp(latest_created_time_us / 1000000) + try: + delay = int(delay) + except Exception as e: + delay = 0 + date_max = datetime.fromtimestamp(datetime.timestamp(datetime.now() - timedelta(seconds=int(delay)))) + + cursor_min = date_min + cursor_max = date_max + + self.logger.debug(f'Getting events between {date_min.strftime("%Y-%m-%dT%H:%M:%SZ")} and {date_max.strftime("%Y-%m-%dT%H:%M:%SZ")}') + while cursor_min != cursor_max: + offset = 0 + while True: + args = { + 'ordering': '+alert_time', + 'level': severity, + 'limit': HarfangLabConnector.MAX_NUMBER_OF_ALERTS_PER_CALL, + 'offset': offset, + 'alert_time__gt': cursor_min.strftime('%Y-%m-%dT%H:%M:%SZ'), + 'alert_time__lte': cursor_max.strftime('%Y-%m-%dT%H:%M:%SZ') + } # type: Dict[str,Any] + + if status: + args['status'] = ','.join(status) + + if alert_type: + args['alert_type'] = alert_type + + try: + u=f'{url}'+get_params(args) + response = self.hlSession.get(u) + response.raise_for_status() + results = response.json() + except Exception as e: + raise Exception(f'Failed to fetch security events: {str(e)}') + + #print( + # f'Getting events between {date_min.strftime("%Y-%m-%dT%H:%M:%SZ")} and {date_max.strftime("%Y-%m-%dT%H:%M:%SZ")}: {results["count"]}') + + if results['count'] >= HarfangLabConnector.MAX_NUMBER_OF_ITEMS: + cursor_max = cursor_min + (cursor_max - cursor_min) / 2 + break + + if 'count' in results and 'results' in results: + self.logger.debug(f'Fetched {total_number_of_alerts} / {results["count"]} events') + + for alert in results['results']: + + if alert.get('rule_name').lower() in excluded_rules: + continue + + alert_id = alert.get('id', None) + alert['incident_link'] = f'{self.base_url}/security-event/{alert_id}/summary' + incident = { + 'name': alert.get('rule_name', None), + 'occurred': alert.get('alert_time', None), + 'severity': HarfangLabConnector.SEVERITIES.index(alert.get('level', '').capitalize()) + 1, + 'alert': alert + } + + incidents.append(incident) + + total_number_of_alerts += 1 + if max_results and total_number_of_alerts >= max_results: + break + + offset += len(results['results']) + if results['count'] == 0 or not results['next'] or (max_results and total_number_of_alerts >= max_results): + cursor_min = cursor_max + cursor_max = date_max + break + + if max_results and total_number_of_alerts >= max_results: + break + + last_fetch = int(datetime.timestamp(date_max)*1000000) + return (last_fetch, incidents) + + """ + Get a security event by ID + + :type event_id: ``str`` + :param event_id: The agent security event ID + """ + def get_event_by_id(self, event_id): + try: + return self.hlSession.get( + url=f'{self.base_url}/api/data/alert/alert/Alert/{event_id}/details/' + ).json() + + except Exception as e: + raise Exception(f'Failed to get security event information: {str(e)}') + + + """ + Search an endpoint in HarfangLab EDR manager + + :type hostname: ``str`` + :param hostname: The agent hostname + + :type ostype: ``str`` + :param ostype: The agent platform ("windows", "linux", "macos") + + :type status: ``str`` + :param status: The agent status ("online", "offline") + + :type offset: ``Integer`` + :param offset: The search offset + + :type limit: ``Integer`` + :param limit: The search total number of records to fetch per call + + :type fields: ``List[str]`` + :param fields: The list of fields to provide in the output + + :type format: ``str`` + :param format: The output format (either 'mardown' or 'html') + + :return: The list of searched endpoints + :rtype: ``Dict[str,Any]`` + """ + def search_endpoint(self, hostname=None, ostype=None, status=None, offset=0, limit=10, fields=None, format='markdown'): + + data = { + 'hostname': hostname, + 'ostype': ostype, + 'status': status, + 'offset': offset, + 'limit': limit + } + + try: + result = {} + results = self.hlSession.get( + url=f'{self.base_url}/api/data/endpoint/Agent/', + params=data + ).json()['results'] + + result['message'] = 'OK' + result['output'] = results + result['count'] = len(results) + + result['markdown'] = get_markdown_from_table( + None, results, headers=fields) + + if format == 'html': + result['html'] = markdown.markdown(result['markdown'], extensions=['tables']) + del (result['markdown']) + + return result + + except Exception as e: + raise Exception(f'Failed to search endpoint: {str(e)}') + + def search_telemetry(self, service_name, args, format='markdown'): + """ + Search in HarfangLab telemetry and returns a markdown table with the search results + + :type service_name: ``str`` + :param service_name: The name of the telemetry search service ('searchHash', 'getBinary', 'searchSourceIP', 'searchDestinationIP', 'searchDriverByFileName', 'searchDriverByHash') + + :type args: ``Dict[str, str]`` + :param args: The arguments for the telemetry search (ip, hash, filename...) + + :type format: ``str`` + :param format: The output format (either 'mardown' or 'html') + + :return: A dict with the results with the following keys: 'message' (message associated to the operation), 'output' (the JSON table with the results), 'markdown' (the markdown table). + :rtype: ``Dict[str,Any]`` + """ + + result = {} + result['message'] = 'Failed' + result['markdown'] = '' + serv = None + if service_name in HarfangLabConnector.TELEMETRY_SEARCHES: + serv = HarfangLabConnector.TELEMETRY_SEARCHES[service_name] + else: + return + + url = f'{self.base_url}{serv["api_endpoint"]}' + params = {} + + for field in serv['inputs']: + func = field.get('transform', None) + data = args.get(field['name'], None) + mandatory = field.get('mandatory', False) + #if not data and mandatory: + # raise Exception( + # f'Mismatch between the observable type and what the responder expects ({field["name"]})') + if func: + (f, v) = func(self, data) + params[f] = v + elif data: + params[field['filter']] = data + + try: + response = self.hlSession.get(url=url, params=params) + response.raise_for_status() + except Exception as e: + raise Exception(f'Failed to search in telemetry %s' % (str(e))) + + response = response.json() + output = [] + url_keys = {} + count = response['count'] + for x in response['results']: + res = {} + for f in serv['fields']: + k = f['name'] + if 'is_url' in f: + url_keys[f['name']] = f.get('link_text', None) + tokens = f['path'].split('.') + v = x + for t in tokens: + if v: + v = v.get(t, None) + else: + v = f['default'] + func = None + if 'transform' in f.keys(): + func = f.get('transform') + v = func(self, v) + res[k] = v + + output.append(res) + + link = None + if 'link' in serv: + if 'transform' in serv['link'].keys(): + func = serv['link'].get('transform') + if func: + link = func(self, params) + if not link: + link = serv.get('link',{}).get('link_href') + + result['search_type'] = service_name + result['args'] = args + result['message'] = 'OK' + result['title'] = serv['title'] + result['output'] = output + result['count'] = count + result['link'] = link + + + headers = [] + for h in serv['fields']: + headers.append(h['name']) + + result['markdown'] += f'### {serv["title"]}\n\n' + result['markdown'] += f'#### Search details\n\n' + + search_metadata = args.copy() + search_metadata['Search Type'] = service_name + search_metadata['Total number of hits'] = count + search_metadata['Investigation link'] = link + + result['markdown'] += get_markdown_from_table( + None, search_metadata, headers=search_metadata.keys()) + result['markdown'] += f'#### Results (fetched {len(output)}/{count} entries)\n\n' + result['markdown'] += get_markdown_from_table( + None, output, headers=headers, url_keys=url_keys) + + if format == 'html': + result['html'] = markdown.markdown(result['markdown'], extensions=['tables']) + del(result['markdown']) + + return result + + def search_multiple_iocs_in_telemetry(self, iocs, limit, format='markdown', search_types = None): + """ + Search multiple IOCs in HarfangLab telemetry and returns a markdown table with the search results + + :type iocs: ``List[Dict[str,str]]`` + :param iocs: The IOCs to search in the following format [{'type': 'md5', value: '1234567890ABCDEF1234567890ABCDEF'}, ...] (ip, hash, filename...) + + :type limit: ``Integer`` + :param limit: Limits the number of hit results for each IOC to this number. + + :type format: ``str`` + :param format: The output format (either 'mardown' or 'html') + + :type search_types: ``Set[Str]`` + :param search_types: Indicates which types of search to perform. + + :return: A dict with the results with the following keys: 'message' (message associated to the operation), 'output' (the JSON table with the results), 'markdown' (the markdown table). + :rtype: ``Dict[str,Any]`` + """ + + url_keys = {} + results = {} + output = [] + exception_count = 0 + success_count = 0 + results['output'] = [] + for ioc in iocs: + for search_type in search_types: + try: + res = None + + if ioc.get('type')[0:2] == 'ip' and search_type in ['searchSourceIP', 'searchDestinationIP']: + res = self.search_telemetry(search_type, {'ip': ioc.get('value'), 'limit': limit}) + elif ioc.get('type') in ['hash', 'md5', 'sha1', 'sha256'] and search_type in ['searchHash', 'searchDriverByHash']: + res = self.search_telemetry(search_type, {'hash': ioc.get('value'), 'limit': limit}) + + if res: + search_result = ioc.copy() + search_result['seach_type'] = search_type + search_result['count'] = res['count'] + search_result['markdown'] = res['markdown'] + search_result['output'] = res['output'] + search_result['message'] = 'OK' + output.append({ + 'IOC Type': ioc.get('type'), + 'IOC Value': ioc.get('value'), + 'Search Type': search_type, + 'Hits count': res['count'], + 'Investigation link': res['link'] + }) + success_count += 1 + results['output'].append(search_result) + except Exception as e: + search_result['message'] = f'Failed to search IOC {ioc.get("value")}: {str(e)}' + exception_count += 1 + results['output'].append(search_result) + + if success_count > 0: + if exception_count: + results['message'] = 'Partially OK' + else: + results['message'] = 'OK' + else: + results['message'] = 'Failed' + + url_keys['Investigation link'] = 'View details' + + results['markdown'] = '' + results['markdown'] += f'### IOC search\n\n' + results['markdown'] += f'#### Synthesis\n\n' + results['markdown'] += get_markdown_from_table( + None, output, headers=['IOC Type', 'IOC Value', 'Search Type', 'Hits count', 'Investigation link'], url_keys=url_keys) + + results['title'] = 'IOC search' + + if format == 'html': + results['html'] = markdown.markdown(results['markdown'], extensions=['tables']) + del(results['markdown']) + + return results + + + def run_job(self, job_name, agent_id, job_title = None, job_description = None, job_timeout = 600, format = 'markdown', request_api_endpoint = None): + """ + Run a HarfangLab job and returns a markdown table with the results + + :type job_name: ``str`` + :param job_name: The job name from the JOBS description to trigger + + :type agent_id: ``str`` + :param agent_id: The agent identifier to run the job on + + :type job_title: ``str`` + :param job_title: The job title + + :type job_description: ``str`` + :param job_description: The job description + + :type job_timeout: ``int`` + :param job_timeout: The job timeout (in seconds) + + :type format: ``str`` + :param format: The output format (either 'mardown' or 'html') + + :type request_api_endpoint: ``str`` + :param request_api_endpoint: The request api endpoint that override the one defined in the JOBS structure + + :return: A dict with the results with the following keys: 'message' (message associated to the operation), 'output' (the JSON table with the results), 'markdown' (the markdown table) if the output format is mardown or 'html' if the output format is html. + :rtype: ``Dict[str,Any]`` + """ + + result = {} + result['message'] = 'Failed' + result['markdown'] = '' + + job = None + if job_name in HarfangLabConnector.JOBS: + job = HarfangLabConnector.JOBS[job_name] + else: + raise Exception('Unknown service') + + if not agent_id: + raise Exception('No agent identifier provided.') + + """ Create job """ + api_endpoint = None + if request_api_endpoint: + api_endpoint = request_api_endpoint + else: + api_endpoint = job["request_api_endpoint"] + if not api_endpoint: + raise Exception('No API endpoint associated to the job name') + + url = f'{self.base_url}{api_endpoint}' + + data = { + 'title': job_title, + 'description': job_description, + 'targets': {'agents': [agent_id]}, + 'actions': [ + { + 'value': job.get('action', None), + 'params': job.get('parameters', None), + } + ] + } + + try: + response = self.hlSession.post(url=url, json=data) + response.raise_for_status() + data = response.json() + if isinstance(data, list): + if len(data) == 0: + raise Exception( + 'Failed to start job (wrong agent identifier ?)') + job_id = data[0]['id'] + elif isinstance(data, dict): + job_id = data['job_id'] + + except Exception as e: + raise Exception('Failed to start job: %s' % (str(e))) + + """ Get job status """ + url = f'{self.base_url}{job["status_api_endpoint"]}{job_id}/' + + duration = 0 + polling_period = 5 + + while duration < job_timeout: + try: + response = self.hlSession.get(url=url) + response.raise_for_status() + info = response.json() + except Exception as e: + raise Exception('Failed to get job status: %s' % (str(e))) + + status = "running" + + if info['instance'] == info['done']: + status = "finished" + elif info['error'] > 0: + status = "error" + elif info['canceled'] > 0: + status = "canceled" + elif info['waiting'] > 0: + status = "waiting" + elif info['running'] > 0: + status = "running" + elif info['injecting'] > 0: + status = "injecting" + + if status in ['error', 'canceled']: + result['message'] = 'Job execution failed' + result['markdown'] = 'Job execution failed' + return result + if status == 'finished': + time.sleep(polling_period) + break + time.sleep(polling_period) + duration += polling_period + + """ Get Job results """ + fields = [] + for f in job['fields']: + fields.append(f['path']) + fields_str = ','.join(fields) + url = f'{self.base_url}{job["result_api_endpoint"]}?limit=10000&job_id={job_id}&fields={fields_str}' + + if job['ordering'] is not None: + url += f'&ordering={job["ordering"]}' + + try: + retries = 0 + while retries < 3: + response = self.hlSession.get(url=url) + response.raise_for_status() + data = response.json() + if data['count'] > 0: + break + else: + time.sleep(10) + retries += 1 + except Exception as e: + raise Exception('Failed to get job results: %s' % (str(e))) + + output = [] + url_keys = {} + for x in data['results']: + res = {} + for f in job['fields']: + k = f['name'] + if 'is_url' in f: + url_keys[f['name']] = f.get('link_text', None) + + tokens = f['path'].split('.') + v = x + for t in tokens: + if v: + v = v.get(t, None) + else: + v = f['default'] + func = None + if 'transform' in f.keys(): + func = f.get('transform') + v = func(self, v) + res[k] = v + + output.append(res) + + result['message'] = 'OK' + result['output'] = output + result['title'] = job['title'] + + headers = [] + for h in job['fields']: + headers.append(h['name']) + result['markdown'] = get_markdown_from_table( + job['title'], output, headers=headers, url_keys=url_keys) + + if format == 'html': + result['html'] = markdown.markdown(result['markdown'], extensions=['tables']) + del(result['markdown']) + + return result + + def dump_process(self, agent_id, process_uuid, format='markdown', job_timeout = 600): + """ + Dump a process + + :type agent_id: ``str`` + :param agent_id: The agent identifier to run the job on + + :type format: ``str`` + :param format: The output format (either 'mardown' or 'html') + + :type job_timeout: ``int`` + :param job_timeout: The job timeout (in seconds) + + :return: A dict with the results with the following keys: 'message' (message associated to the operation), 'output' (the JSON table with the results), 'markdown' (the markdown table). + :rtype: ``Dict[str,Any]`` + """ + return self.run_job('dumpProcess', agent_id, job_timeout, format, f'/api/data/telemetry/Processes/{process_uuid}/requestDumpProcess/') + + def kill_process(self, agent_id, process_uuid, format = 'markdown', job_timeout = 600): + """ + Kill a process + + :type agent_id: ``str`` + :param agent_id: The agent identifier to run the job on + + :type process_uuid: ``str`` + :param process_uuid: The process unique identifier (as defined in the HarfangLab EDR Manager) + + :type format: ``str`` + :param format: The output format (either 'mardown' or 'html') + + :type job_timeout: ``int`` + :param job_timeout: The job timeout (in seconds) + + :return: A dict with the results with the following keys: 'message' (message associated to the operation), 'output' (the JSON table with the results), 'markdown' (the markdown table). + :rtype: ``Dict[str,Any]`` + """ + return self.run_job('killProcess', agent_id, job_timeout, format, f'/api/data/telemetry/Processes/{process_uuid}/requestKillProcess/') + + def list_sources(self, source_type, source_name=None): + ''' + List existing Threat Intelligence sources + + :param source_type: Source type + + :param source_name: Source name + + :returns A list of sources matching input criteria + ''' + data = {} + + if source_name: + data['search'] = source_name + + if source_type == 'yara': + url_suffix = '/api/data/threat_intelligence/YaraSource/' + elif source_type == 'sigma': + url_suffix = '/api/data/threat_intelligence/SigmaSource/' + elif source_type == 'ioc': + url_suffix = '/api/data/threat_intelligence/IOCSource/' + + url = f'{self.base_url}{url_suffix}' + + try: + response = self.hlSession.get(url, params=data) + response.raise_for_status() + except Exception as e: + raise Exception(f'Failed to list sources: %s' % (str(e))) + + return response.json()['results'] + + def get_ioc(self, ioc_value, source_id): + ''' + Get an IOC in a source identified by its id + + :param ioc_value: IOC value to search + + :param source_id: Identifier of the Threat Intelligence source + + :returns: true if IOC exists, else false. + ''' + data = { + 'source_id': source_id, + 'search': ioc_value + } + + url = f'{self.base_url}/api/data/threat_intelligence/IOCRule/' + try: + response = self.hlSession.get(url, params=data) + response.raise_for_status() + except Exception as e: + raise Exception(f'Failed to search IOC {ioc_value}: %s' % (str(e))) + results = response.json() + + if results['count'] > 0: + for ioc in results['results']: + if ioc['value'] == ioc_value: + return ioc + return None + + def add_ioc_to_source(self, ioc_value, ioc_type, ioc_comment, ioc_status, source_name): + ''' + Add an IOC to a Threat Intelligence source + + :param ioc_value: IOC value + + :param ioc_type: IOC type (ip, hash, filename...) + + :param ioc_comment: Comment associated to an IOC + + :param source_name: Name of the Threat Intelligence source to add the IOC to + ''' + + try: + results = self.list_sources(source_type='ioc', source_name=source_name) + except Exception as e: + raise Exception(f'Failed to list sources and identify {source_name}: %s' % (str(e))) + + source_id = None + + for source in results: + self.logger.debug(f'Found source {source["name"]}') + if source['name'] == source_name: + source_id = source['id'] + + self.logger.debug(f'Searching for IOC') + if self.get_ioc(ioc_value, source_id): + return + else: + + testing_status = None + + if ioc_status == 'testing': + testing_status = 'in_progress' + + port = None + if ioc_type[0:2] == 'ip': + res = ioc_value.split('|') + if len(res) >= 2: + ioc_value = res[0] + port = res[1] + + data = { + 'type': ioc_type, + 'value': ioc_value, + 'port': port, + 'comment': ioc_comment, + 'source_id': source_id, + 'hl_status': ioc_status, + 'hl_local_testing_status': testing_status + } + + url = f'{self.base_url}/api/data/threat_intelligence/IOCRule/' + + self.logger.debug(f'Adding for IOC') + + try: + response = self.hlSession.post(url, json=data) + response.raise_for_status() + self.logger.debug(f'IOC added') + except Exception as e: + raise Exception(f'Failed to add IOC {ioc_value} to source {source_id}: %s' % (str(e))) + + def change_security_event_status(self, security_event_id, status): + ''' + Change the status of a security event + + :param security_event_id: Security Event ID or list of IDs + + :param status: The security event status ('New', 'Investigating', 'False Positive' or 'Closed' + ''' + + try: + url = f'{self.base_url}/api/data/alert/alert/Alert/tag/' + + data = {} # type: Dict[str,Any] + + if isinstance(security_event_id, list): + data['ids'] = security_event_id + else: + data['ids'] = [security_event_id] + + if status.lower() == 'new': + data['new_status'] = 'new' + elif status.lower() == 'investigating': + data['new_status'] = 'investigating' + elif status.lower() == 'false positive' or status.lower() == 'false_positive': + data['new_status'] = 'false_positive' + elif status.lower() == 'closed': + data['new_status'] = 'closed' + else: + raise Exception('Status must be either new, investigating, false_positive or closed') + + response = self.hlSession.post(url=url, json=data) + response.raise_for_status() + + except Exception as e: + raise Exception(f'Failed to change security event status: %s' % (str(e))) + + def isolate_endpoint(self, agent_id): + ''' + Isolate an endpoint + + :param agent_id: Agent identifier + + :return: A string with the result message + ''' + url = f'{self.base_url}/api/data/endpoint/Agent/{agent_id}/isolate/' + + if not agent_id: + raise Exception( + 'No agent Id provided') + + try: + response = self.hlSession.post(url=url) + if response.status_code != 200: + raise Exception( + f'Failed to isolate host {agent_id}: {response.status_code} ({response.reason})') + else: + """ + Isolation has successfully been requested. We need to check that the policy allows isolation. + """ + if len(response.json().get('policy_not_allowed', [])) > 0: + raise Exception( + f'Unable to isolate host {agent_id} since isolation is not allowed in the policy.') + + """ + Isolation has successfully been requested and policy allows isolation. We need to check when isolation is effective. + """ + polling_period = 2 + sleep_time = 60 + + duration = 0 + while duration < 3 * sleep_time: + + url = f'{self.base_url}/api/data/endpoint/Agent/{agent_id}/' + response = self.hlSession.get(url=url) + if response.status_code != 200: + raise Exception( + f'Failed to get agent\'s status for host {agent_id}: {response.status_code} ({response.reason})') + else: + sleep_time = int(response.json().get( + 'policy', {}).get('sleeptime', 60)) * 2 + isolation_state = response.json().get('isolation_state') + + if isolation_state: + return f'Host {agent_id} successfully isolated' + else: + duration += polling_period + time.sleep(polling_period) + raise Exception( + f'Host isolation successfully requested but host never switched to an isolated state...') + + except requests.exceptions.RequestException as e: + raise Exception(e) + + def unisolate_endpoint(self, agent_id): + ''' + Unisolate an endpoint + + :param agent_id: Agent identifier + + :return: A string with the result message + ''' + + url = f'{self.base_url}/api/data/endpoint/Agent/{agent_id}/deisolate/' + + if not agent_id: + raise Exception( + 'No agent Id provided') + + try: + response = self.hlSession.post(url=url) + if response.status_code != 200: + raise Exception( + f'Failed to unisolate host {agent_id}: {response.status_code} ({response.reason})') + else: + + """ + Unisolation has successfully been requested. We need to check when unisolation is effective. + """ + polling_period = 2 + sleep_time = 60 + + duration = 0 + while duration < 3 * sleep_time: + + url = f'{self.base_url}/api/data/endpoint/Agent/{agent_id}/' + response = self.hlSession.get(url=url) + if response.status_code != 200: + raise Exception( + f'Failed to get agent\'s status for host {agent_id}: {response.status_code} ({response.reason})') + else: + sleep_time = int(response.json().get( + 'policy', {}).get('sleeptime', 60))*2 + isolation_state = response.json().get('isolation_state') + + if not isolation_state: + return f'Host {agent_id} successfully unisolated' + + else: + duration += polling_period + time.sleep(polling_period) + raise Exception( + f'Host unisolation successfully requested but host never switched to an unisolated state...') + + except requests.exceptions.RequestException as e: + raise Exception(e) diff --git a/hoxhunt/1.0.0/requirements.txt b/hoxhunt/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/hoxhunt/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/http/1.0.0/api.yaml b/http/1.0.0/api.yaml deleted file mode 100644 index b73b44ed..00000000 --- a/http/1.0.0/api.yaml +++ /dev/null @@ -1,267 +0,0 @@ -walkoff_version: 1.0.0 -app_version: 1.0.0 -name: http -description: HTTP app -tags: - - Testing - - HTTP -categories: - - Testing - - HTTP -contact_info: - name: "@frikkylikeme" - url: https://github.com/frikky - email: "frikky@shuffler.io" -actions: - - name: curl - description: Run a curl command - parameters: - - name: statement - description: The curl command to run - multiline: true - example: "curl https://example.com" - required: true - schema: - type: string - returns: - schema: - type: string - - name: GET - description: Runs a GET request towards the specified endpoint - parameters: - - name: url - description: The URL to get - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: verify - description: Check certificate - multiline: false - options: - - false - - true - required: false - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: POST - description: Runs a POST request towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: PATCH - description: Runs a PATCHrequest towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: PUT - description: Runs a PUT request towards the specified endpoint - parameters: - - name: url - description: The URL to PUT to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: DELETE - description: Runs a DELETE request towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - true - - false - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: HEAD - description: Runs a HEAD request towards the specified endpoint - parameters: - - name: url - description: The URL to HEAD to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: OPTIONS - description: Runs a OPTIONS request towards the specified endpoint - parameters: - - name: url - description: The URL to HEAD to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" -large_image: data:image/png;base64,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 diff --git a/http/1.0.0/requirements.txt b/http/1.0.0/requirements.txt deleted file mode 100644 index ae3e5391..00000000 --- a/http/1.0.0/requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -uncurl==0.0.10 -requests==2.25.1 \ No newline at end of file diff --git a/http/1.0.0/src/app.py b/http/1.0.0/src/app.py deleted file mode 100755 index af48e5a8..00000000 --- a/http/1.0.0/src/app.py +++ /dev/null @@ -1,173 +0,0 @@ -import time -import json -import json -import random -import socket -import uncurl -import asyncio -import requests -import subprocess - -from walkoff_app_sdk.app_base import AppBase - -class HTTP(AppBase): - __version__ = "1.0.0" - app_name = "http" - - def __init__(self, redis, logger, console_logger=None): - print("INIT") - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - # This is dangerously fun :) - # Do we care about arbitrary code execution here? - def curl(self, statement): - process = subprocess.Popen(statement, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True) - stdout = process.communicate() - item = "" - if len(stdout[0]) > 0: - print("Succesfully ran bash!") - item = stdout[0] - else: - print("FAILED to run bash!") - item = stdout[1] - - try: - ret = item.decode("utf-8") - return ret - except: - return item - - return item - #try: - # if not statement.startswith("curl "): - # statement = "curl %s" % statement - - # data = uncurl.parse(statement) - # request = eval(data) - # if isinstance(request, requests.models.Response): - # return request.text - # else: - # return "Unable to parse the curl parameter. Remember to start with curl " - #except: - # return "An error occurred during curl parsing" - - def splitheaders(self, headers): - parsed_headers = {} - if headers: - split_headers = headers.split("\n") - self.logger.info(split_headers) - for header in split_headers: - if ": " in header: - splititem = ": " - elif ":" in header: - splititem = ":" - elif "= " in header: - splititem = "= " - elif "=" in header: - splititem = "=" - else: - self.logger.info("Skipping header %s as its invalid" % header) - continue - - splitheader = header.split(splititem) - if len(splitheader) == 2: - parsed_headers[splitheader[0]] = splitheader[1] - else: - self.logger.info("Skipping header %s with split %s cus only one item" % (header, splititem)) - continue - - return parsed_headers - - def checkverify(self, verify): - if verify == None: - return False - elif verify: - return True - elif not verify: - return False - elif verify.lower().strip() == "false": - return False - else: - return True - - def checkbody(self, body): - # Indicates json - if body.strip().startswith("{"): - body = body.replace("\'", "\"") - - # Not sure if loading is necessary - # Seemed to work with plain string into data=body too, and not parsed json=body - #try: - # body = json.loads(body) - #except json.decoder.JSONDecodeError as e: - # return body - - return body - else: - return body - - def GET(self, url, headers="", verify=True): - parsed_headers = self.splitheaders(headers) - verify = self.checkverify(verify) - return requests.get(url, headers=parsed_headers, verify=verify).text - - def POST(self, url, headers="", body="", verify=True): - parsed_headers = self.splitheaders(headers) - verify = self.checkverify(verify) - body = self.checkbody(body) - return requests.post(url, headers=parsed_headers, data=body, verify=verify).text - - # UNTESTED BELOW HERE - def PUT(self, url, headers="", body="", verify=True): - parsed_headers = self.splitheaders(headers) - verify = self.checkverify(verify) - body = self.checkbody(body) - return requests.put(url, headers=parsed_headers, data=body, verify=verify).text - - def PATCH(self, url, headers="", body="", verify=True): - parsed_headers = self.splitheaders(headers) - verify = self.checkverify(verify) - body = self.checkbody(body) - return requests.patch(url, headers=parsed_headers, data=body, verify=verify).text - - def DELETE(self, url, headers="", body="", verify=True): - parsed_headers = self.splitheaders(headers) - verify = self.checkverify(verify) - return requests.delete(url, headers=parsed_headers, verify=verify).text - - def HEAD(self, url, headers="", body="", verify=True): - parsed_headers = self.splitheaders(headers) - verify = self.checkverify(verify) - body = self.checkbody(body) - return requests.head(url, headers=parsed_headers, verify=verify).text - - def OPTIONS(self, url, headers="", body="", verify=True): - parsed_headers = self.splitheaders(headers) - verify = self.checkverify(verify) - body = self.checkbody(body) - return requests.options(url, headers=parsed_headers, verify=verify).text - - -# Run the actual thing after we've checked params -def run(request): - print("Starting cloud!") - action = request.get_json() - print(action) - print(type(action)) - authorization_key = action.get("authorization") - current_execution_id = action.get("execution_id") - - if action and "name" in action and "app_name" in action: - HTTP.run(action) - return f'Attempting to execute function {action["name"]} in app {action["app_name"]}' - else: - return f'Invalid action' - -if __name__ == "__main__": - HTTP.run() diff --git a/http/1.1.0/api.yaml b/http/1.1.0/api.yaml deleted file mode 100644 index bd622ff8..00000000 --- a/http/1.1.0/api.yaml +++ /dev/null @@ -1,365 +0,0 @@ -walkoff_version: 1.1.0 -app_version: 1.1.0 -name: http -description: HTTP app -tags: - - Testing - - HTTP -categories: - - Testing - - HTTP -contact_info: - name: "@frikkylikeme" - url: https://github.com/frikky - email: "frikky@shuffler.io" -actions: - - name: GET - description: Runs a GET request towards the specified endpoint - parameters: - - name: url - description: The URL to get - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Check certificate - multiline: false - options: - - false - - true - required: false - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: POST - description: Runs a POST request towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: PATCH - description: Runs a PATCHrequest towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: PUT - description: Runs a PUT request towards the specified endpoint - parameters: - - name: url - description: The URL to PUT to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: DELETE - description: Runs a DELETE request towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - true - - false - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: HEAD - description: Runs a HEAD request towards the specified endpoint - parameters: - - name: url - description: The URL to HEAD to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: OPTIONS - description: Runs a OPTIONS request towards the specified endpoint - parameters: - - name: url - description: The URL to HEAD to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: curl - description: Run a curl command - parameters: - - name: statement - description: The curl command to run - multiline: true - example: "curl https://example.com" - required: true - schema: - type: string - returns: - schema: - type: string -large_image: data:image/png;base64,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 diff --git a/http/1.1.0/requirements.txt b/http/1.1.0/requirements.txt deleted file mode 100644 index ae3e5391..00000000 --- a/http/1.1.0/requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -uncurl==0.0.10 -requests==2.25.1 \ No newline at end of file diff --git a/http/1.1.0/src/app.py b/http/1.1.0/src/app.py deleted file mode 100755 index 6b7fcc87..00000000 --- a/http/1.1.0/src/app.py +++ /dev/null @@ -1,247 +0,0 @@ -import time -import json -import ast -import random -import socket -import uncurl -import asyncio -import requests -import subprocess - -from walkoff_app_sdk.app_base import AppBase - -class HTTP(AppBase): - __version__ = "1.0.0" - app_name = "http" - - def __init__(self, redis, logger, console_logger=None): - print("INIT") - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - # This is dangerously fun :) - # Do we care about arbitrary code execution here? - def curl(self, statement): - process = subprocess.Popen(statement, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True) - stdout = process.communicate() - item = "" - if len(stdout[0]) > 0: - print("Succesfully ran bash!") - item = stdout[0] - else: - print("FAILED to run bash!") - item = stdout[1] - - try: - ret = item.decode("utf-8") - return ret - except: - return item - - return item - #try: - # if not statement.startswith("curl "): - # statement = "curl %s" % statement - - # data = uncurl.parse(statement) - # request = eval(data) - # if isinstance(request, requests.models.Response): - # return request.text - # else: - # return "Unable to parse the curl parameter. Remember to start with curl " - #except: - # return "An error occurred during curl parsing" - - def splitheaders(self, headers): - parsed_headers = {} - if headers: - split_headers = headers.split("\n") - self.logger.info(split_headers) - for header in split_headers: - if ": " in header: - splititem = ": " - elif ":" in header: - splititem = ":" - elif "= " in header: - splititem = "= " - elif "=" in header: - splititem = "=" - else: - self.logger.info("Skipping header %s as its invalid" % header) - continue - - splitheader = header.split(splititem) - if len(splitheader) == 2: - parsed_headers[splitheader[0]] = splitheader[1] - else: - self.logger.info("Skipping header %s with split %s cus only one item" % (header, splititem)) - continue - - return parsed_headers - - def checkverify(self, verify): - if verify == None: - return False - elif verify: - return True - elif not verify: - return False - elif verify.lower().strip() == "false": - return False - else: - return True - - def checkbody(self, body): - # Indicates json - if body.strip().startswith("{"): - body = json.dumps(ast.literal_eval(body)) - - # Not sure if loading is necessary - # Seemed to work with plain string into data=body too, and not parsed json=body - #try: - # body = json.loads(body) - #except json.decoder.JSONDecodeError as e: - # return body - - return body - else: - return body - - def fix_url(self, url): - # Random bugs seen by users - if "hhttp" in url: - url = url.replace("hhttp", "http") - - if "http:/" in url and not "http://" in url: - url = url.replace("http:/", "http://", -1) - if "https:/" in url and not "https://" in url: - url = url.replace("https:/", "https://", -1) - if "http:///" in url: - url = url.replace("http:///", "http://", -1) - if "https:///" in url: - url = url.replace("https:///", "https://", -1) - if not "http://" in url and not "http" in url: - url = f"http://{url}" - - return url - - def GET(self, url, headers="", username="", password="", verify=True): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - return requests.get(url, headers=parsed_headers, auth=auth, verify=verify).text - - def POST(self, url, headers="", body="", username="", password="", verify=True): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - return requests.post(url, headers=parsed_headers, auth=auth, data=body, verify=verify).text - - # UNTESTED BELOW HERE - def PUT(self, url, headers="", body="", username="", password="", verify=True): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - return requests.put(url, headers=parsed_headers, auth=auth, data=body, verify=verify).text - - def PATCH(self, url, headers="", body="", username="", password="", verify=True): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - return requests.patch(url, headers=parsed_headers, data=body, auth=auth, verify=verify).text - - def DELETE(self, url, headers="", body="", username="", password="", verify=True): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - return requests.delete(url, headers=parsed_headers, auth=auth, verify=verify).text - - def HEAD(self, url, headers="", body="", username="", password="", verify=True): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - return requests.head(url, headers=parsed_headers, auth=auth, verify=verify).text - - def OPTIONS(self, url, headers="", body="", username="", password="", verify=True): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - return requests.options(url, headers=parsed_headers, auth=auth, verify=verify).text - - -# Run the actual thing after we've checked params -def run(request): - print("Starting cloud!") - action = request.get_json() - print(action) - print(type(action)) - authorization_key = action.get("authorization") - current_execution_id = action.get("execution_id") - - if action and "name" in action and "app_name" in action: - HTTP.run(action) - return f'Attempting to execute function {action["name"]} in app {action["app_name"]}' - else: - return f'Invalid action' - -if __name__ == "__main__": - HTTP.run() diff --git a/http/1.2.0/requirements.txt b/http/1.2.0/requirements.txt deleted file mode 100644 index ae3e5391..00000000 --- a/http/1.2.0/requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -uncurl==0.0.10 -requests==2.25.1 \ No newline at end of file diff --git a/http/1.2.0/src/app.py b/http/1.2.0/src/app.py deleted file mode 100755 index 53eb1379..00000000 --- a/http/1.2.0/src/app.py +++ /dev/null @@ -1,394 +0,0 @@ -import time -import json -import ast -import random -import socket -import uncurl -import asyncio -import requests -import subprocess - -from walkoff_app_sdk.app_base import AppBase - -class HTTP(AppBase): - __version__ = "1.2.0" - app_name = "http" - - def __init__(self, redis, logger, console_logger=None): - print("INIT") - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - # This is dangerously fun :) - # Do we care about arbitrary code execution here? - def curl(self, statement): - process = subprocess.Popen(statement, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True) - stdout = process.communicate() - item = "" - if len(stdout[0]) > 0: - print("Succesfully ran bash!") - item = stdout[0] - else: - print("FAILED to run bash!") - item = stdout[1] - - try: - ret = item.decode("utf-8") - return ret - except: - return item - - return item - #try: - # if not statement.startswith("curl "): - # statement = "curl %s" % statement - - # data = uncurl.parse(statement) - # request = eval(data) - # if isinstance(request, requests.models.Response): - # return request.text - # else: - # return "Unable to parse the curl parameter. Remember to start with curl " - #except: - # return "An error occurred during curl parsing" - - def splitheaders(self, headers): - parsed_headers = {} - if headers: - split_headers = headers.split("\n") - self.logger.info(split_headers) - for header in split_headers: - if ": " in header: - splititem = ": " - elif ":" in header: - splititem = ":" - elif "= " in header: - splititem = "= " - elif "=" in header: - splititem = "=" - else: - self.logger.info("Skipping header %s as its invalid" % header) - continue - - splitheader = header.split(splititem) - if len(splitheader) == 2: - parsed_headers[splitheader[0]] = splitheader[1] - else: - self.logger.info("Skipping header %s with split %s cus only one item" % (header, splititem)) - continue - - return parsed_headers - - def checkverify(self, verify): - if verify == None: - return False - elif verify: - return True - elif not verify: - return False - elif verify.lower().strip() == "false": - return False - else: - return True - - def checkbody(self, body): - # Indicates json - if body.strip().startswith("{"): - body = json.dumps(ast.literal_eval(body)) - - - # Not sure if loading is necessary - # Seemed to work with plain string into data=body too, and not parsed json=body - #try: - # body = json.loads(body) - #except json.decoder.JSONDecodeError as e: - # return body - - return body - else: - return body - - def fix_url(self, url): - # Random bugs seen by users - if "hhttp" in url: - url = url.replace("hhttp", "http") - - if "http:/" in url and not "http://" in url: - url = url.replace("http:/", "http://", -1) - if "https:/" in url and not "https://" in url: - url = url.replace("https:/", "https://", -1) - if "http:///" in url: - url = url.replace("http:///", "http://", -1) - if "https:///" in url: - url = url.replace("https:///", "https://", -1) - if not "http://" in url and not "http" in url: - url = f"http://{url}" - - return url - - def return_file(self, requestdata): - filedata = { - "filename": "response.txt", - "data": requestdata, - } - fileret = self.set_files([filedata]) - if len(fileret) == 1: - return {"success": True, "file_id": fileret[0]} - - return fileret - - def GET(self, url, headers="", username="", password="", verify=True, http_proxy="", https_proxy="", timeout=5, to_file=False): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - proxies = None - if http_proxy: - proxies["http"] = http_proxy - if https_proxy: - proxies["https"] = https_proxy - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) - - if to_file == "true": - to_file = True - else: - to_file = False - - request = requests.get(url, headers=parsed_headers, auth=auth, verify=verify, proxies=proxies, timeout=timeout) - if not to_file: - return request.text - - return self.return_file(request.text) - - def POST(self, url, headers="", body="", username="", password="", verify=True, http_proxy="", https_proxy="", timeout=5, to_file=False): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - proxies = None - if http_proxy: - proxies["http"] = http_proxy - if https_proxy: - proxies["https"] = https_proxy - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) - - if to_file == "true": - to_file = True - else: - to_file = False - - request = requests.post(url, headers=parsed_headers, auth=auth, data=body, verify=verify, proxies=proxies, timeout=timeout) - if not to_file: - return request.text - - return self.return_file(request.text) - - # UNTESTED BELOW HERE - def PUT(self, url, headers="", body="", username="", password="", verify=True, http_proxy="", https_proxy="", timeout=5, to_file=False): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - proxies = None - if http_proxy: - proxies["http"] = http_proxy - if https_proxy: - proxies["https"] = https_proxy - - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) - - if to_file == "true": - to_file = True - else: - to_file = False - - request = requests.put(url, headers=parsed_headers, auth=auth, data=body, verify=verify, proxies=proxies, timeout=timeout) - if not to_file: - return request.text - - return self.return_file(request.text) - - def PATCH(self, url, headers="", body="", username="", password="", verify=True, http_proxy="", https_proxy="", timeout=5, to_file=False): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - proxies = None - if http_proxy: - proxies["http"] = http_proxy - if https_proxy: - proxies["https"] = https_proxy - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) - - if to_file == "true": - to_file = True - else: - to_file = False - - request = requests.patch(url, headers=parsed_headers, data=body, auth=auth, verify=verify, proxies=proxies, timeout=timeout) - if not to_file: - return request.text - - return self.return_file(request.text) - - def DELETE(self, url, headers="", body="", username="", password="", verify=True, http_proxy="", https_proxy="", timeout=5, to_file=False): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - proxies = None - if http_proxy: - proxies["http"] = http_proxy - if https_proxy: - proxies["https"] = https_proxy - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) - - if to_file == "true": - to_file = True - else: - to_file = False - - request = requests.delete(url, headers=parsed_headers, auth=auth, verify=verify, proxies=proxies, timeout=timeout) - if not to_file: - return request.text - - return self.return_file(request.text) - - def HEAD(self, url, headers="", body="", username="", password="", verify=True, http_proxy="", https_proxy="", timeout=5, to_file=False): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - proxies = None - if http_proxy: - proxies["http"] = http_proxy - if https_proxy: - proxies["https"] = https_proxy - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) - - if to_file == "true": - to_file = True - else: - to_file = False - - request = requests.head(url, headers=parsed_headers, auth=auth, verify=verify, proxies=proxies, timeout=timeout) - if not to_file: - return request.text - - return self.return_file(request.text) - - def OPTIONS(self, url, headers="", body="", username="", password="", verify=True, http_proxy="", https_proxy="", timeout=5, to_file=False): - url = self.fix_url(url) - - parsed_headers = self.splitheaders(headers) - parsed_headers["User-Agent"] = "Shuffle Automation" - verify = self.checkverify(verify) - body = self.checkbody(body) - proxies = None - if http_proxy: - proxies["http"] = http_proxy - if https_proxy: - proxies["https"] = https_proxy - - auth=None - if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) - - if not timeout: - timeout = 5 - - if timeout: - timeout = int(timeout) - - if to_file == "true": - to_file = True - else: - to_file = False - - request = requests.options(url, headers=parsed_headers, auth=auth, verify=verify, proxies=proxies, timeout=timeout) - if not to_file: - return request.text - - return self.return_file(request.text) - - -# Run the actual thing after we've checked params -def run(request): - print("Starting cloud!") - action = request.get_json() - print(action) - print(type(action)) - authorization_key = action.get("authorization") - current_execution_id = action.get("execution_id") - - if action and "name" in action and "app_name" in action: - HTTP.run(action) - return f'Attempting to execute function {action["name"]} in app {action["app_name"]}' - else: - return f'Invalid action' - -if __name__ == "__main__": - HTTP.run() diff --git a/http/1.3.0/api.yaml b/http/1.3.0/api.yaml deleted file mode 100644 index 8e7b9e21..00000000 --- a/http/1.3.0/api.yaml +++ /dev/null @@ -1,522 +0,0 @@ -walkoff_version: 1.3.0 -app_version: 1.3.0 -name: http -description: HTTP app -tags: - - Testing - - HTTP -categories: - - Testing - - HTTP -contact_info: - name: "@frikkylikeme" - url: https://github.com/frikky - email: "frikky@shuffler.io" -actions: - - name: GET - description: Runs a GET request towards the specified endpoint - parameters: - - name: url - description: The URL to get - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Check certificate - multiline: false - options: - - false - - true - required: false - example: "false" - schema: - type: bool - - name: http_proxy - description: Add a HTTP proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: https_proxy - description: Add a HTTPS proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: timeout - description: Add a timeout for the request, in seconds - multiline: false - required: false - example: "10" - schema: - type: bool - - name: to_file - description: Makes the response into a file, and returns it as an ID - multiline: false - required: false - options: - - false - - true - example: "true" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: POST - description: Runs a POST request towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - - name: http_proxy - description: Add a HTTP proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: https_proxy - description: Add a HTTPS proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: timeout - description: Add a timeout for the request, in seconds - multiline: false - required: false - example: "10" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: PATCH - description: Runs a PATCHrequest towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - - name: http_proxy - description: Add a HTTP proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: https_proxy - description: Add a HTTPS proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: timeout - description: Add a timeout for the request, in seconds - multiline: false - required: false - example: "10" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: PUT - description: Runs a PUT request towards the specified endpoint - parameters: - - name: url - description: The URL to PUT to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: body - description: The body to use - multiline: true - example: "{\n\t'json': 'blob'\n}" - required: false - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - - name: http_proxy - description: Add a HTTP proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: https_proxy - description: Add a HTTPS proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: timeout - description: Add a timeout for the request, in seconds - multiline: false - required: false - example: "10" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: DELETE - description: Runs a DELETE request towards the specified endpoint - parameters: - - name: url - description: The URL to post to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - true - - false - example: "false" - schema: - type: bool - - name: http_proxy - description: Add a HTTP proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: https_proxy - description: Add a HTTPS proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: timeout - description: Add a timeout for the request, in seconds - multiline: false - required: false - example: "10" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: HEAD - description: Runs a HEAD request towards the specified endpoint - parameters: - - name: url - description: The URL to HEAD to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - - name: http_proxy - description: Add a HTTP proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: https_proxy - description: Add a HTTPS proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: timeout - description: Add a timeout for the request, in seconds - multiline: false - required: false - example: "10" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: OPTIONS - description: Runs a OPTIONS request towards the specified endpoint - parameters: - - name: url - description: The URL to HEAD to - multiline: false - example: "https://example.com" - required: true - schema: - type: string - - name: headers - description: Headers to use - multiline: true - required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" - schema: - type: string - - name: username - description: The username to use - multiline: false - required: false - example: "Username" - schema: - type: string - - name: password - description: The password to use - multiline: false - required: false - example: "*****" - schema: - type: string - - name: verify - description: Whether to check the certificate or not - multiline: false - required: false - options: - - false - - true - example: "false" - schema: - type: bool - - name: http_proxy - description: Add a HTTP proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: https_proxy - description: Add a HTTPS proxy - multiline: false - required: false - example: "http://192.168.0.1:8080" - schema: - type: bool - - name: timeout - description: Add a timeout for the request, in seconds - multiline: false - required: false - example: "10" - schema: - type: bool - returns: - schema: - type: string - example: "404 NOT FOUND" - - name: curl - description: Run a curl command - parameters: - - name: statement - description: The curl command to run - multiline: true - example: "curl https://example.com" - required: true - schema: - type: string - returns: - schema: - type: string -large_image: data:image/png;base64,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 diff --git a/http/1.3.0/requirements.txt b/http/1.3.0/requirements.txt deleted file mode 100644 index ae3e5391..00000000 --- a/http/1.3.0/requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -uncurl==0.0.10 -requests==2.25.1 \ No newline at end of file diff --git a/http/1.0.0/Dockerfile b/http/1.4.0/Dockerfile similarity index 100% rename from http/1.0.0/Dockerfile rename to http/1.4.0/Dockerfile diff --git a/http/1.2.0/api.yaml b/http/1.4.0/api.yaml similarity index 96% rename from http/1.2.0/api.yaml rename to http/1.4.0/api.yaml index 65e22188..0c542673 100644 --- a/http/1.2.0/api.yaml +++ b/http/1.4.0/api.yaml @@ -1,12 +1,12 @@ -walkoff_version: 1.2.0 -app_version: 1.2.0 +walkoff_version: 1.4.0 +app_version: 1.4.0 name: http description: HTTP app tags: - Testing - HTTP categories: - - Testing + - Other - HTTP contact_info: name: "@frikkylikeme" @@ -27,7 +27,7 @@ actions: description: Headers to use multiline: true required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" + example: "Content-Type: application/json" schema: type: string - name: username @@ -88,7 +88,20 @@ actions: returns: schema: type: string - example: "404 NOT FOUND" + example: | + { + "status": 200, + "body": { + "example": "json" + "data": "json" + }, + "url": "https://example.com", + "headers": { + "Content-Type": "application/json" + }, + "cookies": {}, + "success": true + } - name: POST description: Runs a POST request towards the specified endpoint parameters: @@ -110,7 +123,7 @@ actions: description: Headers to use multiline: true required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" + example: "Content-Type: application/json" schema: type: string - name: username @@ -163,7 +176,7 @@ actions: type: string example: "404 NOT FOUND" - name: PATCH - description: Runs a PATCHrequest towards the specified endpoint + description: Runs a PATCH request towards the specified endpoint parameters: - name: url description: The URL to post to @@ -183,7 +196,7 @@ actions: description: Headers to use multiline: true required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" + example: "Content-Type: application/json" schema: type: string - name: username @@ -256,7 +269,7 @@ actions: description: Headers to use multiline: true required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" + example: "Content-Type: application/json" schema: type: string - name: username @@ -318,11 +331,18 @@ actions: required: true schema: type: string + - name: body + description: The body to use + multiline: true + example: "{\n\t'json': 'blob'\n}" + required: false + schema: + type: string - name: headers description: Headers to use multiline: true required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" + example: "Content-Type: application/json" schema: type: string - name: username @@ -388,7 +408,7 @@ actions: description: Headers to use multiline: true required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" + example: "Content-Type: application/json" schema: type: string - name: username @@ -454,7 +474,7 @@ actions: description: Headers to use multiline: true required: false - example: "Authorization: Bearer asd\nContent-Type: application/json" + example: "Content-Type: application/json" schema: type: string - name: username diff --git a/http/1.4.0/requirements.txt b/http/1.4.0/requirements.txt new file mode 100644 index 00000000..b7101bd6 --- /dev/null +++ b/http/1.4.0/requirements.txt @@ -0,0 +1,2 @@ +uncurl==0.0.10 +shuffle_sdk==0.0.31 diff --git a/http/1.3.0/src/app.py b/http/1.4.0/src/app.py similarity index 74% rename from http/1.3.0/src/app.py rename to http/1.4.0/src/app.py index 68bea70c..95ee49f8 100755 --- a/http/1.3.0/src/app.py +++ b/http/1.4.0/src/app.py @@ -8,10 +8,10 @@ import requests import subprocess -from walkoff_app_sdk.app_base import AppBase +from shuffle_sdk import AppBase class HTTP(AppBase): - __version__ = "1.3.0" + __version__ = "1.4.0" app_name = "http" def __init__(self, redis, logger, console_logger=None): @@ -26,6 +26,7 @@ def __init__(self, redis, logger, console_logger=None): # This is dangerously fun :) # Do we care about arbitrary code execution here? + # Probably not huh def curl(self, statement): process = subprocess.Popen(statement, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True) stdout = process.communicate() @@ -44,18 +45,6 @@ def curl(self, statement): return item return item - #try: - # if not statement.startswith("curl "): - # statement = "curl %s" % statement - - # data = uncurl.parse(statement) - # request = eval(data) - # if isinstance(request, requests.models.Response): - # return request.text - # else: - # return "Unable to parse the curl parameter. Remember to start with curl " - #except: - # return "An error occurred during curl parsing" def splitheaders(self, headers): parsed_headers = {} @@ -63,12 +52,8 @@ def splitheaders(self, headers): split_headers = headers.split("\n") self.logger.info(split_headers) for header in split_headers: - if ": " in header: - splititem = ": " - elif ":" in header: + if ":" in header: splititem = ":" - elif "= " in header: - splititem = "= " elif "=" in header: splititem = "=" else: @@ -76,8 +61,8 @@ def splitheaders(self, headers): continue splitheader = header.split(splititem) - if len(splitheader) == 2: - parsed_headers[splitheader[0]] = splitheader[1] + if len(splitheader) >= 2: + parsed_headers[splitheader[0].strip()] = splititem.join(splitheader[1:]).strip() else: self.logger.info("Skipping header %s with split %s cus only one item" % (header, splititem)) continue @@ -114,6 +99,12 @@ def checkbody(self, body): else: return body + if isinstance(body, dict) or isinstance(body, list): + try: + body = json.dumps(body) + except: + return body + return body def fix_url(self, url): @@ -163,14 +154,16 @@ def prepare_response(self, request): except: pass - return json.dumps({ - "success": True, + parseddata = { "status": request.status_code, + "body": jsondata, "url": request.url, "headers": parsedheaders, - "body": jsondata, "cookies":cookies, - }) + "success": True, + } + + return json.dumps(parseddata) except Exception as e: print(f"[WARNING] Failed in request: {e}") return request.text @@ -181,7 +174,8 @@ def GET(self, url, headers="", username="", password="", verify=True, http_proxy parsed_headers = self.splitheaders(headers) parsed_headers["User-Agent"] = "Shuffle Automation" verify = self.checkverify(verify) - proxies = None + + proxies = {} if http_proxy: proxies["http"] = http_proxy if https_proxy: @@ -189,12 +183,20 @@ def GET(self, url, headers="", username="", password="", verify=True, http_proxy auth=None if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) + # Shouldn't be used if authorization headers exist + if "Authorization" in parsed_headers: + #print("Found authorization - skipping username & pw") + pass + else: + auth = requests.auth.HTTPBasicAuth(username, password) if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) + timeout = 25 + else: + try: + timeout = int(timeout) + except: + timeout = 25 if to_file == "true": to_file = True @@ -214,7 +216,7 @@ def POST(self, url, headers="", body="", username="", password="", verify=True, parsed_headers["User-Agent"] = "Shuffle Automation" verify = self.checkverify(verify) body = self.checkbody(body) - proxies = None + proxies = {} if http_proxy: proxies["http"] = http_proxy if https_proxy: @@ -222,12 +224,20 @@ def POST(self, url, headers="", body="", username="", password="", verify=True, auth=None if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) + # Shouldn't be used if authorization headers exist + if "Authorization" in parsed_headers: + #print("Found authorization - skipping username & pw") + pass + else: + auth = requests.auth.HTTPBasicAuth(username, password) if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) + timeout = 25 + else: + try: + timeout = int(timeout) + except: + timeout = 25 if to_file == "true": to_file = True @@ -240,7 +250,6 @@ def POST(self, url, headers="", body="", username="", password="", verify=True, return self.return_file(request.text) - # UNTESTED BELOW HERE def PUT(self, url, headers="", body="", username="", password="", verify=True, http_proxy="", https_proxy="", timeout=5, to_file=False): url = self.fix_url(url) @@ -248,7 +257,7 @@ def PUT(self, url, headers="", body="", username="", password="", verify=True, h parsed_headers["User-Agent"] = "Shuffle Automation" verify = self.checkverify(verify) body = self.checkbody(body) - proxies = None + proxies = {} if http_proxy: proxies["http"] = http_proxy if https_proxy: @@ -257,12 +266,20 @@ def PUT(self, url, headers="", body="", username="", password="", verify=True, h auth=None if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) + # Shouldn't be used if authorization headers exist + if "Authorization" in parsed_headers: + #print("Found authorization - skipping username & pw") + pass + else: + auth = requests.auth.HTTPBasicAuth(username, password) if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) + timeout = 25 + else: + try: + timeout = int(timeout) + except: + timeout = 25 if to_file == "true": to_file = True @@ -282,7 +299,7 @@ def PATCH(self, url, headers="", body="", username="", password="", verify=True, parsed_headers["User-Agent"] = "Shuffle Automation" verify = self.checkverify(verify) body = self.checkbody(body) - proxies = None + proxies = {} if http_proxy: proxies["http"] = http_proxy if https_proxy: @@ -290,12 +307,20 @@ def PATCH(self, url, headers="", body="", username="", password="", verify=True, auth=None if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) + # Shouldn't be used if authorization headers exist + if "Authorization" in parsed_headers: + #print("Found authorization - skipping username & pw") + pass + else: + auth = requests.auth.HTTPBasicAuth(username, password) if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) + timeout = 25 + else: + try: + timeout = int(timeout) + except: + timeout = 25 if to_file == "true": to_file = True @@ -314,7 +339,8 @@ def DELETE(self, url, headers="", body="", username="", password="", verify=True parsed_headers = self.splitheaders(headers) parsed_headers["User-Agent"] = "Shuffle Automation" verify = self.checkverify(verify) - proxies = None + body = self.checkbody(body) + proxies = {} if http_proxy: proxies["http"] = http_proxy if https_proxy: @@ -322,19 +348,27 @@ def DELETE(self, url, headers="", body="", username="", password="", verify=True auth=None if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) + # Shouldn't be used if authorization headers exist + if "Authorization" in parsed_headers: + #print("Found authorization - skipping username & pw") + pass + else: + auth = requests.auth.HTTPBasicAuth(username, password) if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) + timeout = 25 + else: + try: + timeout = int(timeout) + except: + timeout = 25 if to_file == "true": to_file = True else: to_file = False - request = requests.delete(url, headers=parsed_headers, auth=auth, verify=verify, proxies=proxies, timeout=timeout) + request = requests.delete(url, headers=parsed_headers, data=body, auth=auth, verify=verify, proxies=proxies, timeout=timeout) if not to_file: return self.prepare_response(request) @@ -347,7 +381,7 @@ def HEAD(self, url, headers="", body="", username="", password="", verify=True, parsed_headers["User-Agent"] = "Shuffle Automation" verify = self.checkverify(verify) body = self.checkbody(body) - proxies = None + proxies = {} if http_proxy: proxies["http"] = http_proxy if https_proxy: @@ -355,12 +389,20 @@ def HEAD(self, url, headers="", body="", username="", password="", verify=True, auth=None if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) + # Shouldn't be used if authorization headers exist + if "Authorization" in parsed_headers: + #print("Found authorization - skipping username & pw") + pass + else: + auth = requests.auth.HTTPBasicAuth(username, password) if not timeout: - timeout = 5 - if timeout: - timeout = int(timeout) + timeout = 25 + else: + try: + timeout = int(timeout) + except: + timeout = 25 if to_file == "true": to_file = True @@ -380,7 +422,7 @@ def OPTIONS(self, url, headers="", body="", username="", password="", verify=Tru parsed_headers["User-Agent"] = "Shuffle Automation" verify = self.checkverify(verify) body = self.checkbody(body) - proxies = None + proxies = {} if http_proxy: proxies["http"] = http_proxy if https_proxy: @@ -388,13 +430,20 @@ def OPTIONS(self, url, headers="", body="", username="", password="", verify=Tru auth=None if username or password: - auth = requests.auth.HTTPBasicAuth(username, password) + # Shouldn't be used if authorization headers exist + if "Authorization" in parsed_headers: + #print("Found authorization - skipping username & pw") + pass + else: + auth = requests.auth.HTTPBasicAuth(username, password) if not timeout: - timeout = 5 - - if timeout: - timeout = int(timeout) + timeout = 25 + else: + try: + timeout = int(timeout) + except: + timeout = 25 if to_file == "true": to_file = True @@ -410,10 +459,7 @@ def OPTIONS(self, url, headers="", body="", username="", password="", verify=Tru # Run the actual thing after we've checked params def run(request): - print("Starting cloud!") action = request.get_json() - print(action) - print(type(action)) authorization_key = action.get("authorization") current_execution_id = action.get("execution_id") diff --git a/lastline/1.0.0/api.yaml b/lastline/1.0.0/api.yaml deleted file mode 100644 index 6b47d371..00000000 --- a/lastline/1.0.0/api.yaml +++ /dev/null @@ -1,312 +0,0 @@ -walkoff_version: 1.0.0 -app_version: 1.0.0 -name: lastline -description: Lastline app interface -tags: - - sandbox - - antivirus - - email -categories: - - sandbox - - antivirus - - email -contact_info: - name: "@frikkylikeme" - url: https://github.com/frikky - email: "frikky@shuffler.io" -actions: - - name: get_event - description: Get an event - parameters: - - name: url - description: The url to use for the API - multiline: false - example: "https://user.lastline.com" - required: true - schema: - type: string - - name: user - description: The user to use for the API - multiline: false - example: "Username" - required: true - schema: - type: string - - name: password - description: The password to use for the API - multiline: false - example: "p@ssw0rd" - required: true - schema: - type: string - - name: event_id - description: The event ID to get - multiline: false - example: "" - required: true - schema: - type: string - returns: - schema: - type: string - - name: get_mail_attachments - description: Get unique mail attachments - parameters: - - name: url - description: The url to use for the API - multiline: false - example: "https://user.lastline.com" - required: true - schema: - type: string - - name: user - description: The user to use for the API - multiline: false - example: "Username" - required: true - schema: - type: string - - name: password - description: The password to use for the API - multiline: false - example: "p@ssw0rd" - required: true - schema: - type: string - - name: start_time - description: The starttime to use - multiline: false - example: "2019-06-01" - required: true - schema: - type: string - - name: end_time - description: The endtime to use - multiline: false - example: "2019-06-02" - required: true - schema: - type: string - - name: limit - description: Max events to get - multiline: false - example: "2019-06-02" - required: false - schema: - type: string - returns: - schema: - type: string - - name: get_mail_urls - description: Get unique url seen in mail - parameters: - - name: url - description: The url to use for the API - multiline: false - example: "https://user.lastline.com" - required: true - schema: - type: string - - name: user - description: The user to use for the API - multiline: false - example: "Username" - required: true - schema: - type: string - - name: password - description: The password to use for the API - multiline: false - example: "p@ssw0rd" - required: true - schema: - type: string - - name: start_time - description: The starttime to use - multiline: false - example: "2019-06-01" - required: true - schema: - type: string - - name: end_time - description: The endtime to use - multiline: false - example: "2019-06-02" - required: true - schema: - type: string - - name: limit - description: Max events to get - multiline: false - example: "2019-06-02" - required: false - schema: - type: string - returns: - schema: - type: string - - name: get_network_events - description: Get network events - parameters: - - name: url - description: The url to use for the API - multiline: false - example: "https://user.lastline.com" - required: true - schema: - type: string - - name: user - description: The user to use for the API - multiline: false - example: "Username" - required: true - schema: - type: string - - name: password - description: The password to use for the API - multiline: false - example: "p@ssw0rd" - required: true - schema: - type: string - - name: start_time - description: The starttime to use - multiline: false - example: "2019-06-01" - required: true - schema: - type: string - - name: end_time - description: The endtime to use - multiline: false - example: "2019-06-02" - required: true - schema: - type: string - - name: limit - description: Max events to get - multiline: false - example: "2019-06-02" - required: false - schema: - type: string - returns: - schema: - type: string - - name: get_endpoint_events - description: Gets endpoint events - parameters: - - name: url - description: The url to use for the API - multiline: false - example: "https://user.lastline.com" - required: true - schema: - type: string - - name: user - description: The user to use for the API - multiline: false - example: "Username" - required: true - schema: - type: string - - name: password - description: The password to use for the API - multiline: false - example: "p@ssw0rd" - required: true - schema: - type: string - - name: start_time - description: The starttime to use - multiline: false - example: "2019-06-01" - required: true - schema: - type: string - - name: end_time - description: The endtime to use - multiline: false - example: "2019-06-02" - required: true - schema: - type: string - - name: limit - description: Max events to get - multiline: false - example: "2019-06-02" - required: false - schema: - type: string - returns: - schema: - type: string - - name: get_history - description: Get submission history - parameters: - - name: url - description: The url to use for the API - multiline: false - example: "https://user.lastline.com" - required: true - schema: - type: string - - name: user - description: The user to use for the API - multiline: false - example: "Username" - required: true - schema: - type: string - - name: password - description: The password to use for the API - multiline: false - example: "p@ssw0rd" - required: true - schema: - type: string - - name: limit - description: Max events to get - multiline: false - example: "2" - required: false - schema: - type: string - returns: - schema: - type: string - - name: submit_url - description: Submit an url for analysis - parameters: - - name: url - description: The url to use for the API - multiline: false - example: "https://user.lastline.com" - required: true - schema: - type: string - - name: user - description: The user to use for the API - multiline: false - example: "Username" - required: true - schema: - type: string - - name: password - description: The password to use for the API - multiline: false - example: "p@ssw0rd" - required: true - schema: - type: string - - name: url_to_submit - description: The url to submit - multiline: false - example: "https://malicious.com" - required: false - schema: - type: string - returns: - schema: - type: string -large_image: data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAA1CAYAAAC3ME4GAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QA/wD/AP+gvaeTAAAAB3RJTUUH4wkCAzo1ikHNdQAACe9JREFUeNrtmmtwVOUZgJ9zzu5md8Mm2c39soEACXeKmo7DLRAsiiJoQS0XW8UqOp2i41jAKncdL1idtjoVsTMi4FisVmcUtYJIUcRASAggkEA2NwLksskm2Vv2cr7+CAYQqEmwcn6c51dy5vve79v32e8975k9khBCoKMZ5Ku9AZ0L0YVoDF2IxtCFaAxdiMbQhWgMXYjG0IVoDF2IxtCFaAxdiMbQhWgMXYjG0IVoDF2IxjD0dGBnZycHSktxNzcjKwoATqeTocOGoZz9/3y8oSYafBWoIoIQAkU2khY7lFhT4tX+zJqmx0IMBgOqKtiyZQtFe74hHA6TkpLCnHnzmDt/HikpKQBE1RAuzzfsq3+bRl8FqohiN2dxTfpssuLGXBAzGAyyeeNGzGYLc+bNxWDo8XZ6RSDcRsmZd0m2DiIvcTIAnuBJKty7SOs3lOz4a69O9i+BsmrVqlU9GSjLMk6nk8mFhcTHx+Fyuag/eZJ9e/dSsn8/doeD1MxEik69wVe1f6c1eBKjbGZo0g0U5ixioH0sBtl0QUyf18tTq9dQW1PDzNtv+9GECCFQVRVZ7qrI3lAT210vIksGBjnGA1DbVsJnlWsxKVYG2sdebQ/d9DoDdrudBx58kHHjJ7B+3Tq2fbaNvUVFVJRXMH3mzUyYNQiH1YmETH76HAY5xmOQYy4TTUJR5O7E/Vh8vXs3sqwwdty5REuSjCSdWyet3zBuHLSEZOvAnybTPaRPmZAkiZGjRvLs2udY+fQyRo4cRUdHO29v3sLLT/yL0IExTHU+yZCkKf9DxuWJRCK0t7fT3NxMR0cHqqpeNCYUCtHS0kJLSwudnZ3d1w+WlfHUqtXU1daiqiqqeulXBvqZkhiVeitptuFnrwiiaghVRAEIq0H8YQ8RtfOS81URIRBpIxhp754DEBVhwtEAUTWMoPevK/S5RqgiSqV3BzFjDvHY83ez873DfPjBVo4ePcILa2ooL6thyeNLSUxK6lVct9vNn9au5fChw3QGg8T2i2XixAJ+c+89JCUnA7C3qIgNb7xBVaULJIm0tDQeefRR4uPjWbl8BeXl5by5YQOffPwxU2+8iZvvKACk7jW8oWa+ql1PINxGmm0412feTSjqY2f138iwjcBijOfAmffxhdzEmzPIT/8VzvhrusWdbD9I2ZkPcAeqkZBJtw3n2vQ7cViy8YaaOdlehqqGGZxYgMUQ/9MIqfbs5cva9fjDHhyWGhb+4QkKC2/k+WefoaK8gn++8w7Jyck8tmQxkiT1OK4syxgMRvLz8+lns3HkyLese/VV/IEAy1Ysp76+nhXLluP3+Zhx20wsFgu1NbVIksTx4xWYTCYURSHWasVut2O1Wi5eQ1IwKlYq3P9BFVFEpiCihqjvOEh9exmypOCwZGOyOKlu3Ysv5Ob2oc/Rz5RIXXsZnx5/BpPBSq6jgFDUz9HmbbQG6piet5JYo4O02CGEooE+VYc+CRFCpdy9g0C4DRmZ/vHXkxE/AucNBto8HpYuXkwoFOKLHTu474H7cTgcPY5tt9tZtWZ1dyvd0dHBwt/ez66dO/E8vIi62lqqXC7uWXAvi5cuBUBVVSRJQpJ+RjAY5EBpKXPnz+eXs2cB0Bqog/PKh9VoZ5xzAfXtZdD9ZZGQJYW2ztNMyXmEkSm3IFD53PUSR5q24Q5UYTUmUHr6XaIizLRBfyS135CuPVuc7Kx6mSpPESOSp5FozelLWq9ACCqhiO+7z4HNlIwidYWSFfnciejFyTif9rY2iouLqXJVIYSK3+/HHwgQ8AdITU0jLS2Njz/aSlp6OpMmTaL/gAHdHdq5tX9olYsHCKGSZM0hN7EAWVIAhZTYPL5t+jehiA9f2E2DtxxbTAohNcCpjsNIyBjkGCRJoclXCcl9dtF3IbJkICtuDJWtXyOEytHm7WTGj0bpSGbzm5sIBoMoikLhlELsdnuvYle5XKxcvoLDhw6RnJKMohg4WVdHQkICqholZ2AOq59+itdfW8+fX3yJ19e9xrRbbuH3ixaRmHT+Q2fvvwwCQazRgUmxnkuQbEJCQgCdES9hNYjbX82nJ57pXkcIFVkyIEtX3i32+R4yPGUajf4THGveTrPfxdaK1eTapjJ99lT8/gC5Q3K5d8GCHt0/zh+xaeMm9hcXs2rNGm6Y+gsAVjy5jNKSku6iM7mwkOvy8zl08CBvbdrMxg0bSE9PY+FDD51NLNDHFzIlSUa6pEyBLBkAiXTbcCZmP3hBGw1dpfCqCbEY4pjU/3ckmDP4tvETPMFTlIXfIfPa0Sy7biHDMgpIiP+he4cAAVFVRQhBOBSi8sQJUlJTKZg8CYfDgRACs8V80Uybzca48eNJSEhg9+7dnDh+4lxUVSUYDF40p6s9FfTl9IAg1uTAFpOCL9TS9bcp5YoF/GhC2jsbKD3zHq2BOkanzuR0xxGqPUXUevbjNrkIeeoZY55FfEz6ZWMYTSZscXFUuVx8sWMHo0aNov+AAewtKuKjDz9kYkEB4VCYpsYmhBBIksSZM2c4UFpKZlYWQlX54P338ft8DB02FOhqChRF4ctdu8jNyyMhIYGU7DhMspUGbznVnn0kxw5GkQxdzwkXnCQB33t26LoiEEIQo/RjWNJUvqpdz86qVxidOgOLMYFgpINApI2B9rEYZTNXQq+FRNQQrtav2Vv/Fg2+clQRpTPipTDnYQY6xlF86h+4/dUU12+h1lPCzzPnMdgx4ZItoNVqZfYdd/DiCy/w+OIlzJk3l/m/vhtXZSWv/OWvvP7aeoRQ6Qx2kpuXS0xMDPv3FbP8iSdB6qrdCLjzrru4fVZXRzV69Gimz7iVz7dtZ8+ePUyZMoVn1z7HiJRplJx+j63H1zDOeR/Dk2/CKFswKGYkupoBo2zB8L2EKpIBk2JFlrtSNTp1BqGoj8ONn1DbVoIiG4mKMHazk0zbSIymKxMi9ebtd0+wnuJTWyhv3kFn1IdRMTPYMYH8jDkkWQciIdESqKH41BYq3DsJRQOYFAt5iZPJz5iDw5J9seBIBFdlJQ0NDWRkZDBo8GBaW1spP1ZOc1MjsqKQlJREZlYW6enpeL1eKsrLaWxoBAmczmxy83Ixm88lwuv1Un7sGO3tHWRmZpCbl0dUhHEHqgiG27FbsrGZkmnyV6LIRhIt/VFFlCa/C6Mcc3afXWXNH27FE6zHbsnGYogDukpfW/AULcFawtEgMUosCeZM4s0ZZ7uzn0SIwO2voTVY173ZGCWWNNuwi45pRO3kjPcYwUjH2ZkqdnMWidacy9wwdb6jVydE5/+P/ouhxtCFaAxdiMbQhWgMXYjG0IVoDF2IxtCFaAxdiMbQhWgMXYjG0IVoDF2IxtCFaAxdiMbQhWgMXYjG0IVoDF2IxtCFaIz/Ao0Z1pmrb5ogAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE5LTA5LTAyVDAzOjU5OjIzLTA0OjAwl48nXQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxOS0wOS0wMlQwMzo1ODo1My0wNDowMAPV/cYAAAAASUVORK5CYII= diff --git a/lastline/1.0.0/requirements.txt b/lastline/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/lastline/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/microsoft-excel/1.0.0/api.yaml b/microsoft-excel/1.0.0/api.yaml index d52baafd..0c27ae28 100644 --- a/microsoft-excel/1.0.0/api.yaml +++ b/microsoft-excel/1.0.0/api.yaml @@ -30,6 +30,40 @@ authentication: schema: type: string actions: + - name: get_excel_file_data + description: Gets data from all cells in an excel file as a list. If CSV, returns it as a CSV list. Max 25.000 lines in total due to timeouts. + auth_not_required: true + parameters: + - name: file_id + description: The file id of the file + multiline: false + required: true + schema: + type: string + - name: to_list + description: Whether the output should be a list or not + multiline: false + required: false + options: + - true + - false + schema: + type: string + - name: sheets + description: The sheets to use. Comma separated. + multiline: false + required: false + schema: + type: string + - name: max_rows + description: The maximum number of rows to return + multiline: false + required: false + schema: + type: string + returns: + schema: + type: string - name: get_user_id description: Returns all users - name: get_files @@ -176,16 +210,4 @@ actions: # returns: # schema: # type: string - - name: get_excel_file_data - description: Gets data from all cells in an excel file as a list - parameters: - - name: file_id - description: The file id of the file - multiline: false - required: true - schema: - type: string - returns: - schema: - type: string large_image: data:image/png;base64,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 diff --git a/microsoft-excel/1.0.0/requirements.txt b/microsoft-excel/1.0.0/requirements.txt index 451582f8..1cdfbefa 100644 --- a/microsoft-excel/1.0.0/requirements.txt +++ b/microsoft-excel/1.0.0/requirements.txt @@ -1,2 +1,3 @@ -requests==2.25.1 openpyxl==3.0.9 +requests +shuffle-sdk diff --git a/microsoft-excel/1.0.0/src/app.py b/microsoft-excel/1.0.0/src/app.py index 7d0b1a13..7031d916 100644 --- a/microsoft-excel/1.0.0/src/app.py +++ b/microsoft-excel/1.0.0/src/app.py @@ -1,14 +1,10 @@ -import socket -import asyncio -import time -import random import json -import uuid -import time import requests -from openpyxl import Workbook, load_workbook -from walkoff_app_sdk.app_base import AppBase +from shuffle_sdk import AppBase +from shuffle_sdk import csv_parse + +from openpyxl import Workbook, load_workbook class MSExcel(AppBase): __version__ = "1.0.0" @@ -123,7 +119,7 @@ def convert_to_csv(self, tenant_id, client_id, client_secret, file_id, sheet="Sh if filedata["success"] != True: return filedata - basename = "file.xlsx" + basename = "/tmp/file.xlsx" with open(basename, "wb") as tmp: tmp.write(filedata["data"]) @@ -131,13 +127,12 @@ def convert_to_csv(self, tenant_id, client_id, client_secret, file_id, sheet="Sh sheet = "Sheet1" #wb = Workbook(basename) - wb = load_workbook(basename) - print("Sheets: %s" % wb.sheetnames) - + wb = load_workbook(basename, read_only=True) + # grab the active worksheet ws = wb.active - for item in ws.iter_rows(): - print(item) + #for item in ws.iter_rows(): + # print(item) csvdata = "" for row in ws.values: @@ -153,41 +148,81 @@ def convert_to_csv(self, tenant_id, client_id, client_secret, file_id, sheet="Sh csvdata = csvdata[:-1]+"\n" csvdata = csvdata[:-1] - print() - print("Data:\n%s\n" % csvdata) + print("Data length: (%s)" % len(csvdata)) return csvdata - def get_excel_file_data(self, file_id): + def get_excel_file_data(self, file_id, to_list=True, sheets="", max_rows=100000, skip_rows=0): filedata = self.get_file(file_id) if filedata["success"] != True: - print(f"Bad info from file: {filedata}") + print(f"[ERROR] Bad info from file: {filedata}") return filedata - #filedata = file_id + + if not sheets: + sheets = "" + + sheets = sheets.lower() + max_rows = int(max_rows) + skip_rows = int(skip_rows) + + try: + #print("Filename: %s" % filedata["filename"]) + if "csv" in filedata["filename"]: + try: + filedata["data"] = filedata["data"].decode("utf-8") + except: + try: + filedata["data"] = filedata["data"].decode("utf-16") + except: + filedata["data"] = filedata["data"].decode("latin-1") + + returndata = csv_parse(filedata["data"]) + return returndata + + except Exception as e: + print("Error parsing file with csv parser for file %s: %s" % (filedata["filename"], e)) - basename = "file.xlsx" + basename = "/tmp/file.xlsx" with open(basename, "wb") as tmp: tmp.write(filedata["data"]) #wb = Workbook(basename) try: - wb = load_workbook(basename) + wb = load_workbook(basename, read_only=True) except Exception as e: return { "success": False, - "reason": "The file is invalid. Are you sure it's a valid excel file?", + "reason": "The file is invalid. Are you sure it's a valid excel file? CSV files are not supported.", "exception": "Error: %s" % e, } - - print("Sheets: %s" % wb.sheetnames) + # Default + #max_count = 25000 + #if os.getenv("SHUFFLE_APP_SDK_TIMEOUT") > 240: + # Limits are ~no longer relevant if to_list=True + + cnt = 0 + skipped_cnt = 0 output_data = [] for ws in wb.worksheets: - print(f"Title: {ws.title}") + if ws.title.lower() not in sheets and sheets != "": + continue # grab the active worksheet csvdata = "" + if cnt-skipped_cnt > skip_rows: + break + + list_data = [] for row in ws.values: + cnt += 1 + if cnt < skip_rows: + skipped_cnt += 1 + continue + + if cnt-skipped_cnt > max_rows: + break + for value in row: #print(value) if value == None: @@ -197,15 +232,30 @@ def get_excel_file_data(self, file_id): else: csvdata += str(value)+"," - csvdata = csvdata[:-1]+"\n" - csvdata = csvdata[:-1] - - print() - print("Data:\n%s\n" % csvdata) - output_data.append({ + list_data.append(csvdata) + if to_list == False: + csvdata = csvdata[:-1]+"\n" + else: + csvdata = "" + + #csvdata = csvdata[:-1] + + output = { "sheet": ws.title, "data": csvdata, - }) + } + + if to_list == False: + print("Data len (%s): %d" % (ws.title, len(csvdata))) + output_data.append(output) + else: + print("Data len (%s): %d" % (ws.title, len(list_data))) + output_data.append({ + "sheet": ws.title, + "data": list_data, + }) + + print("Done! Returning data of length: %d" % len(output_data)) return output_data diff --git a/microsoft-identity-and-access/1.0.0/requirements.txt b/microsoft-identity-and-access/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/microsoft-identity-and-access/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/microsoft-identity-and-access/1.0.0/src/app.py b/microsoft-identity-and-access/1.0.0/src/app.py deleted file mode 100644 index c2633567..00000000 --- a/microsoft-identity-and-access/1.0.0/src/app.py +++ /dev/null @@ -1,316 +0,0 @@ -import socket -import asyncio -import time -import random -import json -import uuid -import time -import requests - -from walkoff_app_sdk.app_base import AppBase - -class MsIdentityAccess(AppBase): - __version__ = "1.0.0" - app_name = "Microsoft Identity and Access" - - def __init__(self, redis, logger, console_logger=None): - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - def authenticate(self, tenant_id, client_id, client_secret, graph_url): - s = requests.Session() - auth_url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token" - auth_data = { - "grant_type": "client_credentials", - "client_id": client_id, - "client_secret": client_secret, - "scope": f"{graph_url}/.default", - } - auth_headers = { - "Content-Type": "application/x-www-form-urlencoded", - "cache-control": "no-cache", - } - - print(f"Making request to: {auth_url}") - res = s.post(auth_url, data=auth_data, headers=auth_headers) - - # Auth failed, raise exception with the response - if res.status_code != 200: - raise ConnectionError(res.text) - - access_token = res.json().get("access_token") - s.headers = {"Authorization": f"Bearer {access_token}", "cache-control": "no-cache"} - return s - - - def list_administrative_units(self, tenant_id, client_id, client_secret): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = "https://graph.microsoft.com/v1.0/directory/administrativeUnits" - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} - - - def get_administrative_units(self, tenant_id, client_id, client_secret,id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits/{id}" - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def create_administrative_unit(self, tenant_id, client_id, client_secret, display_name, description, visibility): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits" - - request_body = { - "displayName": display_name, - "description": description, - "visibility": visibility - } - - ret = session.post(graph_url, json= request_body) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text, "error_response":ret.text} - - def list_administrative_unit_members(self, tenant_id, client_id, client_secret,administrative_unit_id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits/{administrative_unit_id}/members" - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} - - def get_administrative_unit_member(self, tenant_id, client_id, client_secret, administrative_unit_id, member_id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits/{administrative_unit_id}/members/{member_id}" - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - ## add member - def remove_administrative_unit_member(self, tenant_id, client_id, client_secret, administrative_unit_id, user_or_group_id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits/{administrative_unit_id}/members/{user_or_group_id}/$ref" - ret = session.delete(graph_url) - print(ret.status_code) - print(ret.text) - return ret.json() - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code,"error_response":ret.text} - - def list_risky_users(self, tenant_id, client_id, client_secret): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/identityProtection/riskyUsers" - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} - - def get_risky_user(self, tenant_id, client_id, client_secret, risky_user_id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/identityProtection/riskyUsers{risky_user_id}" - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def confirm_compromised_users(self, tenant_id, client_id, client_secret, risky_user_ids): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = "https://graph.microsoft.com/v1.0/identityProtection/riskyUsers/confirmCompromised" - - user_list = [str(user) for user in risky_user_ids.split(',')] - - request_body = { - "userIds": user_list - } - - ret = session.post(graph_url, json= request_body) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def dismiss_compromised_users(self, tenant_id, client_id, client_secret, risky_user_ids): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = "https://graph.microsoft.com/v1.0/identityProtection/riskyUsers/dismiss" - - user_list = [str(user) for user in risky_user_ids.split(',')] - - request_body = { - "userIds": user_list - } - - ret = session.post(graph_url, json= request_body) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def list_directory_role(self, tenant_id, client_id, client_secret): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = "https://graph.microsoft.com/v1.0/directoryRoles" - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def list_directory_role_members(self, tenant_id, client_id, client_secret, directory_role_id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/directoryRoles/{directory_role_id}/members" - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def add_directory_role_members(self, tenant_id, client_id, client_secret, directory_role_id, user_id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/directoryRoles/{directory_role_id}/members/$ref" - - request_body = { - "@odata.id": f"https://graph.microsoft.com/v1.0/directoryObjects/{user_id}" - } - - ret = session.post(graph_url, json=request_body) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def remove_directory_role_members(self, tenant_id, client_id, client_secret, directory_role_id, user_id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/v1.0/directoryRoles/{directory_role_id}/members/$ref" - - request_body = { - "@odata.id": f"https://graph.microsoft.com/v1.0/directoryObjects/{user_id}" - } - - ret = session.delete(graph_url, json=request_body) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def list_password_methods(self, tenant_id, client_id, client_secret, user_email_or_id): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}/authentication/passwordMethods" - - ret = session.get(graph_url) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - - def reset_user_password(self, tenant_id, client_id, client_secret, user_email_or_id , registered_password_id, new_password): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(tenant_id, client_id, client_secret, graph_url) - - graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}/authentication/passwordMethods/{registered_password_id}/resetPassword" - - headers = { - "Content-type": "application/json" - } - request_body = { - "newPassword": str(new_password) - } - - ret = session.post(graph_url, json=request_body,headers=headers) - print(ret.status_code) - print(ret.text) - if ret.status_code < 300: - data = ret.json() - return data - - return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} - -if __name__ == "__main__": - MsIdentityAccess.run() diff --git a/microsoft-intune/1.0.0/requirements.txt b/microsoft-intune/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/microsoft-intune/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/microsoft-security-and-compliance/1.0.0/requirements.txt b/microsoft-security-and-compliance/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/microsoft-security-and-compliance/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/microsoft-teams-system-access/1.0.0/requirements.txt b/microsoft-teams-system-access/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/microsoft-teams-system-access/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/microsoft-teams/1.0.0/requirements.txt b/microsoft-teams/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/microsoft-teams/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/microsoft-teams/1.0.0/src/__pycache__/teams.cpython-38.pyc b/microsoft-teams/1.0.0/src/__pycache__/teams.cpython-38.pyc deleted file mode 100644 index 1c3e43a2..00000000 Binary files a/microsoft-teams/1.0.0/src/__pycache__/teams.cpython-38.pyc and /dev/null differ diff --git a/microsoft-teams/1.0.0/src/__pycache__/teams.cpython-39.pyc b/microsoft-teams/1.0.0/src/__pycache__/teams.cpython-39.pyc deleted file mode 100644 index 90a9ca6d..00000000 Binary files a/microsoft-teams/1.0.0/src/__pycache__/teams.cpython-39.pyc and /dev/null differ diff --git a/mysql/1.0.0/README.md b/mysql/1.0.0/README.md index db6f1ea1..8698fed0 100644 --- a/mysql/1.0.0/README.md +++ b/mysql/1.0.0/README.md @@ -87,7 +87,64 @@ Query condition text after a WHERE clause. age=23 and gender='M' ``` +### Update data +update data inside the table +Fields: +- table; +- fields; +- condition. +- data fields. + +**Fields example:** +Table fields to be return. +``` +["first_name","last_name"] +``` + +**Condition example:** +Query condition text after a WHERE clause. +``` +emp_no=1 +``` + +**Data Fields example:** +Table fields value to be updated. +``` +["jaydeep","kotak"] +``` + +### Delete data +delete data inside the table +Fields: +- table; +- condition +- fields;(optional) + +**Condition example:** +Query condition text after a WHERE clause. +``` +emp_no = 1 +``` +**Data Fields example:** +Table fields value to be deleted. +``` +["jaydeep","kotak"] +``` + +### Join Query +join two or more table and display data +Fields: +- type; +- fields. + +**Fields example:** +Table fields to be return. +``` + +SELECT * from employees INNER JOIN departments ON employees.emp_no = departments.emp_no +``` + ## Upcoming - Improve the tables field to be needed just to insert the table name once in the json as key, and for the value the table fields syntax. -- Advanced Query - Allows the user to insert any type of query, as example with joins, etc...; \ No newline at end of file + diff --git a/mysql/1.0.0/api.yaml b/mysql/1.0.0/api.yaml index c16cfb83..95a4961c 100644 --- a/mysql/1.0.0/api.yaml +++ b/mysql/1.0.0/api.yaml @@ -1,6 +1,6 @@ app_version: 1.0.0 name: MySQL -description: Mysql integration +description: Mysql integration. Compatible with MSSQL and other SQL databases. contact_info: name: "@d4rkw0lv3s" url: https://github.com/D4rkw0lv3s @@ -52,11 +52,11 @@ actions: description: create new tables required: false multiline: true - example: | + example: '| { "employees": "CREATE TABLE `employees` ( `emp_no` int(11) NOT NULL AUTO_INCREMENT, `first_name` varchar(14) NOT NULL, `last_name` varchar(16) NOT NULL, PRIMARY KEY (`emp_no`)) ENGINE=InnoDB", "departments": "CREATE TABLE `departments` ( `dept_no` char(4) NOT NULL, `dept_name` varchar(40) NOT NULL, PRIMARY KEY (`dept_no`), UNIQUE KEY `dept_name` (`dept_name`)) ENGINE=InnoDB" - } + }' schema: type: string returns: @@ -69,11 +69,11 @@ actions: description: create new tables required: true multiline: true - example: | + example: '| { "employees": "CREATE TABLE `employees` ( `emp_no` int(11) NOT NULL AUTO_INCREMENT, `first_name` varchar(14) NOT NULL, `last_name` varchar(16) NOT NULL, PRIMARY KEY (`emp_no`)) ENGINE=InnoDB", "departments": "CREATE TABLE `departments` ( `dept_no` char(4) NOT NULL, `dept_name` varchar(40) NOT NULL, PRIMARY KEY (`dept_no`), UNIQUE KEY `dept_name` (`dept_name`)) ENGINE=InnoDB" - } + }' schema: type: string returns: @@ -93,7 +93,7 @@ actions: description: mysql data in JSON format, it can be a list or not required: true multiline: true - example: | + example: '| [{ "title": "New Function1", "text": "testing", @@ -103,7 +103,7 @@ actions: "title": "New Function2", "text": "testing", "time": 1617032159000 - }] + }]' schema: type: string returns: @@ -136,4 +136,90 @@ actions: returns: schema: type: string + - name: update_data + description: update data inside the table + parameters: + - name: table + description: table name + required: true + multiline: false + example: "my_table" + schema: + type: string + - name: fields + description: table fields to be return + required: false + multiline: false + example: '["username", "fname"]' + schema: + type: string + - name: condition + description: query condition, the string after a WHERE + required: false + multiline: false + example: "id=123 and gender='M'" + schema: + type: string + - name: data_value + description: query data, value + required: false + multiline: false + example: '["firstname","lastname"]' + schema: + type: string + returns: + schema: + type: string + - name: delete_data + description: delete data inside the table + parameters: + - name: table + description: table name + required: true + multiline: false + example: "my_table" + schema: + type: string + - name: condition + description: query condition, the string after a WHERE + required: false + multiline: false + example: "id=123 and gender='M'" + schema: + type: string + - name: fields + description: table fields to be return + required: false + multiline: false + example: "username, fname, lname" + schema: + type: string + returns: + schema: + type: string + - name: join + description: join multiple table + parameters: + - name: type + description: join type + required: true + multiline: false + example: "select here" + options: + - INNER JOIN + - LEFT JOIN + - RIGHT JOIN + - CROSS JOIN + schema: + type: string + - name: fields + description: table fields to be return + required: false + multiline: false + example: 'input query' + schema: + type: string + returns: + schema: + type: string large_image: data:image/jpeg;base64,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 diff --git a/mysql/1.0.0/requirements.txt b/mysql/1.0.0/requirements.txt index 28cc0ef7..9ae049c1 100644 --- a/mysql/1.0.0/requirements.txt +++ b/mysql/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 -mysql-connector-python==8.0.23 +requests==2.32.4 +mysql-connector-python==9.1.0 diff --git a/mysql/1.0.0/src/app.py b/mysql/1.0.0/src/app.py index a8a5e816..f5996137 100644 --- a/mysql/1.0.0/src/app.py +++ b/mysql/1.0.0/src/app.py @@ -1,5 +1,8 @@ +from ast import Return import asyncio import json +from urllib import response +import itertools import mysql.connector from mysql.connector import errorcode @@ -130,10 +133,8 @@ def create_tables(self, server, user, password, database, tables): if t_count > 1 else "Table created with success!" ) - cursor.close() conn.close() - return result # Insert data into table @@ -272,7 +273,155 @@ def query_data( cursor.close() conn.close() return json.dumps(json_data, indent=4) + + #update data + def update_data(self, server, user, password, database, table, fields=None, condition=None, data_value=None + ): + q = f"SELECT * from {table}" + if condition: + q += f" WHERE {condition}" + query = f"UPDATE {table} SET " + for (key,value) in zip(fields,data_value): + query += f"{key} = '{value}'," + + query = query[:-1] + if condition: + query += f" WHERE {condition}" + + try: + conn = mysql.connector.connect( + host=server, user=user, passwd=password, db=database + ) + cursor = conn.cursor() + cursor.execute(q) + rs = cursor.fetchone() + if rs == None: + cursor.close() + return f"data not found" + else: + cursor1 = conn.cursor() + cursor1.execute(query) + conn.commit() + cursor1.close() + conn.close() + response = { + "message": f"Data updated with success {table}!", + "data": query,} + return json.dumps(response, indent=4) + + except mysql.connector.Error as err: + if err.errno == errorcode.ER_ACCESS_DENIED_ERROR: + print("Something is wrong with your user name or password") + return "Something is wrong with your user name or password" + elif err.errno == errorcode.ER_BAD_DB_ERROR: + print("Database does not exist") + return "Database does not exist" + else: + print(err) + return err + + # delete data + def delete_data(self, server, user, password, database, table, fields=None, condition=None + ): + + q = f"SELECT * from {table}" + if condition: + q += f" WHERE {condition}" + query = f"DELETE FROM {table}" + if condition: + query += f" WHERE {condition}" + try: + conn = mysql.connector.connect( + host=server, user=user, passwd=password, db=database + ) + cursor = conn.cursor() + cursor.execute(q) + rs = cursor.fetchone() + if rs == None: + cursor.close() + return f"data not found" + else: + cursor1 = conn.cursor() + cursor1.execute(query) + conn.commit() + cursor1.close() + conn.close() + response = { + "message": f"Data deleted with success {table}!", + "data": query,} + return json.dumps(response, indent=4) + except mysql.connector.Error as err: + if err.errno == errorcode.ER_ACCESS_DENIED_ERROR: + print("Something is wrong with your user name or password") + return "Something is wrong with your user name or password" + elif err.errno == errorcode.ER_BAD_DB_ERROR: + print("Database does not exist") + return "Database does not exist" + else: + print(err) + return err + + # join + def join(self, type, server, user, password, database, fields=None + ): + try: + conn = mysql.connector.connect( + host=server, user=user, passwd=password, db=database + ) + cursor = conn.cursor() + except mysql.connector.Error as err: + if err.errno == errorcode.ER_ACCESS_DENIED_ERROR: + print("Something is wrong with your user name or password") + return "Something is wrong with your user name or password" + elif err.errno == errorcode.ER_BAD_DB_ERROR: + print("Database does not exist") + return "Database does not exist" + else: + print(err) + return err + if type == "INNER JOIN": + cursor.execute(fields) + row_headers = [x[0] for x in cursor.description] + json_data = [] + for result in cursor.fetchall(): + json_data.append(dict(zip(row_headers, result))) + result = cursor + cursor.close() + conn.close() + return json.dumps(json_data, indent=4) + elif type == "LEFT JOIN": + cursor.execute(fields) + row_headers = [x[0] for x in cursor.description] + json_data = [] + for result in cursor.fetchall(): + json_data.append(dict(zip(row_headers, result))) + result = cursor + cursor.close() + conn.close() + return json.dumps(json_data, indent=4) + elif type == "RIGHT JOIN": + cursor.execute(fields) + row_headers = [x[0] for x in cursor.description] + json_data = [] + for result in cursor.fetchall(): + json_data.append(dict(zip(row_headers, result))) + result = cursor + cursor.close() + conn.close() + return json.dumps(json_data, indent=4) + elif type == "CROSS JOIN": + cursor.execute(fields) + row_headers = [x[0] for x in cursor.description] + json_data = [] + for result in cursor.fetchall(): + json_data.append(dict(zip(row_headers, result))) + result = cursor + cursor.close() + conn.close() + return json.dumps(json_data, indent=4) + else: + return f"Select join" if __name__ == "__main__": MySQL.run() diff --git a/netcraft/1.0.0/requirements.txt b/netcraft/1.0.0/requirements.txt index fd7d3e06..480d0c4b 100644 --- a/netcraft/1.0.0/requirements.txt +++ b/netcraft/1.0.0/requirements.txt @@ -1 +1 @@ -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/oauth2-example/1.0.0/api.yaml b/oauth2-example/1.0.0/api.yaml deleted file mode 100644 index 40c44127..00000000 --- a/oauth2-example/1.0.0/api.yaml +++ /dev/null @@ -1,53 +0,0 @@ -walkoff_version: 1.0.0 -app_version: 1.0.0 -name: oauth2-example -description: Oauth2 sample -tags: - - Example -categories: - - Example -contact_info: - name: "@frikkylikeme" - url: https://github.com/frikky -authentication: - required: true - type: oauth2 - redirect_uri: "https://login.microsoftonline.com/common/oauth2/authorize" - token_uri: "https://login.microsoftonline.com/common/oauth2/v2.0/token" - client_id: "dae24316-4bec-4832-b660-4cba6dc2477b" - client_secret: "._Qu3EvYY-OW_D57uy79qwEo.32qD6.l0z" - scope: - - UserAuthenticationMethod.ReadWrite.All -actions: - - name: reset_password - description: Change password of a user in Azure - parameters: - - name: userId - description: - example: "user@company.com" - required: true - schema: - type: string - - name: passwordId - description: - example: "28c10230-6103-485e-b985-444c60001490" - required: true - schema: - type: string - - name: newPassword - description: - example: "*****" - required: false - schema: - type: string - returns: - example: '{"data": "this is a test", "this_is_a_number": 1, "this_is_a_list": [{"item": [{"hello": "there", "how_is_this": {"sub_in_sub": [{"another": "list"}]}}]}, {"item": "2"}], "subobject": {"data": "subobject"}}' - schema: - type: string - - name: get_password_methods - description: Get available password methods for your user - returns: - example: '{"data": "this is a test", "this_is_a_number": 1, "this_is_a_list": [{"item": [{"hello": "there", "how_is_this": {"sub_in_sub": [{"another": "list"}]}}]}, {"item": "2"}], "subobject": {"data": "subobject"}}' - schema: - type: string -large_image: data:image/png;base64,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 diff --git a/oauth2-example/1.0.0/src/app.py b/oauth2-example/1.0.0/src/app.py deleted file mode 100644 index e36997e4..00000000 --- a/oauth2-example/1.0.0/src/app.py +++ /dev/null @@ -1,61 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- - -import asyncio -import time -import random -import json -import requests -import thehive4py - -from thehive4py.api import TheHiveApi -from thehive4py.query import * -import thehive4py.models - -from walkoff_app_sdk.app_base import AppBase - - -class Oauth2Example(AppBase): - __version__ = "1.0.0" - app_name = "oauth2-example" - - def __init__(self, redis, logger, console_logger=None): - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - def authenticate(self, access_token, refresh_token): - s = requests.Session() - s.headers = { - "Content-Type": "application/json", - "Authorization": "Bearer %s" % access_token - } - - return s - - # UserAuthenticationMethod.ReadWrite.All - def reset_password(self, access_token, refresh_token, userId, passwordId, newPassword=""): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(access_token, refresh_token) - - url = "https://graph.microsoft.com/beta/users/%s/authentication/passwordMethods/%s/resetPassword" % (userId, passwordId) - response = session.post(url) - print(response.status_code) - return response.text - - # UserAuthenticationMethod.ReadWrite.All - def get_password_methods(self, access_token, refresh_token): - graph_url = "https://graph.microsoft.com" - session = self.authenticate(access_token, refresh_token) - - url = "https://graph.microsoft.com/beta/me/authentication/passwordMethods" - response = session.get(url) - print(response.status_code) - return response.text - -if __name__ == "__main__": - Oauth2Example.run() diff --git a/outlook_owa/1.0.0/Dockerfile b/outlook-exchange/1.0.0/Dockerfile similarity index 100% rename from outlook_owa/1.0.0/Dockerfile rename to outlook-exchange/1.0.0/Dockerfile diff --git a/outlook_owa/1.0.0/api.yaml b/outlook-exchange/1.0.0/api.yaml similarity index 98% rename from outlook_owa/1.0.0/api.yaml rename to outlook-exchange/1.0.0/api.yaml index 91367f80..751c0b53 100644 --- a/outlook_owa/1.0.0/api.yaml +++ b/outlook-exchange/1.0.0/api.yaml @@ -1,6 +1,6 @@ walkoff_version: 1.0.0 app_version: 1.0.0 -name: outlook_owa +name: outlook-exchange description: "Email app for Exchange (OWA). Important about usage: try WITHOUT the full email in the username for authentication." tags: - email @@ -148,6 +148,13 @@ actions: required: true schema: type: string + - name: ccrecipient + description: The CC receiver(s) of the email + multiline: false + example: "frikky@shuffler.io,frikky@shuffler.io" + required: false + schema: + type: string - name: subject description: The subject of the email multiline: false diff --git a/outlook_owa/1.0.0/requirements.txt b/outlook-exchange/1.0.0/requirements.txt similarity index 57% rename from outlook_owa/1.0.0/requirements.txt rename to outlook-exchange/1.0.0/requirements.txt index 46de1688..c7a756d5 100644 --- a/outlook_owa/1.0.0/requirements.txt +++ b/outlook-exchange/1.0.0/requirements.txt @@ -1,5 +1,5 @@ -cryptography==3.3.2 +cryptography==44.0.1 exchangelib==3.3.2 eml_parser==1.14.4 glom==20.11.0 -requests==2.25.1 +requests==2.32.4 diff --git a/outlook_owa/1.0.0/src/app.py b/outlook-exchange/1.0.0/src/app.py similarity index 91% rename from outlook_owa/1.0.0/src/app.py rename to outlook-exchange/1.0.0/src/app.py index b5d6a11f..38d8b2cd 100644 --- a/outlook_owa/1.0.0/src/app.py +++ b/outlook-exchange/1.0.0/src/app.py @@ -19,6 +19,7 @@ Message, FileAttachment, ItemAttachment, + HTMLBody, ) from exchangelib.protocol import BaseProtocol, NoVerifyHTTPAdapter from walkoff_app_sdk.app_base import AppBase @@ -164,10 +165,17 @@ def send_email( account, verifyssl, recipient, + ccrecipient, subject, body, attachments, ): + if "office365" in server.lower(): + return { + "success": False, + "reason": "Use the Outlook Office365 app to connect to Office365. Basic auth is deprecated.", + } + # Authenticate auth = self.authenticate( username, password, server, build, account, verifyssl @@ -181,16 +189,23 @@ def send_email( account = auth["account"] + try: + body = HTMLBody(str(body)) + except Exception as e: + pass + m = Message( account=account, subject=subject, body=body, - to_recipients=[ - Mailbox(email_address=address) for address in recipient.split(", ") - ], + to_recipients=[] ) - file_uids = attachments.split() + for address in recipient.split(", "): + address = address.strip() + m.to_recipients.append(Mailbox(email_address=address)) + + file_uids = str(attachments).split() if len(file_uids) > 0: for file_uid in file_uids: attachment_data = self.get_file(file_uid) @@ -212,6 +227,13 @@ def send_email( def mark_email_as_read( self, username, password, server, build, account, verifyssl, email_id, foldername="inbox" ): + + if "office365" in server.lower(): + return { + "success": False, + "reason": "Use the Outlook Office365 app to connect to Office365. Basic auth is deprecated.", + } + if not foldername: foldername = "inbox" @@ -248,6 +270,12 @@ def add_category( self, username, password, server, build, account, verifyssl, email_id, category, foldername="inbox" ): + if "office365" in server.lower(): + return { + "success": False, + "reason": "Use the Outlook Office365 app to connect to Office365. Basic auth is deprecated.", + } + if not foldername: foldername = "inbox" @@ -285,6 +313,12 @@ def add_category( def delete_email( self, username, password, server, build, account, verifyssl, email_id ): + if "office365" in server.lower(): + return { + "success": False, + "reason": "Use the Outlook Office365 app to connect to Office365. Basic auth is deprecated.", + } + # Authenticate auth = self.authenticate( username, password, server, build, account, verifyssl @@ -313,6 +347,12 @@ def move_email( email_id, foldername, ): + if "office365" in server.lower(): + return { + "success": False, + "reason": "Use the Outlook Office365 app to connect to Office365. Basic auth is deprecated.", + } + # Authenticate auth = self.authenticate( username, password, server, build, account, verifyssl @@ -360,6 +400,12 @@ def get_emails( upload_email_shuffle, upload_attachments_shuffle, ): + if "office365" in server.lower(): + return { + "success": False, + "reason": "Use the Outlook Office365 app to connect to Office365. Basic auth is deprecated.", + } + def path_to_dict(path, value=None): def pack(parts): return ( diff --git a/passivetotal/1.0.0/requirements.txt b/passivetotal/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/passivetotal/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/email/1.2.0/Dockerfile b/postgress/1.0.0/Dockerfile similarity index 100% rename from email/1.2.0/Dockerfile rename to postgress/1.0.0/Dockerfile index bcc1273d..41f976bb 100644 --- a/email/1.2.0/Dockerfile +++ b/postgress/1.0.0/Dockerfile @@ -21,7 +21,7 @@ COPY src /app # Install any binary dependencies needed in our final image # RUN apk --no-cache add --update my_binary_dependency + # Finally, lets run our app! WORKDIR /app CMD python app.py --log-level DEBUG - diff --git a/postgress/1.0.0/README.md b/postgress/1.0.0/README.md new file mode 100644 index 00000000..96f475a4 --- /dev/null +++ b/postgress/1.0.0/README.md @@ -0,0 +1,3 @@ +# PostgreSQL Shuffle App +This app connects to PostgreSQL and executes queries. + diff --git a/postgress/1.0.0/api.yaml b/postgress/1.0.0/api.yaml new file mode 100644 index 00000000..26467487 --- /dev/null +++ b/postgress/1.0.0/api.yaml @@ -0,0 +1,55 @@ +app_version: 1.0.0 +name: postgress +description: postgress integration. Compatible with SQL databases. +contact_info: + name: "@d4rkw0lv3s" + url: https://github.com/D4rkw0lv3s + email: d4rkw0lv3s@outlook.pt +tags: + - postgress +categories: + - Intel + - Network +actions: + - name: run_query + description: Create a new database + parameters: + - name: host + description: mysql server ip or fqdn + example: "myserver.com or 127.0.0.1" + required: true + schema: + type: string + - name: port + description: mysql database + example: "my_database" + required: false + schema: + type: string + - name: dbname + description: mysql database + example: "my_database" + required: false + schema: + type: string + - name: user + description: mysql database + example: "my_database" + required: false + schema: + type: string + - name: password + description: mysql database + example: "my_database" + required: false + schema: + type: string + - name: query + description: mysql database + example: "my_database" + required: false + schema: + type: string + return: + schema: + type: string diff --git a/postgress/1.0.0/requirements.txt b/postgress/1.0.0/requirements.txt new file mode 100644 index 00000000..78f864b2 --- /dev/null +++ b/postgress/1.0.0/requirements.txt @@ -0,0 +1,2 @@ +psycopg2-binary +shuffle-sdk diff --git a/postgress/1.0.0/src/app.py b/postgress/1.0.0/src/app.py new file mode 100644 index 00000000..3c973e49 --- /dev/null +++ b/postgress/1.0.0/src/app.py @@ -0,0 +1,35 @@ +import psycopg2 +from psycopg2.extras import RealDictCursor +#from walkoff_app_sdk.app_base import AppBase +from shuffle_sdk import AppBase + + +class PostgreSQL(AppBase): + __version__ = "1.0.0" + app_name = "PostgreSQL" + + def __init__(self, redis, logger, console_logger=None): + super().__init__(redis, logger, console_logger) + + def connect(self, host, port, dbname, user, password): + conn = psycopg2.connect( + host=host, + port=port, + dbname=dbname, + user=user, + password=password, + cursor_factory=RealDictCursor + ) + return conn + + def run_query(self, host, port, dbname, user, password, query): + with self.connect(host, port, dbname, user, password) as conn: + with conn.cursor() as cur: + cur.execute(query) + try: + return {"result": cur.fetchall()} + except psycopg2.ProgrammingError: + return {"message": "Query executed successfully, no data returned."} + +if __name__ == "__main__": + PostgreSQL.run() diff --git a/python3-playground/1.0.0/requirements.txt b/python3-playground/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/python3-playground/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/python3-playground/1.0.0/src/app.py b/python3-playground/1.0.0/src/app.py deleted file mode 100644 index 356a6cfe..00000000 --- a/python3-playground/1.0.0/src/app.py +++ /dev/null @@ -1,51 +0,0 @@ -import socket -import asyncio -import time -import random -import json - -from walkoff_app_sdk.app_base import AppBase - -class PythonPlayground(AppBase): - __version__ = "1.0.0" - app_name = "python_playground" # this needs to match "name" in api.yaml - - def __init__(self, redis, logger, console_logger=None): - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - def run_me_1(self, json_data): - return "Ran function 1" - - def run_me_2(self, json_data): - return "Ran function 2" - - def run_me_3(self, json_data): - return "Ran function 3" - - # Write your data inside this function - def run_python_script(self, json_data, function_to_execute): - # It comes in as a string, so needs to be set to JSON - if not isinstance(json_data, list) and not isinstance(json_data, object) and not isinstance(json_data, dict): - try: - json_data = json.loads(json_data) - except json.decoder.JSONDecodeError as e: - return "Couldn't decode json: %s" % e - - # These are functions - switcher = { - "function_1" : self.run_me_1, - "function_2" : self.run_me_2, - "function_3" : self.run_me_3, - } - - func = switcher.get(function_to_execute, lambda: "Invalid function") - return func(json_data) - -if __name__ == "__main__": - PythonPlayground.run() diff --git a/recordedfuture/1.0.0/requirements.txt b/recordedfuture/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/recordedfuture/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/http/1.1.0/Dockerfile b/redis/1.0.0/Dockerfile similarity index 100% rename from http/1.1.0/Dockerfile rename to redis/1.0.0/Dockerfile diff --git a/redis/1.0.0/api.yaml b/redis/1.0.0/api.yaml new file mode 100644 index 00000000..0ee97122 --- /dev/null +++ b/redis/1.0.0/api.yaml @@ -0,0 +1,110 @@ +app_version: 1.0.0 +name: Redis +description: Redis integration. +tags: + - redis +categories: + - Other +# contact_info: +# name: "@frikkylikeme" +# url: https://shuffler.io +# email: frikky@shuffler.io +authentication: + required: true + parameters: + - name: server + description: Redis server ip + example: "127.0.0.1" + required: true + schema: + type: string + - name: port + description: Redis port + example: "6379" + required: true + schema: + type: string + - name: password + description: redis password + example: "*****" + required: false + schema: + type: string + - name: database + description: redis database + example: "0" + required: false + options: + - 0 + - 1 + - 2 + - 3 + - 4 + - 5 + - 6 + - 7 + - 8 + - 9 + - 10 + - 11 + - 12 + - 13 + - 14 + - 15 + schema: + type: string + +actions: + - name: set_value + description: Set a key value pair + parameters: + - name: key + description: Key name + required: true + multiline: false + example: "my key" + schema: + type: string + - name: value + description: Value + required: true + multiline: true + example: 'my value' + schema: + type: string + - name: nx + description: Set value only if not exists + required: true + options: + - "false" + - "true" + multiline: false + example: "true" + schema: + type: bool + - name: ex + description: Expiration time in seconds + required: false + multiline: false + example: '60' + schema: + type: string + returns: + schema: + type: string + + - name: get_value + description: Get value of a key + parameters: + - name: key + description: Key name + required: true + multiline: false + example: "my key" + schema: + type: string + returns: + schema: + type: string +large_image: data:image/svg+xml;base64,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 +# yamllint disable-line rule:line-length diff --git a/redis/1.0.0/app.zip b/redis/1.0.0/app.zip new file mode 100644 index 00000000..670f8456 Binary files /dev/null and b/redis/1.0.0/app.zip differ diff --git a/redis/1.0.0/requirements.txt b/redis/1.0.0/requirements.txt new file mode 100644 index 00000000..c6889d58 --- /dev/null +++ b/redis/1.0.0/requirements.txt @@ -0,0 +1 @@ +redis==5.2.1 \ No newline at end of file diff --git a/redis/1.0.0/src/app.py b/redis/1.0.0/src/app.py new file mode 100644 index 00000000..9a60449a --- /dev/null +++ b/redis/1.0.0/src/app.py @@ -0,0 +1,58 @@ +import json +import ast +import redis + +from walkoff_app_sdk.app_base import AppBase + +class REDIS(AppBase): + __version__ = "1.0.0" + app_name = "Redis" + + def __init__(self, redis, logger, console_logger=None): + print("INIT") + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def set_value(self, server, port, key, value, nx, ex = None, password = None, database = 0): + """ + Sets a key-value pair in Redis. + """ + + if password == None: + redis_client = redis.Redis(decode_responses=True, host=server, port=port, db=database) + else: + redis_client = redis.Redis(decode_responses=True, password=password, port=port, host=server, db=database) + + + result = redis_client.set(name=key, value=value, nx=nx, ex=ex) # nx=True ensures "set only if the key does not exist" + print(result) + if result: # If result is True, the key was successfully set + print(f"Success: Key {key} set with value '{value}'") + return {"success": True} + else: + print(f"Failed: Key {key} already exists.") + return {"success": False} + + def get_value(self, server, port, key, password = None, database = 0): + """ + Gets a value for a key in Redis. + """ + if password == None: + redis_client = redis.Redis(decode_responses=True, host=server, port=port, db=database) + else: + redis_client = redis.Redis(decode_responses=True, password=password, port=port, host=server, db=database) + + result = redis_client.get(name=key) + if result: + return {"success": True, "value": result} + else: + return {"success": False, "error": f"Key {key} does not exist", "value": None} + + +if __name__ == "__main__": + REDIS.run() diff --git a/rss/1.0.0/requirements.txt b/rss/1.0.0/requirements.txt index 6a0049ac..1c09069e 100644 --- a/rss/1.0.0/requirements.txt +++ b/rss/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 -feedparser +feedparser==6.0.8 +requests==2.32.4 diff --git a/rss/1.0.0/src/app.py b/rss/1.0.0/src/app.py index bcbd4722..7fcc3ac2 100644 --- a/rss/1.0.0/src/app.py +++ b/rss/1.0.0/src/app.py @@ -5,9 +5,10 @@ import json import feedparser +socket.setdefaulttimeout(10) from walkoff_app_sdk.app_base import AppBase -class PythonPlayground(AppBase): +class RSS(AppBase): __version__ = "1.0.0" app_name = "python_playground" # this needs to match "name" in api.yaml @@ -48,4 +49,4 @@ def get_rss(self, url): # return entry.keys() if __name__ == "__main__": - PythonPlayground.run() + RSS.run() diff --git a/secureworks/1.0.0/requirements.txt b/secureworks/1.0.0/requirements.txt index fd7d3e06..480d0c4b 100644 --- a/secureworks/1.0.0/requirements.txt +++ b/secureworks/1.0.0/requirements.txt @@ -1 +1 @@ -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/servicenow/1.0.0/requirements.txt b/servicenow/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/servicenow/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/shuffle-ai/1.1.0/Dockerfile b/shuffle-ai/1.1.0/Dockerfile new file mode 100644 index 00000000..9b059f27 --- /dev/null +++ b/shuffle-ai/1.1.0/Dockerfile @@ -0,0 +1,54 @@ +FROM python:3.10-alpine + +# Install all alpine build tools needed for our pip installs +#RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev git poppler-utils + +# Install all of our pip packages in a single directory that we can copy to our base image later +RUN mkdir /install +WORKDIR /install + +# Switch back to our base image and copy in all of our built packages and source code +#COPY --from=builder /install /usr/local +COPY src /app +COPY requirements.txt /requirements.txt +RUN python3 -m pip install -r /requirements.txt + +# Install any binary dependencies needed in our final image +# RUN apk --no-cache add --update my_binary_dependency +RUN apk --no-cache add jq git curl + +ENV SHELL=/bin/bash + +### Install Tesseract +ENV CC /usr/bin/clang +ENV CXX /usr/bin/clang++ +ENV LANG=C.UTF-8 +ENV TESSDATA_PREFIX=/usr/local/share/tessdata + +# Dev tools +WORKDIR /tmp +RUN apk update +RUN apk upgrade +RUN apk add file openssl openssl-dev bash tini leptonica-dev openjpeg-dev tiff-dev libpng-dev zlib-dev libgcc mupdf-dev jbig2dec-dev +RUN apk add freetype-dev openblas-dev ffmpeg-dev linux-headers aspell-dev aspell-en # enchant-dev jasper-dev +RUN apk add --virtual .dev-deps git clang clang-dev g++ make automake autoconf libtool pkgconfig cmake ninja +RUN apk add --virtual .dev-testing-deps -X http://dl-3.alpinelinux.org/alpine/edge/testing autoconf-archive +RUN ln -s /usr/include/locale.h /usr/include/xlocale.h + +RUN apk add tesseract-ocr +RUN apk add poppler-utils + +# Install from main +RUN mkdir /usr/local/share/tessdata +RUN mkdir src +RUN cd src +RUN wget https://github.com/tesseract-ocr/tessdata_fast/raw/main/eng.traineddata -P /usr/local/share/tessdata +RUN git clone --depth 1 https://github.com/tesseract-ocr/tesseract.git + +#RUN curl -fsSL https://ollama.com/install.sh | sh +#RUN ollama pull llama3.2 +#RUN cd tesseract && ./autogen.sh && ./configure --build=x86_64-alpine-linux-musl --host=x86_64-alpine-linux-musl && make && make install && cd /tmp/src + +# Finally, lets run our app! +WORKDIR /app +CMD ["python", "app.py", "--log-level", "DEBUG"] diff --git a/shuffle-ai/1.1.0/Dockerfile_GPU b/shuffle-ai/1.1.0/Dockerfile_GPU new file mode 100644 index 00000000..ed2798c2 --- /dev/null +++ b/shuffle-ai/1.1.0/Dockerfile_GPU @@ -0,0 +1,108 @@ +FROM python:3.10.18-slim + +# Switch back to our base image and copy in all of our built packages and source code +COPY requirements.txt /requirements.txt +# Check if requirements.txt contains llama-cpp-python or not +RUN grep -q "^llama-cpp-python" /requirements.txt \ + || (echo "❌ requirements.txt missing llama-cpp-python" && exit 1) + +### Install Tesseract +ENV SHELL=/bin/bash +ENV CC /usr/bin/clang +ENV CXX /usr/bin/clang++ +ENV LANG=C.UTF-8 +ENV TESSDATA_PREFIX=/usr/local/share/tessdata + +# Install all build tools needed for our pip installs +RUN apt update +RUN apt install -y clang g++ make automake autoconf libtool cmake + +## Install the same packages with apt as with apk, but ensure they exist in apt +RUN apt install -y jq git curl +RUN apt install -y file openssl bash tini libpng-dev aspell-en +RUN apt install -y git clang g++ make automake autoconf libtool cmake +RUN apt install -y autoconf-archive wget + +# Install cuda toolkit +#RUN wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-archive-keyring.gpg +#RUN dpkg -i cuda-archive-keyring.gpg +#RUN rm cuda-archive-keyring.gpg +#RUN apt update +#RUN apt install -y cuda +#RUN echo 'export PATH=/usr/local/cuda/bin:$PATH' >> ~/.bashrc +#RUN echo 'export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc +#RUN source ~/.bashrc + +# Larger model +RUN mkdir -p /models + +# Fails. 6 bit, 8B model. +#RUN wget https://huggingface.co/RichardErkhov/meta-llama_-_Meta-Llama-3-8B-gguf/blob/main/Meta-Llama-3-8B.Q6_K.gguf?download=true -O /models/Meta-Llama-3-8B.Q6_K.gguf +#ENV MODEL_PATH="/models/Meta-Llama-3-8B.Q6_K.gguf" + +# Simple small Llama wrapper +RUN wget https://huggingface.co/unsloth/DeepSeek-R1-Distill-Llama-8B-GGUF/resolve/main/DeepSeek-R1-Distill-Llama-8B-Q2_K.gguf?download=true -O /models/DeepSeek-R1-Distill-Llama.gguf +# Larger one +#RUN wget https://huggingface.co/unsloth/DeepSeek-R1-Distill-Llama-8B-GGUF/resolve/main/DeepSeek-R1-Distill-Llama-8B-Q8_0.gguf?download=true -O /models/DeepSeek-R1-Distill-Llama.gguf +ENV MODEL_PATH="/models/DeepSeek-R1-Distill-Llama.gguf" + +# Failing? Bad magic bytes. +#RUN wget https://huggingface.co/QuantFactory/Llama-3.2-3B-GGUF/resolve/main/Llama-3.2-3B.Q2_K.gguf?download=true -O /models/Llama-3.2-3B.Q2_K.gguf + + +# Install all of our pip packages in a single directory that we can copy to our base image later +RUN mkdir /install +WORKDIR /install + +RUN python3 -m pip install -r /requirements.txt +RUN CMAKE_ARGS="-DLLAMA_CUBLAS=on" python3 -m pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir + + +# Install any binary dependencies needed in our final image + + +# Dev tools +WORKDIR /tmp +#RUN apk update +#RUN apk upgrade + + +RUN ln -s /usr/include/locale.h /usr/include/xlocale.h + +#RUN apk add tesseract-ocr +RUN apt install -y tesseract-ocr +#RUN apk add poppler-utils +RUN apt install -y poppler-utils +RUN apt clean && rm -rf /var/lib/apt/lists/* + +# Install from main +RUN mkdir /usr/local/share/tessdata +RUN wget https://github.com/tesseract-ocr/tessdata_fast/raw/main/eng.traineddata -P /usr/local/share/tessdata + +RUN mkdir src +RUN cd src + +RUN git clone --depth 1 https://github.com/tesseract-ocr/tesseract.git + +#RUN curl -fsSL https://ollama.com/install.sh | sh +# Install to /usr/local +#RUN wget https://ollama.com/install.sh -O /usr/local/bin/ollama-install +#RUN chmod +x /usr/local/bin/ollama-install +#RUN sh /usr/local/bin/ollama-install +# +#RUN ls -alh /usr/bin +#RUN ollama serve & sleep 2 && ollama pull nezahatkorkmaz/deepseek-v3 +#CMD ["sh", "-c", "ollama serve & sleep 2 && python app.py --log-level DEBUG"] + +#RUN wget https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf +RUN python3 -m pip install ctransformers --no-binary ctransformers + +# Finally, lets run our app! +ENV GIN_MODE=release +ENV SHUFFLE_APP_SDK_TIMEOUT=300 +#ENV LD_LIBRARY_PATH=/usr/local/lib/python3.10/site-packages/ctransformers/lib/basic/libctransformers.so +#RUN chmod 755 /usr/local/lib/python3.10/site-packages/ctransformers/lib/basic/libctransformers.so + +COPY src /app +WORKDIR /app +CMD ["python", "app.py", "--log-level", "DEBUG"] diff --git a/shuffle-ai/1.1.0/api.yaml b/shuffle-ai/1.1.0/api.yaml new file mode 100644 index 00000000..ab3f6243 --- /dev/null +++ b/shuffle-ai/1.1.0/api.yaml @@ -0,0 +1,167 @@ +--- +app_version: 1.1.0 +name: Shuffle AI +description: An EXPERIMENTAL AI tool app for Shuffle +tags: + - AI + - Shuffle + - LLM +categories: + - AI + - LLM + - Shuffle +contact_info: + name: "@frikkylikeme" + url: https://shuffler.io + email: support@shuffler.io +actions: + #- name: run_llm + # description: "Runs a local LLM, with a GPU or CPU (slow). Default model is set up in Dockerfile" + # parameters: + # - name: input + # description: "The input question to the model" + # required: true + # multiline: true + # example: "" + # schema: + # type: string + # - name: system_message + # description: "The system message use, if any" + # required: false + # multiline: false + # example: "" + # schema: + # type: string + + - name: shuffle_cloud_inference + description: Input ANY kind of data in the format you want, and the format you want it in. Default is a business-y email. Uses ShuffleGPT, which is based on OpenAI and our own model. + parameters: + - name: apikey + description: Your https://shuffler.io apikey + required: true + multiline: false + example: "" + schema: + type: string + - name: text + description: The text you want to be converted (ANY format) + required: true + multiline: true + example: "Bad IPs are 1.2.3.4 and there's no good way to format this. JSON works too!" + schema: + type: string + - name: formatting + description: The format to use. + required: false + multiline: true + example: "Make it work as a ticket we can put in service now that is human readable for security analysts" + schema: + type: string + returns: + schema: + type: string + - name: generate_report + description: Input ANY kind of data in the format you want, and it will make an HTML report for you. This can be downloaded from the File location. + parameters: + - name: apikey + description: Your https://shuffler.io apikey + required: true + multiline: false + example: "" + schema: + type: string + - name: input_data + description: The text you want to be converted (ANY format) + required: true + multiline: true + example: "Bad IPs are 1.2.3.4 and there's no good way to format this. JSON works too!" + schema: + type: string + - name: report_title + description: The report title to be used in the report + required: true + multiline: true + example: "Statistics for October" + schema: + type: string + - name: report_name + description: The name of the HTML file + required: false + multiline: true + example: "statistics.html" + schema: + type: string + returns: + schema: + type: string + - name: extract_text_from_pdf + description: Returns text from a pdf + parameters: + - name: file_id + description: The file to find text in + required: true + multiline: false + example: "file_" + schema: + type: string + returns: + schema: + type: string + - name: extract_text_from_image + description: Returns text from an image + parameters: + - name: file_id + description: The file to find text in + required: true + multiline: false + example: "file_" + schema: + type: string + returns: + schema: + type: string + - name: run_schemaless + description: Runs an automatically translated action + parameters: + - name: category + description: The category the action is in + required: true + multiline: false + schema: + type: string + - name: action + description: The action label to run + required: true + multiline: false + schema: + type: string + - name: app_name + description: The app to run the action in + required: false + multiline: false + schema: + type: string + - name: fields + description: The additional fields to add + required: false + multiline: false + schema: + type: string + returns: + schema: + type: string + - name: transcribe_audio + description: Returns text from audio + parameters: + - name: file_id + description: The file containing the audio + required: true + multiline: false + example: "file_" + schema: + type: string + returns: + schema: + type: string + +large_image: data:image/png;base64,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 diff --git a/shuffle-ai/1.1.0/requirements.txt b/shuffle-ai/1.1.0/requirements.txt new file mode 100644 index 00000000..bb5d1927 --- /dev/null +++ b/shuffle-ai/1.1.0/requirements.txt @@ -0,0 +1,5 @@ +shuffle-sdk==0.0.35 + +pytesseract +pdf2image +pypdf2 diff --git a/shuffle-ai/1.1.0/src/app.py b/shuffle-ai/1.1.0/src/app.py new file mode 100644 index 00000000..8785b341 --- /dev/null +++ b/shuffle-ai/1.1.0/src/app.py @@ -0,0 +1,610 @@ +import os +import json +import tempfile +import requests +import time + +try: + import pytesseract +except Exception as e: + print("Skipping pytesseract import: %s" % e) + +try: + import PyPDF2 +except Exception as e: + print("Skipping PyPDF2 import: %s" % e) + +try: + from pdf2image import convert_from_path +except Exception as e: + print("Skipping pdf2image import: %s" % e) + + +try: + import llama_cpp +except Exception as e: + print("Skipping llama_cpp import: %s" % e) + +print("LD Library: '%s'" % os.environ.get("LD_LIBRARY_PATH", "")) + +from shuffle_sdk import AppBase + +#model = "/models/Llama-3.2-3B.Q8_0.gguf" # Larger +#model = "/models/Llama-3.2-3B.Q2_K.gguf" # Smol + +#model = "/models/DeepSeek-R1-Distill-Llama-8B-Q2_K.gguf" # Smaller +#model = "/models/Meta-Llama-3-8B.Q6_K.gguf" +model = "/models/DeepSeek-R1-Distill-Llama.gguf" +if os.getenv("MODEL_PATH"): + model = os.getenv("MODEL_PATH") + +def load_llm_model(model): + print("Using model path '%s'" % model) + if not os.path.exists(model): + print("Could not find model at path %s" % model) + model_name = model.split("/")[-1] + # Check $HOME/downloads/{model} + + home_path = os.path.expanduser("~") + print(home_path) + + if os.path.exists(f"{home_path}/downloads/{model_name}"): + model = f"{home_path}/downloads/{model_name}" + else: + return { + "success": False, + "reason": "Model not found at path %s" % model, + "details": "Ensure the model path is correct" + } + + # Check for GPU layers + innerllm = None + gpu_layers = os.getenv("GPU_LAYERS") + if gpu_layers: + print("GPU Layers: %s" % gpu_layers) + + gpu_layers = int(gpu_layers) + if gpu_layers > 0: + innerllm = llama_cpp.Llama(model_path=model, n_gpu_layers=gpu_layers) + else: + innerllm = llama_cpp.Llama(model_path=model, n_gpu_layers=8) + else: + # Check if GPU available + print("No GPU layers set.") + #innerllm = llama_cpp.Llama(model_path=model) + + return { + "success": False, + "reason": "GPU layers not set", + "details": "Set GPU_LAYERS environment variable to the number of GPU layers to use (e.g. 8)." + } + + return innerllm + +try: + llm = load_llm_model(model) +except Exception as e: + print("[ERROR] Failed to load LLM model: %s" % e) + llm = { + "success": False, + "reason": "Failed to load LLM model %s" % model, + } + +class ShuffleAI(AppBase): + __version__ = "1.0.0" + app_name = "Shuffle AI" + + def __init__(self, redis, logger, console_logger=None): + super().__init__(redis, logger, console_logger) + + def run_llm(self, input, system_message=""): + global llm + global model + + self.logger.info("[DEBUG] LD LIbrary: '%s'. If this is empty, GPU's may not work." % os.environ.get("LD_LIBRARY_PATH", "")) + + if not system_message: + system_message = "Answer their question directly. Don't use HTML or Markdown", + + self.logger.info("[DEBUG] Running LLM with model '%s'. To overwrite path, use environment variable MODEL_PATH=" % model) + + # Check if llm is a dict or not and look for success and reason in it + if not llm: + return { + "success": False, + "reason": "LLM model not loaded", + "details": "Ensure the LLM model is loaded", + "gpu_layers": os.getenv("GPU_LAYERS"), + } + + if isinstance(llm, dict): + if "success" in llm and not llm["success"]: + # List files in /model folder + llm["folder"] = os.listdir("/models") + llm["gpu_layers"] = os.getenv("GPU_LAYERS") + return llm + + self.logger.info("[DEBUG] Running LLM with input '%s' and system message '%s'. GPU Layers: %s" % (input, system_message, os.getenv("GPU_LAYERS"))) + + # https://github.com/abetlen/llama-cpp-python + try: + print("LLM: ", llm) + + self.logger.info("[DEBUG] LLM: %s" % llm) + output = llm.create_chat_completion( + max_tokens=100, + messages = [ + { + "role": "system", + "content": system_message, + }, + { + "role": "user", + "content": input, + } + ] + ) + except Exception as e: + return { + "success": False, + "reason": f"Failed to run local LLM. Check logs in this execution for more info: {self.current_execution_id}", + "details": f"{e}" + } + + self.logger.info("[DEBUG] LLM output: %s" % output) + + new_message = "" + if "choices" in output and len(output["choices"]) > 0: + new_message = output["choices"][0]["message"]["content"] + + parsed_output = { + "success": True, + "model": output["model"], + "output": new_message, + } + + if "tokens" in output: + parsed_output["tokens"] = output["tokens"] + + if "usage" in output: + parsed_output["tokens"] = output["usage"] + + if not os.getenv("GPU_LAYERS"): + parsed_output["debug"] = "GPU_LAYERS not set. Running on CPU. Set GPU_LAYERS to the number of GPU layers to use (e.g. 8)." + + return parsed_output + + def security_assistant(self): + # Currently testing outside the Shuffle environment + # using assistants and local LLMs + + return "Not implemented" + + def shuffle_cloud_inference(self, apikey, text, formatting="auto"): + headers = { + "Authorization": "Bearer %s" % apikey, + } + + if not formatting: + formatting = "auto" + + output_formatting= "Format the following data to be a good email that can be sent to customers. Don't make it too business sounding." + if formatting != "auto": + output_formatting = formatting + + ret = requests.post( + "https://shuffler.io/api/v1/conversation", + json={ + "query": text, + "formatting": output_formatting, + "output_format": "formatting" + }, + headers=headers, + ) + + if ret.status_code != 200: + print(ret.text) + return { + "success": False, + "reason": "Status code for auto-formatter is not 200" + } + + return ret.text + + def autoformat_text(self, apikey, text, formatting="auto"): + headers = { + "Authorization": "Bearer %s" % apikey, + } + + if not formatting: + formatting = "auto" + + output_formatting= "Format the following data to be a good email that can be sent to customers. Don't make it too business sounding." + if formatting != "auto": + output_formatting = formatting + + ret = requests.post( + "https://shuffler.io/api/v1/conversation", + json={ + "query": text, + "formatting": output_formatting, + "output_format": "formatting" + }, + headers=headers, + ) + + if ret.status_code != 200: + print(ret.text) + return { + "success": False, + "reason": "Status code for auto-formatter is not 200" + } + + return ret.text + + def generate_report(self, apikey, input_data, report_title, report_name="generated_report.html"): + headers = { + "Authorization": "Bearer %s" % apikey, + } + + if not report_name: + report_name = "generated_report.html" + + if "." in report_name and not ".html" in report_name: + report_name = report_name.split(".")[0] + + if not "html" in report_name: + report_name = report_name + ".html" + + report_name = report_name.replace(" ", "_", -1) + output_formatting= "Format the following text into an HTML report with relevant graphs and tables. Title of the report should be {report_title}." + ret = requests.post( + "https://shuffler.io/api/v1/conversation", + json={ + "query": text, + "formatting": output_formatting, + "output_format": "formatting" + }, + headers=headers, + ) + + if ret.status_code != 200: + print(ret.text) + return { + "success": False, + "reason": "Status code for auto-formatter is not 200" + } + + # Make it into a shuffle file with self.set_files() + new_file = { + "name": report_name, + "data": ret.text, + } + + retdata = self.set_files([new_file]) + if retdata["success"]: + return retdata + + return { + "success": False, + "reason": "Failed to upload file" + } + + + def extract_text_from_pdf(self, file_id): + def extract_pdf_text(pdf_path): + with open(pdf_path, 'rb') as file: + pdf_reader = PyPDF2.PdfReader(file) + text = '' + for page in pdf_reader.pages: + text += page.extract_text() + + return text + + def extract_text_from_images(images): + text = '' + for image in images: + extracted_text = pytesseract.image_to_string(image, lang='eng') + text += extracted_text + return text + + def extract_text_from_pdf_with_images(pdf_path): + images = convert_from_path(pdf_path) + return extract_text_from_images(images) + + def export_text_to_json(image_text, extracted_text): + data = { + "success": True, + 'image_text': image_text, + 'extracted_text': extracted_text, + } + + #with open(output_path, 'w+') as file: + # json.dump(data, file, indent=4) + + return data + + pdf_data = self.get_file(file_id) + defaultdata = { + "success": False, + "file_id": file_id, + "filename": pdf_data["filename"], + "reason": "Something failed in reading and parsing the pdf. See error logs for more info", + } + + # Check type of pdf_data["data"] + if not isinstance(pdf_data["data"], bytes): + self.logger.info("Encoding data to bytes for the bytestream reader") + pdf_data["data"] = pdf_data["data"].encode() + + # Make a tempfile for the file data from self.get_file + # Make a tempfile with tempfile library + with tempfile.NamedTemporaryFile() as temp: + # Write the file data to the tempfile + # Get the path to the tempfile + temp.write(pdf_data["data"]) + pdf_path = temp.name + + # Extract text from the PDF + extracted_text_from_pdf = extract_pdf_text(pdf_path) + + # Extract text from the PDF using images + extracted_text_from_images = extract_text_from_pdf_with_images(pdf_path) + + # Combine the extracted text + + # Export combined text to JSON + #output_path = pdf_path.split(".")[0] + ".json" + exported_text = export_text_to_json(extracted_text_from_images, extracted_text_from_pdf) + exported_text["file_id"] = file_id + exported_text["filename"] = pdf_data["filename"] + return exported_text + + return defaultdata + + def extract_text_from_image(self, file_id): + # Check if it's a pdf + + pdf_data = self.get_file(file_id) + if "filename" not in pdf_data: + available_fields = [] + for key, value in pdf_data.items(): + available_fields.append(key) + + return { + "success": False, + "reason": "File not found", + "details": f"Available fields: {available_fields}", + } + + # If it is, use extract_text_from_pdf + # If it's not, use pytesseract + if pdf_data["filename"].endswith(".pdf"): + return self.extract_text_from_pdf(file_id) + + defaultdata = { + "success": False, + "file_id": file_id, + "filename": pdf_data["filename"], + "reason": "Something failed in reading and parsing the pdf. See error logs for more info", + } + + with tempfile.NamedTemporaryFile() as temp: + # Load temp as Image + # Write the file data to the tempfile + # Get the path to the tempfile + temp.write(pdf_data["data"]) + pdf_path = temp.name + + image = Image.open(temp.name) + image = image.resize((500,300)) + custom_config = r'-l eng --oem 3 --psm 6' + text = pytesseract.image_to_string(image,config=custom_config) + + data = { + "success": True, + 'extracted_text': text, + } + + return data + + return defaultdata + + def transcribe_audio(self, file_id): + return { + "success": False, + "reason": "Not implemented yet" + } + + def find_image_objects(self, file_id): + return { + "success": False, + "reason": "Not implemented yet" + } + + def gpt(self, input_text): + return { + "success": False, + "reason": "Not implemented yet" + } + + def run_agent(self, input_data, actions=None, apps=None): + prepared_format = { + "id": self.action["id"], + "params": { + "tool_name": self.action["app_name"], + "tool_id": self.action["app_id"], + "environment": self.action["environment"], + "input": { + "text": input_data, + } + }, + } + + if actions: + prepared_format["params"]["tool_name"] = actions + + if apps: + pass + + baseurl = f"{self.url}/api/v1/agent?execution_id={self.current_execution_id}&authorization={self.authorization}&action_id={self.action['id']}" + self.logger.info("[DEBUG] Running agent action with URL '%s'" % (baseurl)) + + headers = {} + request = requests.post( + baseurl, + json=prepared_format, + headers=headers, + ) + + # Random sleep timer to force delay + time.sleep(2) + # Gets into waiting state on backend + return json.dumps({ + "app_run": True, + "input_prompt": prepared_format, + "status": request.status_code, + "body": request.text, + }) + + def run_schemaless(self, category, action, app_name="", fields=""): + self.logger.info("[DEBUG] Running schemaless action with category '%s' and action label '%s'" % (category, action)) + + # Not necessary anymore + """ + action := shuffle.CategoryAction{ + Label: step.Name, + Category: step.Category, + AppName: step.AppName, + Fields: step.Fields, + + Environment: step.Environment, + + SkipWorkflow: true, + } + """ + + data = { + "label": action, + "category": category, + + "app_name": "", + "fields": [], + + "skip_workflow": True, + } + + if app_name: + data["app_name"] = app_name + + if fields: + if isinstance(fields, list): + data["fields"] = fields + + elif isinstance(fields, dict): + for key, value in fields.items(): + parsedvalue = str(value) + try: + if str(value).startswith("{") or str(value).startswith("["): + parsedvalue = json.dumps(value) + except: + pass + + data["fields"].append({ + "key": key, + "value": parsedvalue, + }) + + else: + fields = str(fields).strip() + # Valid format: + # {"field1": "value1", "field2": "value2"} + # field1=value1&field2=value2 + # field1:value1\nfield2:value2 + + cursplit = None + if "\\n" in fields and not fields.startswith("{") and not fields.startswith("["): + cursplit = "\\n" + elif ("=" in fields or ":" in fields) and not fields.startswith("{") and not fields.startswith("["): + cursplit = "&" + + if cursplit: + newfields = [] + for line in fields.split(cursplit): + splitkey = None + if "=" in line: + splitkey = "=" + elif ":" in line: + splitkey = ":" + + if splitkey: + parts = line.split(splitkey, 1) + newfields.append({ + "key": parts[0].strip(), + "value": splitkey.join(parts[1:]).strip(), + }) + + data["fields"] = newfields + else: + if not fields.startswith("{") and not fields.startswith("["): + fields = json.dumps({ + "data": fields, + }) + + try: + loadedfields = json.loads(fields) + for key, value in loadedfields.items(): + data["fields"].append({ + "key": key, + "value": value, + }) + + except Exception as e: + self.logger.info("[ERROR] Failed to load fields as JSON: %s" % e) + return json.dumps({ + "success": False, + "reason": "Ensure 'Fields' are valid JSON", + "details": "%s" % e, + }) + + #baseurl = "%s/api/v1/apps/categories/run" % self.base_url + baseurl = "%s/api/v1/apps/categories/run" % self.url + baseurl += "?execution_id=%s&authorization=%s" % (self.current_execution_id, self.authorization) + + self.logger.info("[DEBUG] Running schemaless action with URL '%s', category %s and action label %s" % (baseurl, category, action)) + + headers = {} + request = requests.post( + baseurl, + json=data, + headers=headers, + ) + + try: + if "parameters" in self.action: + response_headers = request.headers + for key, value in response_headers.items(): + if not str(key).lower().endswith("-url"): + continue + + self.action["parameters"].append({ + "name": key, + "value": value, + }) + + #self.logger.info("[DEBUG] Response header: %s: %s" % (key, value)) + except Exception as e: + self.logger.info("[ERROR] Failed to get response headers (category action url debug mapping): %s" % e) + + try: + data = request.json() + + #if "success" in data and "result" in data and "errors" in data: + # return data["result"] + + return data + except: + return request.text + +if __name__ == "__main__": + ShuffleAI.run() diff --git a/shuffle-ai/1.1.0/upload.sh b/shuffle-ai/1.1.0/upload.sh new file mode 100755 index 00000000..b449aa4b --- /dev/null +++ b/shuffle-ai/1.1.0/upload.sh @@ -0,0 +1,16 @@ +gcloud config set project shuffler + +gcloud beta run deploy shuffle-ai-1-0-0 \ + --project=shuffler \ + --region=europe-west4 \ + --source=./ \ + --max-instances=1 \ + --concurrency=64 \ + --gpu 1 --gpu-type=nvidia-l4 \ + --cpu 4 \ + --memory=16Gi \ + --no-cpu-throttling \ + --set-env-vars=MODEL_PATH=/models/DeepSeek-R1-Distill-Llama.gguf,GPU_LAYERS=64,SHUFFLE_APP_EXPOSED_PORT=8080,SHUFFLE_SWARM_CONFIG=run,SHUFFLE_LOGS_DISABLED=true,SHUFFLE_APP_SDK_TIMEOUT=300,LD_LIBRARY_PATH=/usr/local/lib:/usr/local/nvidia/lib64:$LD_LIBRARY_PATH \ + --source=./ \ + --service-account=shuffle-apps@shuffler.iam.gserviceaccount.com \ + --timeout=120s diff --git a/shuffle-subflow/1.0.0/api.yaml b/shuffle-subflow/1.0.0/api.yaml index 9d2642bb..4148c19a 100644 --- a/shuffle-subflow/1.0.0/api.yaml +++ b/shuffle-subflow/1.0.0/api.yaml @@ -58,4 +58,45 @@ actions: returns: schema: type: string + - name: run_userinput + description: Stops a workflow and notifies the right people + parameters: + - name: user_apikey + description: The apikey to connect back to the APIs + required: true + multiline: false + example: "apikey" + schema: + type: string + - name: sms + description: The numbers to send an sms to + required: false + multiline: false + example: "+474135212,+180241322" + schema: + type: string + - name: email + description: The emails to send an email to + required: false + multiline: false + example: "example@shuffler.io,test@test.com" + schema: + type: string + - name: subflow + description: The subflow IDs to start + required: false + multiline: false + example: "7944b41d-6200-4f28-8973-22ba52637bf0,4832b41d-6200-4f28-8973-22ba52637bf0" + schema: + type: string + - name: information + description: The information to send to the targets + required: false + multiline: true + example: "This is an argument using some liquid: {{ 1 + 2 }} " + schema: + type: string + returns: + schema: + type: string large_image: data:image/png;base64,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 diff --git a/shuffle-subflow/1.0.0/requirements.txt b/shuffle-subflow/1.0.0/requirements.txt index fd7d3e06..41daa615 100644 --- a/shuffle-subflow/1.0.0/requirements.txt +++ b/shuffle-subflow/1.0.0/requirements.txt @@ -1 +1,2 @@ -requests==2.25.1 \ No newline at end of file +requests==2.32.4 +shuffle-sdk diff --git a/shuffle-subflow/1.0.0/src/app.py b/shuffle-subflow/1.0.0/src/app.py index 43f3dcce..adcb13cd 100644 --- a/shuffle-subflow/1.0.0/src/app.py +++ b/shuffle-subflow/1.0.0/src/app.py @@ -1,11 +1,7 @@ -import asyncio -import time -import random import json import requests -import json -from walkoff_app_sdk.app_base import AppBase +from shuffle_sdk import AppBase class Subflow(AppBase): """ @@ -24,14 +20,131 @@ def __init__(self, redis, logger, console_logger=None): """ super().__init__(redis, logger, console_logger) - #def run_userinput(self, sms, email, subflow, argument): - # url = "%s/api/v1/workflows/%s/execute" % (self.url, workflow) + # Should run user input + def run_userinput(self, user_apikey, sms="", email="", subflow="", information="", startnode="", backend_url="", source_node=""): + #url = "%s/api/v1/workflows/%s/execute" % (self.url, workflow) + + headers = { + "Authorization": "Bearer %s" % user_apikey, + "User-Agent": "Shuffle Userinput 1.1.0" + } - # if len(sms) > 0: + result = { + "success": True, + "source": "userinput", + "reason": "Userinput data sent and workflow paused. Waiting for user input before continuing workflow.", + "information": information, + "click_info": { + "clicked": False, + "time": "", + "ip": "", + "user": "", + "note": "", + } + } - def run_subflow(self, user_apikey, workflow, argument, source_workflow="", source_execution="", source_node="", source_auth="", startnode=""): - print("STARTNODE: %s" % startnode) + url = self.url + if len(self.base_url) > 0: + url = self.base_url + + if len(str(backend_url)) > 0: + url = backend_url + + print("Found backend url: %s" % url) + #if len(information): + # print("Should run arg: %s", information) + + if len(subflow): + #print("Should run subflow: %s", subflow) + + # Missing startnode (user input trigger) + #print("Subflows to run from userinput: ", subflows) + + subflows = subflow.split(",") + frontend_url = url + if ":5001" in frontend_url: + print("Should change port to 3001.") + if "appspot.com" in frontend_url: + frontend_url = "https://shuffler.io" + + for item in subflows: + # In case of URL being passed, and not just ID + if "/" in item: + item = item.split("/")[-1] + + # Subflow should be the subflow to run + # Workflow in the URL should be the source workflow + argument = json.dumps({ + "information": information, + "parent_workflow": self.full_execution["workflow"]["id"], + "frontend_continue": "%s/forms/%s?authorization=%s&reference_execution=%s&answer=true" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"]), + "frontend_abort": "%s/forms/%s?authorization=%s&reference_execution=%s&answer=false" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"]), + "api_continue": "%s/api/v1/workflows/%s/execute?authorization=%s&reference_execution=%s&answer=true" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"]), + "api_abort": "%s/api/v1/workflows/%s/execute?authorization=%s&reference_execution=%s&answer=false" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"]), + }) + + ret = self.run_subflow(user_apikey, item, argument, source_workflow=self.full_execution["workflow"]["id"], source_execution=self.full_execution["execution_id"], source_auth=self.full_execution["authorization"], startnode=startnode, backend_url=backend_url, source_node=source_node) + result["subflow"] = ret + result["subflow_url"] = "%s/workflows/%s" % (frontend_url, item) + + if len(email): + jsondata = { + "targets": [], + "body": information, + "subject": "User input required", + "type": "User input", + "start": startnode, + "workflow_id": self.full_execution["workflow"]["id"], + "reference_execution": self.full_execution["execution_id"], + "authorization": self.full_execution["authorization"], + } + + for item in email.split(","): + jsondata["targets"].append(item.strip()) + + print("Should run email with targets: %s", jsondata["targets"]) + + ret = requests.post("%s/api/v1/functions/sendmail" % url, json=jsondata, headers=headers) + if ret.status_code != 200: + print("Failed sending email. Data: %s" % ret.text) + result["email"] = False + else: + result["email"] = True + + if len(sms) > 0: + print("Should run SMS: %s", sms) + + jsondata = { + "numbers": [], + "body": information, + "type": "User input", + "start": startnode, + "workflow_id": self.full_execution["workflow"]["id"], + "reference_execution": self.full_execution["execution_id"], + "authorization": self.full_execution["authorization"], + } + + for item in sms.split(","): + jsondata["numbers"].append(item.strip()) + + print("Should send sms with targets: %s", jsondata["numbers"]) + + ret = requests.post("%s/api/v1/functions/sendsms" % url, json=jsondata, headers=headers) + if ret.status_code != 200: + print("Failed sending email. Data: %s" % ret.text) + result["sms"] = False + else: + result["sms"] = True + + + + return json.dumps(result) + + def run_subflow(self, user_apikey, workflow, argument, source_workflow="", source_execution="", source_node="", source_auth="", startnode="", backend_url="", auth_override=""): + #print("STARTNODE: %s" % startnode) url = "%s/api/v1/workflows/%s/execute" % (self.url, workflow) + if len(self.base_url) > 0: + url = "%s/api/v1/workflows/%s/execute" % (self.base_url, workflow) params = {} if len(str(source_workflow)) > 0: @@ -59,19 +172,34 @@ def run_subflow(self, user_apikey, workflow, argument, source_workflow="", sourc else: print("No startnode") + if len(self.full_execution["execution_id"]) > 0 and self.full_execution["execution_id"] != source_execution: + params["source_execution"] = self.full_execution["execution_id"] + + if len(self.full_execution["authorization"]) > 0 and self.full_execution["authorization"] != source_auth: + params["source_auth"] = self.full_execution["authorization"] + + if len(str(backend_url)) > 0: + url = "%s/api/v1/workflows/%s/execute" % (backend_url, workflow) + print("[INFO] Changed URL to %s for this execution" % url) + headers = { "Authorization": "Bearer %s" % user_apikey, + "User-Agent": "Shuffle Subflow 1.0.0" } + if len(auth_override) > 0: + headers["appauth"] = auth_override + if len(str(argument)) == 0: ret = requests.post(url, headers=headers, params=params) else: - if not isinstance(argument, list) and not isinstance(argument, object) and not isinstance(argument, dict): + if not isinstance(argument, list) and not isinstance(argument, dict): try: argument = json.loads(argument) except: pass + #print(f"ARG: {argument}") try: ret = requests.post(url, headers=headers, params=params, json=argument) print(f"Successfully sent argument of length {len(str(argument))} as JSON") @@ -88,10 +216,5 @@ def run_subflow(self, user_apikey, workflow, argument, source_workflow="", sourc return ret.text - # This logs to the docker logs - #self.logger.info(message) - - return message - if __name__ == "__main__": Subflow.run() diff --git a/hoxhunt/1.0.0/Dockerfile b/shuffle-subflow/1.1.0/Dockerfile similarity index 100% rename from hoxhunt/1.0.0/Dockerfile rename to shuffle-subflow/1.1.0/Dockerfile diff --git a/shuffle-subflow/1.1.0/api.yaml b/shuffle-subflow/1.1.0/api.yaml new file mode 100644 index 00000000..0c64bda1 --- /dev/null +++ b/shuffle-subflow/1.1.0/api.yaml @@ -0,0 +1,102 @@ +app_version: 1.1.0 +name: Shuffle Subflow +description: The Shuffle Subflow app +tags: + - Trigger +categories: + - Trigger +contact_info: + name: "@frikkylikeme" + url: https://shuffler.io + email: frikky@shuffler.io +actions: + - name: run_subflow + description: Executes a subflow + parameters: + - name: user_apikey + description: The apikey to use + required: true + multiline: false + example: "REPEATING: Hello world" + schema: + type: string + - name: workflow + description: The Workflow to execute + required: true + multiline: false + example: "REPEATING: Hello world" + schema: + type: string + - name: execution_argument + description: The execution_argument + required: true + multiline: true + example: "REPEATING: Hello world" + schema: + type: string + - name: startnode + description: + required: false + multiline: false + example: "" + schema: + type: string + - name: source_workflow + description: + required: false + multiline: false + example: "" + schema: + type: string + - name: source_execution + description: + required: false + multiline: false + example: "" + schema: + type: string + returns: + schema: + type: string + - name: run_userinput + description: Stops a workflow and notifies the right people + parameters: + - name: user_apikey + description: The apikey to connect back to the APIs + required: true + multiline: false + example: "apikey" + schema: + type: string + - name: sms + description: The numbers to send an sms to + required: false + multiline: false + example: "+474135212,+180241322" + schema: + type: string + - name: email + description: The emails to send an email to + required: false + multiline: false + example: "example@shuffler.io,test@test.com" + schema: + type: string + - name: subflow + description: The subflow IDs to start + required: false + multiline: false + example: "7944b41d-6200-4f28-8973-22ba52637bf0,4832b41d-6200-4f28-8973-22ba52637bf0" + schema: + type: string + - name: information + description: The information to send to the targets + required: false + multiline: true + example: "This is an argument using some liquid: {{ 1 + 2 }} " + schema: + type: string + returns: + schema: + type: string +large_image: data:image/png;base64,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 diff --git a/shuffle-subflow/1.1.0/requirements.txt b/shuffle-subflow/1.1.0/requirements.txt new file mode 100644 index 00000000..41daa615 --- /dev/null +++ b/shuffle-subflow/1.1.0/requirements.txt @@ -0,0 +1,2 @@ +requests==2.32.4 +shuffle-sdk diff --git a/testing/1.0.0/run b/shuffle-subflow/1.1.0/run similarity index 100% rename from testing/1.0.0/run rename to shuffle-subflow/1.1.0/run diff --git a/shuffle-subflow/1.1.0/src/app.py b/shuffle-subflow/1.1.0/src/app.py new file mode 100644 index 00000000..f51ace59 --- /dev/null +++ b/shuffle-subflow/1.1.0/src/app.py @@ -0,0 +1,242 @@ +import json +import requests + +from shuffle_sdk import AppBase + +class Subflow(AppBase): + """ + An example of a Walkoff App. + Inherit from the AppBase class to have Redis, logging, and console logging set up behind the scenes. + """ + __version__ = "1.1.0" + app_name = "subflow" # this needs to match "name" in api.yaml + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + # Should run user input + def run_userinput(self, user_apikey, sms="", email="", subflow="", information="", startnode="", backend_url="", source_node=""): + #url = "%s/api/v1/workflows/%s/execute" % (self.url, workflow) + + headers = { + "Authorization": "Bearer %s" % user_apikey, + "User-Agent": "Shuffle Userinput 1.1.0", + } + + + result = { + "success": True, + "source": "userinput", + "reason": "Userinput data sent and workflow paused. Waiting for user input before continuing workflow.", + "information": information, + "click_info": { + "clicked": False, + "time": "", + "ip": "", + "user": "", + "note": "", + }, + "links": { + "frontend_no_answer": "", + "api_continue": "", + "api_abort": "", + } + } + + url = self.url + if len(self.base_url) > 0: + url = self.base_url + + if len(str(backend_url)) > 0: + url = backend_url + + frontend_url = url + if ":5001" in frontend_url: + print("Should change port to 3001.") + if "appspot.com" in frontend_url: + frontend_url = "https://shuffler.io" + if "run.app" in frontend_url: + frontend_url = "https://shuffler.io" + if "ngrok" in frontend_url: + frontend_url = "" + if "shuffle-backend" in frontend_url: + frontend_url = "" + + api_continue_url = "%s/api/v1/workflows/%s/execute?authorization=%s&reference_execution=%s&answer=true&source_node=%s" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"], source_node) + api_abort_url = "%s/api/v1/workflows/%s/execute?authorization=%s&reference_execution=%s&answer=false&source_node=%s" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"], source_node) + + # Remove subdomain before .shuffler.io so that https://*.shuffler.io -> https://shuffler.io + if ".shuffler.io" in frontend_url: + frontend_url = "https://shuffler.io" + + explore_path = "%s/forms/%s?authorization=%s&reference_execution=%s&source_node=%s&backend_url=%s" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"], source_node, backend_url) + frontend_continue_url = "%s/forms/%s?authorization=%s&reference_execution=%s&answer=true&source_node=%s&backend_url=%s" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"], source_node, backend_url) + frontend_abort_url = "%s/forms/%s?authorization=%s&reference_execution=%s&answer=false&source_node=%s&backend_url=%s" % (frontend_url, self.full_execution["workflow"]["id"], self.full_execution["authorization"], self.full_execution["execution_id"], source_node, backend_url) + + result["links"]["frontend_no_answer"] = explore_path + result["links"]["frontend_continue"] = frontend_continue_url + result["links"]["frontend_abort"] = frontend_abort_url + result["links"]["api_continue"] = api_continue_url + result["links"]["api_abort"] = api_abort_url + + print("Found backend url: %s" % url) + if len(subflow) > 0: + + subflows = subflow.split(",") + for item in subflows: + # In case of URL being passed, and not just ID + if "/" in item: + item = item.split("/")[-1] + + # Subflow should be the subflow to run + # Workflow in the URL should be the source workflow + argument = json.dumps({ + "information": information, + "parent_workflow": self.full_execution["workflow"]["id"], + "frontend_continue": frontend_continue_url, + "frontend_abort": frontend_abort_url, + "api_continue": api_continue_url, + "api_abort": api_abort_url, + }) + + ret = self.run_subflow(user_apikey, item, argument, source_workflow=self.full_execution["workflow"]["id"], source_execution=self.full_execution["execution_id"], source_auth=self.full_execution["authorization"], startnode=startnode, backend_url=backend_url, source_node=source_node) + result["subflow"] = ret + result["subflow_url"] = "%s/workflows/%s" % (frontend_url, item) + + if len(email): + jsondata = { + "targets": [], + "body": information, + "subject": "User input required", + "type": "User input", + "start": startnode, + "workflow_id": self.full_execution["workflow"]["id"], + "reference_execution": self.full_execution["execution_id"], + "authorization": self.full_execution["authorization"], + } + + for item in email.split(","): + jsondata["targets"].append(item.strip()) + + print("Should run email with targets: %s", jsondata["targets"]) + + ret = requests.post("%s/api/v1/functions/sendmail" % url, json=jsondata, headers=headers, verify=False, proxies=self.proxy_config) + if ret.status_code != 200: + print("Failed sending email. Data: %s" % ret.text) + result["email"] = False + else: + result["email"] = True + + if len(sms) > 0: + print("Should run SMS: %s", sms) + + jsondata = { + "numbers": [], + "body": information, + "type": "User input", + "start": startnode, + "workflow_id": self.full_execution["workflow"]["id"], + "reference_execution": self.full_execution["execution_id"], + "authorization": self.full_execution["authorization"], + } + + for item in sms.split(","): + jsondata["numbers"].append(item.strip()) + + print("Should send sms with targets: %s", jsondata["numbers"]) + + ret = requests.post("%s/api/v1/functions/sendsms" % url, json=jsondata, headers=headers, verify=False, proxies=self.proxy_config) + if ret.status_code != 200: + print("Failed sending email. Data: %s" % ret.text) + result["sms"] = False + else: + result["sms"] = True + + + + return json.dumps(result) + + def run_subflow(self, user_apikey, workflow, argument, source_workflow="", source_execution="", source_node="", source_auth="", startnode="", backend_url="", check_result="", auth_override=""): + #print("STARTNODE: %s" % startnode) + url = "%s/api/v1/workflows/%s/execute" % (self.url, workflow) + if len(self.base_url) > 0: + url = "%s/api/v1/workflows/%s/execute" % (self.base_url, workflow) + + params = {} + if len(str(source_workflow)) > 0: + params["source_workflow"] = source_workflow + else: + print("No source workflow") + + if len(str(source_auth)) > 0: + params["source_auth"] = source_auth + else: + print("No source auth") + + if len(str(source_node)) > 0: + params["source_node"] = source_node + else: + print("No source node") + + if len(str(source_execution)) > 0: + params["source_execution"] = source_execution + else: + print("No source execution") + + if len(str(startnode)) > 0: + params["start"] = startnode + else: + print("No startnode") + + if len(self.full_execution["execution_id"]) > 0 and self.full_execution["execution_id"] != source_execution: + params["source_execution"] = self.full_execution["execution_id"] + + if len(self.full_execution["authorization"]) > 0 and self.full_execution["authorization"] != source_auth: + params["source_auth"] = self.full_execution["authorization"] + + if len(str(backend_url)) > 0: + url = "%s/api/v1/workflows/%s/execute" % (backend_url, workflow) + print("[INFO] Changed URL to %s for this execution" % url) + + headers = { + "Authorization": "Bearer %s" % user_apikey, + "User-Agent": "Shuffle Subflow 1.1.0" + } + + if len(auth_override) > 0: + headers["appauth"] = auth_override + + if len(str(argument)) == 0: + ret = requests.post(url, headers=headers, params=params, verify=False, proxies=self.proxy_config) + else: + if not isinstance(argument, list) and not isinstance(argument, dict): + try: + argument = json.loads(argument) + except: + pass + + #print(f"ARG: {argument}") + try: + ret = requests.post(url, headers=headers, params=params, json=argument, verify=False, proxies=self.proxy_config) + print(f"Successfully sent argument of length {len(str(argument))} as JSON") + except: + try: + ret = requests.post(url, headers=headers, json=argument, params=params, verify=False, proxies=self.proxy_config) + print("Successfully sent as JSON (2)") + except: + ret = requests.post(url, headers=headers, data=argument, params=params, verify=False, proxies=self.proxy_config) + print("Successfully sent as data (3)") + + print("Status: %d" % ret.status_code) + print("RET: %s" % ret.text) + + return ret.text + +if __name__ == "__main__": + Subflow.run() diff --git a/shuffle-tools/1.0.0/api.yaml b/shuffle-tools/1.0.0/api.yaml deleted file mode 100644 index b2f9b61e..00000000 --- a/shuffle-tools/1.0.0/api.yaml +++ /dev/null @@ -1,815 +0,0 @@ ---- -app_version: 1.0.0 -name: Shuffle Tools -description: A tool app for Shuffle -tags: - - Testing - - Shuffle -categories: - - Testing - - Shuffle -contact_info: - name: "@frikkylikeme" - url: https://shuffler.io - email: frikky@shuffler.io -actions: - - name: repeat_back_to_me - description: Repeats the call parameter - parameters: - - name: call - description: The message to repeat - required: true - multiline: true - example: "REPEATING: Hello world" - schema: - type: string - returns: - schema: - type: string - - name: router - description: Reroutes information between different nodes - returns: - schema: - type: string - - name: get_cache_value - description: Get a value saved to your organization in Shuffle - parameters: - - name: key - description: The key to get - required: true - multiline: false - example: "timestamp" - schema: - type: string - returns: - schema: - type: string - - name: set_cache_value - description: Set a value to be saved to your organization in Shuffle. - parameters: - - name: key - description: The key to set the value for - required: true - multiline: false - example: "timestamp" - schema: - type: string - - name: value - description: The value to set - required: true - multiline: true - example: "1621959545" - schema: - type: string - returns: - schema: - type: string - - name: send_sms_shuffle - description: Send an SMS from Shuffle - parameters: - - name: apikey - description: Your https://shuffler.io organization apikey - multiline: false - example: "https://shuffler.io apikey" - required: true - schema: - type: string - - name: phone_numbers - description: The receivers of the SMS - multiline: false - example: "+4741323535,+8151023022" - required: true - schema: - type: string - - name: body - description: The SMS to add to the numbers - multiline: true - example: "This is an alert from Shuffle :)" - required: true - schema: - type: string - returns: - schema: - type: string - - name: send_email_shuffle - description: Send an email from Shuffle - parameters: - - name: apikey - description: Your https://shuffler.io organization apikey - multiline: false - example: "https://shuffler.io apikey" - required: true - schema: - type: string - - name: recipients - description: The recipients of the email - multiline: false - example: "test@example.com,frikky@shuffler.io" - required: true - schema: - type: string - - name: subject - description: The subject to use - multiline: false - example: "SOS this is an alert :o" - required: true - schema: - type: string - - name: body - description: The body to add to the email - multiline: true - example: "This is an email alert from Shuffler.io :)" - required: true - schema: - type: string - returns: - schema: - type: string - - name: filter_list - description: Takes a list and filters based on your data - skip_multicheck: true - parameters: - - name: input_list - description: The list to check - required: true - multiline: false - example: '[{"data": "1.2.3.4"}, {"data": "1.2.3.5"}]' - schema: - type: string - - name: field - description: The field to check - required: false - multiline: false - example: "data" - schema: - type: string - - name: check - description: Type of check - required: true - example: "equals" - options: - - equals - - 'larger than' - - 'less than' - - is empty - - contains - - contains any of - - starts with - - ends with - - field is unique - - files by extension - schema: - type: string - - name: value - description: The value to check with - required: false - multiline: false - example: "1.2.3.4" - schema: - type: string - - name: opposite - description: Whether to add or to NOT add - required: true - options: - - False - - True - multiline: false - example: "false" - schema: - type: string - returns: - schema: - type: string - #- name: multi_list_filter - # description: Takes a list and filters based on your data - # skip_multicheck: true - # parameters: - # - name: input_list - # description: The list to check - # required: true - # multiline: false - # example: '[{"data": "1.2.3.4"}, {"data": "1.2.3.5"}]' - # schema: - # type: string - # - name: field - # description: The field to check - # required: true - # multiline: false - # example: "data" - # schema: - # type: string - # - name: check - # description: Type of check - # required: true - # example: "equals,equals" - # schema: - # type: string - # - name: value - # description: The value to check with - # required: true - # multiline: false - # example: "1.2.3.4" - # schema: - # type: string - # returns: - # schema: - # type: string - - name: parse_ioc - description: Parse IOC's based on https://github.com/fhightower/ioc-finder - parameters: - - name: input_string - description: The string to check - required: true - multiline: true - example: "123ijq192.168.3.6kljqwiejs8 https://shuffler.io" - schema: - type: string - - name: input_type - description: The string to check - required: false - multiline: false - example: "md5s" - schema: - type: string - returns: - schema: - type: string - - name: parse_file_ioc - description: Parse IOC's based on https://github.com/fhightower/ioc-finder - parameters: - - name: file_ids - description: The shuffle file to check - required: true - multiline: false - schema: - type: string - - name: input_type - description: The string to check - required: false - multiline: false - example: "md5s" - schema: - type: string - returns: - schema: - type: string - - name: translate_value - description: Takes a list of values and translates it in your input data - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: Hello this is an md5 - schema: - type: string - - name: translate_from - description: The source items to look for - required: true - multiline: false - example: sha256,md5,sha1 - schema: - type: string - - name: translate_to - description: The destination data to change to - required: true - multiline: true - example: hash - schema: - type: string - - name: else_value - description: The value to set if it DOESNT match. Default to nothing. - required: false - multiline: false - example: - schema: - type: string - returns: - returns: - schema: - type: string - - name: map_value - description: Takes a mapping dictionary and translates the input data - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: $exec.field1 - schema: - type: string - - name: mapping - description: The mapping dictionary - required: true - multiline: true - example: | - { - "Low": 1, - "Medium": 2, - "High": 3, - } - schema: - type: string - returns: - schema: - type: string - - name: regex_replace - description: Replace all instances matching a regular expression - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: $exec.http_headers - schema: - type: string - - name: regex - description: Your regular expression - multiline: false - example: "(Content-\\w+): (.*)" - required: true - schema: - type: string - - name: replace_string - description: Replacement string (capture groups with \1 \2) - multiline: true - example: "Content header '\\1' = '\\2'" - required: false - schema: - type: string - - name: ignore_case - description: "Make regex case insensitive (Default: False)" - multiline: false - example: "False" - required: false - schema: - type: string - returns: - schema: - type: string - - name: parse_list - description: Parses a list and returns it as a json object - parameters: - - name: items - description: List of items - required: true - multiline: true - example: shuffler.io,test.com,test.no - schema: - type: string - - name: splitter - description: The splitter to use - required: false - multiline: false - example: "," - schema: - type: string - returns: - schema: - type: string - - name: execute_bash - description: Runs bash with the data inputted available (TBD) - parameters: - - name: code - description: The code to run - required: true - multiline: true - example: echo "Hello" - schema: - type: string - - name: shuffle_input - description: Alternative data to add - required: false - multiline: true - example: '{"data": "Hello world"}' - schema: - type: string - - name: get_file_value - description: This function is made for reading file(s), printing their data - parameters: - - name: filedata - description: The files - required: true - multiline: true - example: "REPEATING: Hello world" - schema: - type: file - returns: - schema: - type: string - - name: download_remote_file - description: Downloads a file from a URL - parameters: - - name: url - description: - required: true - multiline: false - example: "https://secure.eicar.org/eicar.com.txt" - schema: - type: string - returns: - schema: - type: string - - name: get_file_meta - description: Gets the file meta - parameters: - - name: file_id - description: - required: true - multiline: false - example: "" - schema: - type: string - returns: - schema: - type: string - - name: delete_file - description: Deletes a file based on ID - parameters: - - name: file_id - description: - required: true - multiline: false - example: "Some data to put in the file" - schema: - type: string - returns: - schema: - type: string - - name: extract_archive - description: Extract compressed files, return file ids - parameters: - - name: file_ids - description: - required: true - multiline: false - schema: - type: string - - name: fileformat - description: - required: true - multiline: false - options: - - zip - - rar - - 7zip - - tar - - tar.gz - schema: - type: string - - name: password - description: - required: false - multiline: false - schema: - type: string - returns: - schema: - type: string - - name: inflate_archive - description: Compress files in archive, return archive's file id - parameters: - - name: file_ids - description: - required: true - multiline: true - schema: - type: string - - name: fileformat - description: - required: true - multiline: false - options: - - zip - - 7zip - schema: - type: string - - name: name - description: - required: false - multiline: false - schema: - type: string - - name: password - description: - required: false - multiline: false - schema: - type: string - returns: - schema: - type: string - - name: xml_json_convertor - description: Converts xml to json and vice versa - parameters: - - name: convertto - required: true - multiline: false - options: - - json - - xml - schema: - type: string - - name: data - description: - required: true - multiline: false - example: 'xml data / json data' - schema: - type: string - returns: - schema: - type: string - - name: date_to_epoch - description: Converts a date field with a given format to an epoch time - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: 2010-11-04T04:15:22.123Z - schema: - type: dict - - name: date_field - description: The field containing the date to parse - required: true - multiline: false - example: currentDateTime - schema: - type: string - - name: date_format - # yamllint disable-line rule:line-length - description: The datetime format of the field to parse (strftime format). - required: true - multiline: false - example: '%Y-%m-%dT%H:%M:%s.%f%Z' - schema: - type: string - returns: - schema: - type: dict - - name: compare_relative_date - # yamllint disable-line rule:line-length - description: Compares an input date to a relative date and returns a True/False result - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: 2010-11-04T04:15:22.123Z - schema: - type: string - - name: date_format - description: The format of the input date field (strftime format) - required: true - multiline: false - example: '%Y-%m-%dT%H:%M:%S.%f%Z' - options: - - '%Y-%m-%dT%H:%M%z' - - '%Y-%m-%dT%H:%M:%SZ' - - '%Y-%m-%dT%H:%M:%S%Z' - - '%Y-%m-%dT%H:%M:%S%z' - - '%Y-%m-%dT%H:%M:%S.%f%z' - - '%Y-%m-%d' - - '%H:%M:%S' - - '%s' - schema: - type: string - - name: equality_test - description: How to compare the input date and offset date - required: true - multiline: false - example: '>' - options: - - '>' - - '<' - - '=' - - '!=' - - '>=' - - '<=' - schema: - type: string - - name: offset - description: Numeric offset from current time - required: true - multiline: false - example: 60 - schema: - type: string - - name: units - description: The units of the provided value - required: true - multiline: false - example: 'seconds' - options: - - seconds - - minutes - - hours - - days - schema: - type: string - - name: direction - description: Whether the comparison should be in the past or future - required: true - multiline: false - example: 'ago' - options: - - ago - - ahead - schema: - type: string - returns: - schema: - type: strings - - name: add_list_to_list - description: Adds items of second list (list_two) to the first one (list_one) - parameters: - - name: list_one - description: The first list - multiline: true - example: "{'key': 'value'}" - required: true - schema: - type: string - - name: list_two - description: The second list to use - multiline: true - required: true - example: "{'key2': 'value2'}" - schema: - type: string - - name: merge_lists - description: Merges two lists of same type AND length. - parameters: - - name: list_one - description: The first list - multiline: true - example: "{'key': 'value'}" - required: true - schema: - type: string - - name: list_two - description: The second list to use - multiline: true - required: true - example: "{'key2': 'value2'}" - schema: - type: string - - name: set_field - description: If items in list 2 are strings, but first is JSON, sets the values to the specified key. Defaults to key "new_shuffle_key" - required: false - example: "json_key" - schema: - type: string - - name: sort_key_list_one - description: Sort by this key before using list one for merging - required: false - example: "json_key" - schema: - type: string - - name: sort_key_list_two - description: Sort by this key before using list two for merging - required: false - example: "json_key" - schema: - type: string - - name: diff_lists - description: Diffs two lists of strings or integers and finds what's missing - parameters: - - name: list_one - description: The first list - multiline: true - example: "{'key': 'value'}" - required: true - schema: - type: string - - name: list_two - description: The second list to use - multiline: true - required: true - example: "{'key2': 'value2'}" - schema: - type: string - - name: delete_json_keys - description: Deletes keys in a json object - parameters: - - name: json_object - description: The object to edit - multiline: true - example: "{'key': 'value', 'key2': 'value2', 'key3': 'value3'}" - required: true - schema: - type: string - - name: keys - description: The key(s) to remove - multiline: true - required: true - example: "key, key3" - schema: - type: string - - name: convert_json_to_tags - description: Creates key:value pairs and - parameters: - - name: json_object - description: The object to make into a key:value pair - multiline: true - example: "{'key': 'value', 'key2': 'value2', 'key3': 'value3'}" - required: true - schema: - type: string - - name: split_value - description: The way to split the values. Defaults to comma. - multiline: false - required: false - example: "," - schema: - type: string - - name: include_key - description: Whether it should include the key or not - options: - - true - - false - schema: - type: string - - name: lowercase - description: Whether it should be lowercase or not - options: - - true - - false - schema: - type: string - - name: run_math_operation - description: Takes a math input and gives you the result - parameters: - - name: operation - description: The operation to perform - required: true - multiline: true - example: "5+10" - schema: - type: string - returns: - schema: - type: string - - name: escape_html - description: Performs HTML escaping on a field - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: $exec.field1 - schema: - type: string - - name: field_name - description: The field to HTML escape - required: true - multiline: true - example: my_unsafe_field - schema: - type: string - returns: - schema: - type: string - - name: base64_conversion - description: Encode or decode a Base64 string - parameters: - - name: string - description: string to process - multiline: true - example: "This is a string to be encoded" - required: true - schema: - type: string - - name: operation - description: Choose to encode or decode the string - example: "encode" - required: true - options: - - encode - - decode - schema: - type: string - - name: cidr_ip_match - description: Check if an IP is contained in a CIDR defined network - parameters: - - name: ip - description: IP to check - multiline: false - example: "1.1.1.1" - required: True - schema: - type: string - - name: networks - description: List of network in CIDR format - multiline: true - required: true - example: "['10.0.0.0/8', '192.168.10.0/24']" - schema: - type: string - returns: - schema: - type: string - -# yamllint disable-line rule:line-length -large_image: data:image/png;base64,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 diff --git a/shuffle-tools/1.0.0/requirements.txt b/shuffle-tools/1.0.0/requirements.txt deleted file mode 100644 index 6b792a90..00000000 --- a/shuffle-tools/1.0.0/requirements.txt +++ /dev/null @@ -1,9 +0,0 @@ -ioc_finder==6.0.1 -py7zr==0.11.3 -rarfile==4.0 -pyminizip==0.2.4 -requests==2.25.1 -xmltodict==0.11.0 -json2xml==3.6.0 -ipaddress==1.0.23 -liquidpy==0.7.1 diff --git a/shuffle-tools/1.0.0/src/app.py b/shuffle-tools/1.0.0/src/app.py deleted file mode 100644 index 9a09e415..00000000 --- a/shuffle-tools/1.0.0/src/app.py +++ /dev/null @@ -1,1305 +0,0 @@ -import asyncio -import datetime -import json -import markupsafe -import os -import re -import subprocess -import tempfile -import zipfile -import base64 -import ipaddress - -import py7zr -import pyminizip -import rarfile -import requests -import tarfile - -import xmltodict -from json2xml import json2xml - -from json2xml.utils import readfromstring - -from ioc_finder import find_iocs -from walkoff_app_sdk.app_base import AppBase - - - - -class Tools(AppBase): - """ - An example of a Walkoff App. - Inherit from the AppBase class to have Redis, logging, and console - logging set up behind the scenes. - - """ - - __version__ = "1.0.0" - app_name = ( - "Shuffle Tools" # this needs to match "name" in api.yaml for WALKOFF to work - ) - - def __init__(self, redis, logger, console_logger=None): - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - def router(self): - return "This action should be skipped" - - def base64_conversion(self, string, operation): - - if operation == "encode": - encoded_bytes = base64.b64encode(string.encode("utf-8")) - encoded_string = str(encoded_bytes, "utf-8") - return encoded_string - - elif operation == "decode": - decoded_bytes = base64.b64decode(string.encode("utf-8")) - decoded_string = str(decoded_bytes, "utf-8") - return decoded_string - - # This is an SMS function of Shuffle - def send_sms_shuffle(self, apikey, phone_numbers, body): - targets = [phone_numbers] - if ", " in phone_numbers: - targets = phone_numbers.split(", ") - elif "," in phone_numbers: - targets = phone_numbers.split(",") - - data = {"numbers": targets, "body": body} - - url = "https://shuffler.io/api/v1/functions/sendsms" - headers = {"Authorization": "Bearer %s" % apikey} - return requests.post(url, headers=headers, json=data).text - - # This is an email function of Shuffle - def send_email_shuffle(self, apikey, recipients, subject, body): - targets = [recipients] - if ", " in recipients: - targets = recipients.split(", ") - elif "," in recipients: - targets = recipients.split(",") - - data = {"targets": targets, "body": body, "subject": subject, "type": "alert"} - - url = "https://shuffler.io/api/v1/functions/sendmail" - headers = {"Authorization": "Bearer %s" % apikey} - return requests.post(url, headers=headers, json=data).text - - def repeat_back_to_me(self, call): - return call - - # https://github.com/fhightower/ioc-finder - def parse_file_ioc(self, file_ids, input_type="all"): - def parse(data): - try: - iocs = find_iocs(str(data)) - newarray = [] - for key, value in iocs.items(): - if input_type != "all": - if key not in input_type: - continue - if len(value) > 0: - for item in value: - if isinstance(value, dict): - for subkey, subvalue in value.items(): - if len(subvalue) > 0: - for subitem in subvalue: - data = { - "data": subitem, - "data_type": "%s_%s" - % (key[:-1], subkey), - } - if data not in newarray: - newarray.append(data) - else: - data = {"data": item, "data_type": key[:-1]} - if data not in newarray: - newarray.append(data) - for item in newarray: - if "ip" in item["data_type"]: - item["data_type"] = "ip" - return {"success": True, "items": newarray} - except Exception as excp: - return {"success": False, "message": "{}".format(excp)} - - if input_type == "": - input_type = "all" - else: - input_type = input_type.split(",") - - try: - file_ids = eval(file_ids) # nosec - except SyntaxError: - file_ids = file_ids - except NameError: - file_ids = file_ids - - return_value = None - if type(file_ids) == str: - return_value = parse(self.get_file(file_ids)["data"]) - elif type(file_ids) == list and type(file_ids[0]) == str: - return_value = [ - parse(self.get_file(file_id)["data"]) for file_id in file_ids - ] - elif ( - type(file_ids) == list - and type(file_ids[0]) == list - and type(file_ids[0][0]) == str - ): - return_value = [ - [parse(self.get_file(file_id2)["data"]) for file_id2 in file_id] - for file_id in file_ids - ] - else: - return "Invalid input" - return return_value - - # https://github.com/fhightower/ioc-finder - def parse_ioc(self, input_string, input_type="all"): - if input_type == "": - input_type = "all" - else: - input_type = input_type.split(",") - - iocs = find_iocs(input_string) - newarray = [] - for key, value in iocs.items(): - if input_type != "all": - if key not in input_type: - continue - - if len(value) > 0: - for item in value: - # If in here: attack techniques. Shouldn't be 3 levels so no - # recursion necessary - if isinstance(value, dict): - for subkey, subvalue in value.items(): - if len(subvalue) > 0: - for subitem in subvalue: - data = { - "data": subitem, - "data_type": "%s_%s" % (key[:-1], subkey), - } - if data not in newarray: - newarray.append(data) - else: - data = {"data": item, "data_type": key[:-1]} - if data not in newarray: - newarray.append(data) - - # Reformatting IP - for item in newarray: - if "ip" in item["data_type"]: - item["data_type"] = "ip" - try: - item["is_private_ip"] = ipaddress.ip_address(item["data"]).is_private - except: - print("Error parsing %s" % ip) - pass - - try: - newarray = json.dumps(newarray) - except json.decoder.JSONDecodeError as e: - return "Failed to parse IOC's: %s" % e - - return newarray - - def parse_list(self, items, splitter="\n"): - if splitter == "": - splitter = "\n" - - splititems = items.split(splitter) - - return str(splititems) - - def get_length(self, item): - if item.startswith("[") and item.endswith("]"): - try: - item = item.replace("'", '"', -1) - item = json.loads(item) - except json.decoder.JSONDecodeError as e: - print("Parse error: %s" % e) - pass - - return str(len(item)) - - def delete_json_keys(self, json_object, keys): - splitdata = [keys] - if ", " in keys: - splitdata = keys.split(", ") - elif "," in keys: - splitdata = keys.split(",") - - for key in splitdata: - key = key.strip() - try: - del json_object[key] - except: - print("Key %s doesn't exist" % key) - - return json_object - - def translate_value(self, input_data, translate_from, translate_to, else_value=""): - splitdata = [translate_from] - if ", " in translate_from: - splitdata = translate_from.split(", ") - elif "," in translate_from: - splitdata = translate_from.split(",") - - if isinstance(input_data, list) or isinstance(input_data, dict): - input_data = json.dumps(input_data) - - to_return = input_data - if isinstance(input_data, str): - found = False - for item in splitdata: - item = item.strip() - if item in input_data: - input_data = input_data.replace(item, translate_to) - found = True - - if not found and len(else_value) > 0: - input_data = else_value - - if input_data.lower() == "false": - return False - elif input_data.lower() == "true": - return True - - return input_data - - def map_value(self, input_data, mapping): - - mapping = json.loads(mapping) - print(f"Got mapping {json.dumps(mapping, indent=2)}") - - # Get value if input_data in map, otherwise return original input_data - output_data = mapping.get(input_data, input_data) - print(f"Mapping {input_data} to {output_data}") - - return output_data - - def regex_replace( - self, input_data, regex, replace_string="", ignore_case="False" - ): - - print("=" * 80) - print(f"Regex: {regex}") - print(f"replace_string: {replace_string}") - print("=" * 80) - - if ignore_case.lower().strip() == "true": - return re.sub(regex, replace_string, input_data, flags=re.IGNORECASE) - else: - return re.sub(regex, replace_string, input_data) - - def execute_python(self, code, shuffle_input): - print("Run with shuffle_data %s" % shuffle_input) - print("And python code %s" % code) - # Write the code to a file, then jdjd - exec(code) # nosec - - # 1. Take the data into a file - # 2. Subprocess execute file? - - # May be necessary - # compile() - - return "Some return: %s" % shuffle_input - - def execute_bash(self, code, shuffle_input): - process = subprocess.Popen( - code, - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - text=True, - shell=True, # nosec - ) - stdout = process.communicate() - item = "" - if len(stdout[0]) > 0: - print("Succesfully ran bash!") - item = stdout[0] - else: - print("FAILED to run bash!") - item = stdout[1] - - try: - ret = item.decode("utf-8") - return ret - except Exception: - return item - - return item - - def filter_list(self, input_list, field, check, value, opposite): - print(f"\nRunning function with list {input_list}") - - flip = False - if opposite.lower() == "true": - flip = True - - try: - input_list = eval(input_list) # nosec - except Exception: - try: - input_list = input_list.replace("'", '"', -1) - input_list = json.loads(input_list) - except Exception: - print("Error parsing string to array. Continuing anyway.") - - # Workaround D: - if not isinstance(input_list, list): - return { - "success": False, - "reason": "Error: input isnt a list. Remove # to use this action." - % type(input_list), - "valid": [], - "invalid": [], - } - - input_list = [input_list] - - print("\nRunning with check \"%s\" on list of length %d\n" % (check, len(input_list))) - found_items = [] - new_list = [] - failed_list = [] - for item in input_list: - try: - try: - item = json.loads(item) - except Exception: - pass - - # Support for nested dict key - tmp = item - if field and field.strip() != "": - for subfield in field.split("."): - tmp = tmp[subfield] - - if isinstance(tmp, dict) or isinstance(tmp, list): - try: - tmp = json.dumps(tmp) - except json.decoder.JSONDecodeError as e: - print("FAILED DECODING: %s" % e) - pass - - #print("PRE CHECKS FOR TMP: %") - - # EQUALS JUST FOR STR - if check == "equals": - # Mostly for bools - # value = tmp.lower() - - if str(tmp).lower() == str(value).lower(): - print("APPENDED BECAUSE %s %s %s" % (field, check, value)) - if not flip: - new_list.append(item) - else: - failed_list.append(item) - else: - if flip: - new_list.append(item) - else: - failed_list.append(item) - - # IS EMPTY FOR STR OR LISTS - elif check == "is empty": - if tmp == "[]": - tmp = [] - - if type(tmp) == list and len(tmp) == 0 and not flip: - new_list.append(item) - elif type(tmp) == list and len(tmp) > 0 and flip: - new_list.append(item) - elif type(tmp) == str and not tmp and not flip: - new_list.append(item) - elif type(tmp) == str and tmp and flip: - new_list.append(item) - else: - failed_list.append(item) - - # STARTS WITH = FOR STR OR [0] FOR LIST - elif check == "starts with": - if type(tmp) == list and tmp[0] == value and not flip: - new_list.append(item) - elif type(tmp) == list and tmp[0] != value and flip: - new_list.append(item) - elif type(tmp) == str and tmp.startswith(value) and not flip: - new_list.append(item) - elif type(tmp) == str and not tmp.startswith(value) and flip: - new_list.append(item) - else: - failed_list.append(item) - - # ENDS WITH = FOR STR OR [-1] FOR LIST - elif check == "ends with": - if type(tmp) == list and tmp[-1] == value and not flip: - new_list.append(item) - elif type(tmp) == list and tmp[-1] != value and flip: - new_list.append(item) - elif type(tmp) == str and tmp.endswith(value) and not flip: - new_list.append(item) - elif type(tmp) == str and not tmp.endswith(value) and flip: - new_list.append(item) - else: - failed_list.append(item) - - # CONTAINS FIND FOR LIST AND IN FOR STR - elif check == "contains": - if type(tmp) == list and value.lower() in tmp and not flip: - new_list.append(item) - elif type(tmp) == list and value.lower() not in tmp and flip: - new_list.append(item) - elif ( - type(tmp) == str - and tmp.lower().find(value.lower()) != -1 - and not flip - ): - new_list.append(item) - elif ( - type(tmp) == str - and tmp.lower().find(value.lower()) == -1 - and flip - ): - new_list.append(item) - else: - failed_list.append(item) - elif check == "contains any of": - print("Inside contains any of") - checklist = value.split(",") - print("Checklist and tmp: %s - %s" % (checklist, tmp)) - found = False - for subcheck in checklist: - subcheck = subcheck.strip().lower() - #ext.lower().strip() == value.lower().strip() - if type(tmp) == list and subcheck in tmp and not flip: - new_list.append(item) - found = True - break - elif type(tmp) == list and subcheck not in tmp and flip: - new_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) != -1 and not flip): - new_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) == -1 and flip): - new_list.append(item) - found = True - break - - if not found: - failed_list.append(item) - - # CONTAINS FIND FOR LIST AND IN FOR STR - elif check == "field is unique": - #print("FOUND: %s" - if tmp.lower() not in found_items and not flip: - new_list.append(item) - found_items.append(tmp.lower()) - elif tmp.lower() in found_items and flip: - new_list.append(item) - found_items.append(tmp.lower()) - else: - failed_list.append(item) - - #tmp = json.dumps(tmp) - - #for item in new_list: - #if type(tmp) == list and value.lower() in tmp and not flip: - # new_list.append(item) - # found = True - # break - #elif type(tmp) == list and value.lower() not in tmp and flip: - # new_list.append(item) - # found = True - # break - - # CONTAINS FIND FOR LIST AND IN FOR STR - elif check == "contains any of": - checklist = value.split(",") - tmp = tmp.lower() - print("CHECKLIST: %s. Value: %s" % (checklist, tmp)) - found = False - for value in checklist: - if value in tmp and not flip: - new_list.append(item) - found = True - break - elif value not in tmp and flip: - new_list.append(item) - found = True - break - - if not found: - failed_list.append(item) - - elif check == "larger than": - if int(tmp) > int(value) and not flip: - new_list.append(item) - elif int(tmp) > int(value) and flip: - new_list.append(item) - else: - failed_list.append(item) - elif check == "less than": - if int(tmp) < int(value) and not flip: - new_list.append(item) - elif int(tmp) < int(value) and flip: - new_list.append(item) - else: - failed_list.append(item) - - # SINGLE ITEM COULD BE A FILE OR A LIST OF FILES - elif check == "files by extension": - if type(tmp) == list: - file_list = [] - - for file_id in tmp: - filedata = self.get_file(file_id) - _, ext = os.path.splitext(filedata["filename"]) - if ( - ext.lower().strip() == value.lower().strip() - and not flip - ): - file_list.append(file_id) - elif ext.lower().strip() != value.lower().strip() and flip: - file_list.append(file_id) - # else: - # failed_list.append(file_id) - - tmp = item - if field and field.strip() != "": - for subfield in field.split(".")[:-1]: - tmp = tmp[subfield] - tmp[field.split(".")[-1]] = file_list - new_list.append(item) - else: - new_list = file_list - # else: - # failed_list = file_list - - elif type(tmp) == str: - filedata = self.get_file(tmp) - _, ext = os.path.splitext(filedata["filename"]) - if ext.lower().strip() == value.lower().strip() and not flip: - new_list.append(item) - elif ext.lower().strip() != value.lower().strip() and flip: - new_list.append((item, ext)) - else: - failed_list.append(item) - - except Exception as e: - # "Error: %s" % e - print("[WARNING] FAILED WITH EXCEPTION: %s" % e) - failed_list.append(item) - # return - - try: - return json.dumps( - { - "success": True, - "valid": new_list, - "invalid": failed_list, - } - ) - # new_list = json.dumps(new_list) - except json.decoder.JSONDecodeError as e: - return json.dumps( - { - "success": False, - "reason": "Failed parsing filter list output" + e, - } - ) - - return new_list - - #def multi_list_filter(self, input_list, field, check, value): - # input_list = input_list.replace("'", '"', -1) - # input_list = json.loads(input_list) - - # fieldsplit = field.split(",") - # if ", " in field: - # fieldsplit = field.split(", ") - - # valuesplit = value.split(",") - # if ", " in value: - # valuesplit = value.split(", ") - - # checksplit = check.split(",") - # if ", " in check: - # checksplit = check.split(", ") - - # new_list = [] - # for list_item in input_list: - # list_item = json.loads(list_item) - - # index = 0 - # for check in checksplit: - # if check == "equals": - # print( - # "Checking %s vs %s" - # % (list_item[fieldsplit[index]], valuesplit[index]) - # ) - # if list_item[fieldsplit[index]] == valuesplit[index]: - # new_list.append(list_item) - - # index += 1 - - # # "=", - # # "equals", - # # "!=", - # # "does not equal", - # # ">", - # # "larger than", - # # "<", - # # "less than", - # # ">=", - # # "<=", - # # "startswith", - # # "endswith", - # # "contains", - # # "re", - # # "matches regex", - - # try: - # new_list = json.dumps(new_list) - # except json.decoder.JSONDecodeError as e: - # return "Failed parsing filter list output" % e - - # return new_list - - # Gets the file's metadata, e.g. md5 - def get_file_meta(self, file_id): - headers = { - "Authorization": "Bearer %s" % self.authorization, - } - - ret = requests.get( - "%s/api/v1/files/%s?execution_id=%s" - % (self.url, file_id, self.current_execution_id), - headers=headers, - ) - print(f"RET: {ret}") - - return ret.text - - # Use data from AppBase to talk to backend - def delete_file(self, file_id): - headers = { - "Authorization": "Bearer %s" % self.authorization, - } - print("HEADERS: %s" % headers) - - ret = requests.delete( - "%s/api/v1/files/%s?execution_id=%s" - % (self.url, file_id, self.current_execution_id), - headers=headers, - ) - return ret.text - - def get_file_value(self, filedata): - if filedata is None: - return "File is empty?" - - print("INSIDE APP DATA: %s" % filedata) - return "%s" % filedata["data"].decode() - - def download_remote_file(self, url): - ret = requests.get(url, verify=False) # nosec - filename = url.split("/")[-1] - fileret = self.set_files( - [ - { - "filename": filename, - "data": ret.content, - } - ] - ) - - if len(fileret) > 0: - value = {"success": True, "file_id": fileret[0]} - else: - value = {"success": False, "reason": "No files downloaded"} - - return value - - def extract_archive(self, file_ids, fileformat="zip", password=None): - try: - return_data = {"success": False, "files": []} - - try: - file_ids = eval(file_ids) # nosec - except SyntaxError: - file_ids = file_ids - - print("IDS: %s" % file_ids) - items = file_ids if type(file_ids) == list else file_ids.split(",") - for file_id in items: - - item = self.get_file(file_id) - return_ids = None - - print("Working with fileformat %s" % fileformat) - with tempfile.TemporaryDirectory() as tmpdirname: - - # Get archive and save phisically - with open(os.path.join(tmpdirname, "archive"), "wb") as f: - f.write(item["data"]) - - # Grab files before, upload them later - to_be_uploaded = [] - - # Zipfile for zipped archive - if fileformat.strip().lower() == "zip": - try: - with zipfile.ZipFile( - os.path.join(tmpdirname, "archive") - ) as z_file: - if password: - z_file.setpassword(bytes(password.encode())) - for member in z_file.namelist(): - filename = os.path.basename(member) - if not filename: - continue - source = z_file.open(member) - to_be_uploaded.append( - {"filename": source.name, "data": source.read()} - ) - return_data["success"] = True - except (zipfile.BadZipFile, Exception): - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": "File is not a valid zip archive", - } - ) - - continue - - elif fileformat.strip().lower() == "rar": - try: - with rarfile.RarFile( - os.path.join(tmpdirname, "archive") - ) as z_file: - if password: - z_file.setpassword(password) - for member in z_file.namelist(): - filename = os.path.basename(member) - if not filename: - continue - source = z_file.open(member) - to_be_uploaded.append( - {"filename": source.name, "data": source.read()} - ) - return_data["success"] = True - except Exception: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": "File is not a valid rar archive", - } - ) - continue - - elif fileformat.strip().lower() == "tar": - try: - with tarfile.open( - os.path.join(tmpdirname, "archive"), mode="r" - ) as z_file: - for member in z_file.getnames(): - member_files = z_file.extractfile(member) - to_be_uploaded.append( - { - "filename": member, - "data": member_files.read(), - } - ) - return_data["success"] = True - except Exception as e: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": e, - } - ) - continue - elif fileformat.strip().lower() == "tar.gz": - try: - with tarfile.open( - os.path.join(tmpdirname, "archive"), mode="r:gz" - ) as z_file: - for member in z_file.getnames(): - member_files = z_file.extractfile(member) - to_be_uploaded.append( - { - "filename": member, - "data": member_files.read(), - } - ) - return_data["success"] = True - except Exception as e: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": e, - } - ) - continue - - elif fileformat.strip().lower() == "7zip": - try: - with py7zr.SevenZipFile( - os.path.join(tmpdirname, "archive"), - mode="r", - password=password if password else None, - ) as z_file: - for filename, source in z_file.readall().items(): - # Removes paths - filename = filename.split("/")[-1] - to_be_uploaded.append( - { - "filename": item["filename"], - "data": source.read(), - } - ) - return_data["success"] = True - except Exception: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": "File is not a valid 7zip archive", - } - ) - continue - else: - return "No such format: %s" % fileformat - - if len(to_be_uploaded) > 0: - return_ids = self.set_files(to_be_uploaded) - return_data["files"].append( - { - "success": True, - "file_id": file_id, - "filename": item["filename"], - "file_ids": return_ids, - } - ) - else: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": "Archive is empty", - } - ) - - return return_data - - except Exception as excp: - return {"success": False, "message": "%s" % excp} - - def inflate_archive(self, file_ids, fileformat, name, password=None): - - try: - # TODO: will in future support multiple files instead of string ids? - file_ids = file_ids.split() - print("picking {}".format(file_ids)) - - # GET all items from shuffle - items = [self.get_file(file_id) for file_id in file_ids] - - if len(items) == 0: - return "No file to inflate" - - # Dump files on disk, because libs want path :( - with tempfile.TemporaryDirectory() as tmpdir: - paths = [] - print("Number 1") - for item in items: - with open(os.path.join(tmpdir, item["filename"]), "wb") as f: - f.write(item["data"]) - paths.append(os.path.join(tmpdir, item["filename"])) - - # Create archive temporary - print("{} items to inflate".format(len(items))) - with tempfile.NamedTemporaryFile() as archive: - - if fileformat == "zip": - archive_name = "archive.zip" if not name else name - pyminizip.compress_multiple( - paths, [], archive.name, password, 5 - ) - - elif fileformat == "7zip": - archive_name = "archive.7z" if not name else name - with py7zr.SevenZipFile( - archive.name, - "w", - password=password if len(password) > 0 else None, - ) as sz_archive: - for path in paths: - sz_archive.write(path) - - else: - return "Format {} not supported".format(fileformat) - - return_id = self.set_files( - [{"filename": archive_name, "data": open(archive.name, "rb")}] - ) - - if len(return_id) == 1: - # Returns the first file's ID - return {"success": True, "id": return_id[0]} - else: - return { - "success": False, - "message": "Upload archive returned {}".format(return_id), - } - - except Exception as excp: - return {"success": False, "message": excp} - - def add_list_to_list(self, list_one, list_two): - try: - list_one = json.loads(list_one) - except json.decoder.JSONDecodeError as e: - print("Failed to parse list1 as json: %s" % e) - return "List one is not a valid list: %s" % list_one - - try: - list_two = json.loads(list_two) - except json.decoder.JSONDecodeError as e: - print("Failed to parse list2 as json: %s" % e) - return "List two is not a valid list: %s" % list_two - - for item in list_two: - list_one.append(item) - - return list_one - - def diff_lists(self, list_one, list_two): - try: - list_one = json.loads(list_one) - except json.decoder.JSONDecodeError as e: - print("Failed to parse list1 as json: %s" % e) - - try: - list_two = json.loads(list_two) - except json.decoder.JSONDecodeError as e: - print("Failed to parse list2 as json: %s" % e) - - def diff(li1, li2): - return list(set(li1) - set(li2)) + list(set(li2) - set(li1)) - - return diff(list_one, list_two) - - def merge_lists(self, list_one, list_two, set_field="", sort_key_list_one="", sort_key_list_two=""): - try: - list_one = json.loads(list_one) - except json.decoder.JSONDecodeError as e: - print("Failed to parse list1 as json: %s" % e) - - try: - list_two = json.loads(list_two) - except json.decoder.JSONDecodeError as e: - print("Failed to parse list2 as json: %s" % e) - - if len(list_one) != len(list_two): - return {"success": False, "message": "Lists length must be the same. %d vs %d" % (len(list_one), len(list_two))} - - #result = json.loads(input_data) - print(list_one) - print(list_two) - print(set_field) - print("START: ") - - if len(sort_key_list_one) > 0: - print("Sort 1 %s by key: %s" % (list_one, sort_key_list_one)) - try: - list_one = sorted(list_one, key=lambda k: k.get(sort_key_list_one), reverse=True) - except: - print("Failed to sort list one") - pass - - if len(sort_key_list_two) > 0: - #print("Sort 2 %s by key: %s" % (list_two, sort_key_list_two)) - try: - list_two = sorted(list_two, key=lambda k: k.get(sort_key_list_two), reverse=True) - except: - print("Failed to sort list one") - pass - - for i in range(len(list_one)): - #print(list_two[i]) - if isinstance(list_two[i], dict): - for key, value in list_two[i].items(): - list_one[i][key] = value - elif isinstance(list_two[i], str) or isinstance(list_two[i], int) or isinstance(list_two[i], bool): - print("IN SETTER FOR %s" % list_two[i]) - if len(set_field) == 0: - return "Define a JSON key to set for List two (Set Field)" - - list_one[i][set_field] = list_two[i] - - return list_one - - def xml_json_convertor(self, convertto, data): - try: - if convertto == "json": - ans = xmltodict.parse(data) - json_data = json.dumps(ans) - return json_data - else: - ans = readfromstring(data) - return json2xml.Json2xml(ans, wrapper="all", pretty=True).to_xml() - except Exception as e: - return e - - def date_to_epoch(self, input_data, date_field, date_format): - - print( - "Executing with {} on {} with format {}".format( - input_data, date_field, date_format - ) - ) - - result = json.loads(input_data) - - # https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior - epoch = datetime.datetime.strptime(result[date_field], date_format).strftime( - "%s" - ) - result["epoch"] = epoch - return result - - def compare_relative_date( - self, input_data, date_format, equality_test, offset, units, direction - ): - - if input_data == "None": - return False - - print("Converting input date.") - - if date_format != "%s": - input_dt = datetime.datetime.strptime(input_data, date_format) - else: - input_dt = datetime.datetime.utcfromtimestamp(float(input_data)) - - offset = int(offset) - if units == "seconds": - delta = datetime.timedelta(seconds=offset) - elif units == "minutes": - delta = datetime.timedelta(minutes=offset) - elif units == "hours": - delta = datetime.timedelta(hours=offset) - elif units == "days": - delta = datetime.timedelta(days=offset) - - utc_format = date_format - if utc_format.endswith("%z"): - utc_format = utc_format.replace("%z", "Z") - - if date_format != "%s": - formatted_dt = datetime.datetime.strptime( - datetime.datetime.utcnow().strftime(utc_format), date_format - ) - else: - formatted_dt = datetime.datetime.utcnow() - - print("Formatted time is: {}".format(formatted_dt)) - if direction == "ago": - comparison_dt = formatted_dt - delta - else: - comparison_dt = formatted_dt + delta - print("{} {} {} is {}".format(offset, units, direction, comparison_dt)) - - diff = (input_dt - comparison_dt).total_seconds() - print( - "Difference between {} and {} is {}".format(input_data, comparison_dt, diff) - ) - result = False - if equality_test == ">": - result = 0 > diff - if direction == "ahead": - result = not (result) - elif equality_test == "<": - result = 0 < diff - if direction == "ahead": - result = not (result) - elif equality_test == "=": - result = diff == 0 - elif equality_test == "!=": - result = diff != 0 - elif equality_test == ">=": - result = 0 >= diff - if direction == "ahead" and diff != 0: - result = not (result) - elif equality_test == "<=": - result = 0 <= diff - if direction == "ahead" and diff != 0: - result = not (result) - - print( - "At {}, is {} {} than {} {} {}? {}".format( - formatted_dt, - input_data, - equality_test, - offset, - units, - direction, - result, - ) - ) - - return result - - def run_math_operation(self, operation): - print("Operation: %s" % operation) - result = eval(operation) - return result - - def escape_html(self, input_data, field_name): - - mapping = json.loads(input_data) - print(f"Got mapping {json.dumps(mapping, indent=2)}") - - result = markupsafe.escape(mapping[field_name]) - print(f"Mapping {input_data} to {result}") - - mapping[field_name] = result - return mapping - - def get_cache_value(self, key): - org_id = self.full_execution["workflow"]["execution_org"]["id"] - url = "%s/api/v1/orgs/%s/get_cache" % (self.url, org_id) - data = { - "workflow_id": self.full_execution["workflow"]["id"], - "execution_id": self.current_execution_id, - "authorization": self.authorization, - "org_id": org_id, - "key": key, - } - - value = requests.post(url, json=data) - try: - allvalues = value.json() - print("VAL1: ", allvalues) - allvalues["key"] = key - print("VAL2: ", allvalues) - - try: - parsedvalue = json.loads(allvalues["value"]) - allvalues["value"] = parsedvalue - except: - print("Parsing of value as JSON failed") - pass - - return json.dumps(allvalues) - except: - print("Value couldn't be parsed, or json dump of value failed") - return value.text - - # FIXME: Add option for org only & sensitive data (not to be listed) - def set_cache_value(self, key, value): - org_id = self.full_execution["workflow"]["execution_org"]["id"] - url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) - data = { - "workflow_id": self.full_execution["workflow"]["id"], - "execution_id": self.current_execution_id, - "authorization": self.authorization, - "org_id": org_id, - "key": key, - "value": str(value), - } - - response = requests.post(url, json=data) - try: - allvalues = response.json() - allvalues["key"] = key - allvalues["value"] = str(value) - return json.dumps(allvalues) - except: - print("Value couldn't be parsed") - return response.text - - def convert_json_to_tags(self, json_object, split_value=", ", include_key=True, lowercase=True): - try: - json_object = json.loads(json_object) - except json.decoder.JSONDecodeError as e: - print("Failed to parse list2 as json: %s. Type: %s" % (e, type(json_object))) - - if isinstance(lowercase, str) and lowercase.lower() == "true": - lowercase = True - else: - lowercase = False - - if isinstance(include_key, str) or include_key.lower() == "true": - include_key = True - else: - include_key = False - - parsedstring = [] - for key, value in json_object.items(): - print("KV: %s:%s" % (key, value)) - if isinstance(value, str) or isinstance(value, int) or isinstance(value, bool): - if include_key == True: - parsedstring.append("%s:%s" % (key, value)) - else: - parsedstring.append("%s" % (value)) - else: - print("Can't handle type %s" % type(value)) - - fullstring = split_value.join(parsedstring) - if lowercase == True: - fullstring = fullstring.lower() - - return fullstring - - def cidr_ip_match(self, ip, networks): - print("Executing with\nIP: {},\nNetworks: {}".format(ip, networks)) - - try: - networks = json.loads(networks) - except json.decoder.JSONDecodeError as e: - print("Failed to parse networks list as json: {}. Type: {}".format( - e, type(networks) - )) - return "Networks is not a valid list: {}".format(networks) - - try: - ip_networks = list(map(ipaddress.ip_network, networks)) - ip_address = ipaddress.ip_address(ip) - except ValueError as e: - return "IP or some networks are not in valid format.\nError: {}".format(e) - - matched_networks = list(filter(lambda net: (ip_address in net), ip_networks)) - - result = {} - result['networks'] = list(map(str, matched_networks)) - result['is_contained'] = True if len(result['networks']) > 0 else False - - return json.dumps(result) - -if __name__ == "__main__": - Tools.run() diff --git a/shuffle-tools/1.1.0/api.yaml b/shuffle-tools/1.1.0/api.yaml deleted file mode 100644 index 9b59f2e2..00000000 --- a/shuffle-tools/1.1.0/api.yaml +++ /dev/null @@ -1,951 +0,0 @@ ---- -app_version: 1.1.0 -name: Shuffle Tools -description: A tool app for Shuffle. Gives access to most missing features along with Liquid. -tags: - - Testing - - Shuffle -categories: - - Testing - - Shuffle -contact_info: - name: "@frikkylikeme" - url: https://shuffler.io - email: frikky@shuffler.io -actions: - - name: repeat_back_to_me - description: Repeats the call parameter - parameters: - - name: call - description: The message to repeat - required: true - multiline: true - example: "REPEATING: Hello world" - schema: - type: string - returns: - schema: - type: string - - name: router - description: Reroutes information between different nodes - returns: - schema: - type: string - - name: check_cache_contains - description: Checks Shuffle cache whether a user-provided key contains a value. Returns ALL the values previously appended. - parameters: - - name: key - description: The key to get - required: true - multiline: false - example: "alert_ids" - schema: - type: string - - name: value - description: The value to check for and append if applicable - required: true - multiline: false - example: "1208301599081" - schema: - type: string - - name: append - description: Whether to auto-append the value if it doesn't exist in the cache - required: true - options: - - true - - false - multiline: false - example: "timestamp" - schema: - type: string - - name: get_cache_value - description: Get a value saved to your organization in Shuffle - parameters: - - name: key - description: The key to get - required: true - multiline: false - example: "timestamp" - schema: - type: string - returns: - schema: - type: string - - name: set_cache_value - description: Set a value to be saved to your organization in Shuffle. - parameters: - - name: key - description: The key to set the value for - required: true - multiline: false - example: "timestamp" - schema: - type: string - - name: value - description: The value to set - required: true - multiline: true - example: "1621959545" - schema: - type: string - returns: - schema: - type: string - - name: send_sms_shuffle - description: Send an SMS from Shuffle - parameters: - - name: apikey - description: Your https://shuffler.io organization apikey - multiline: false - example: "https://shuffler.io apikey" - required: true - schema: - type: string - - name: phone_numbers - description: The receivers of the SMS - multiline: false - example: "+4741323535,+8151023022" - required: true - schema: - type: string - - name: body - description: The SMS to add to the numbers - multiline: true - example: "This is an alert from Shuffle :)" - required: true - schema: - type: string - returns: - schema: - type: string - - name: send_email_shuffle - description: Send an email from Shuffle - parameters: - - name: apikey - description: Your https://shuffler.io organization apikey - multiline: false - example: "https://shuffler.io apikey" - required: true - schema: - type: string - - name: recipients - description: The recipients of the email - multiline: false - example: "test@example.com,frikky@shuffler.io" - required: true - schema: - type: string - - name: subject - description: The subject to use - multiline: false - example: "SOS this is an alert :o" - required: true - schema: - type: string - - name: body - description: The body to add to the email - multiline: true - example: "This is an email alert from Shuffler.io :)" - required: true - schema: - type: string - - name: attachments - description: The ID of files in Shuffle to add as attachments - multiline: true - example: "file_id1,file_id2,file_id3" - required: false - schema: - type: string - returns: - schema: - type: string - - name: filter_list - description: Takes a list and filters based on your data - skip_multicheck: true - parameters: - - name: input_list - description: The list to check - required: true - multiline: false - example: '[{"data": "1.2.3.4"}, {"data": "1.2.3.5"}]' - schema: - type: string - - name: field - description: The field to check - required: false - multiline: false - example: "data" - schema: - type: string - - name: check - description: Type of check - required: true - example: "equals" - options: - - equals - - 'larger than' - - 'less than' - - is empty - - contains - - contains any of - - starts with - - ends with - - field is unique - - files by extension - schema: - type: string - - name: value - description: The value to check with - required: false - multiline: false - example: "1.2.3.4" - schema: - type: string - - name: opposite - description: Whether to add or to NOT add - required: true - options: - - False - - True - multiline: false - example: "false" - schema: - type: string - returns: - schema: - type: string - #- name: multi_list_filter - # description: Takes a list and filters based on your data - # skip_multicheck: true - # parameters: - # - name: input_list - # description: The list to check - # required: true - # multiline: false - # example: '[{"data": "1.2.3.4"}, {"data": "1.2.3.5"}]' - # schema: - # type: string - # - name: field - # description: The field to check - # required: true - # multiline: false - # example: "data" - # schema: - # type: string - # - name: check - # description: Type of check - # required: true - # example: "equals,equals" - # schema: - # type: string - # - name: value - # description: The value to check with - # required: true - # multiline: false - # example: "1.2.3.4" - # schema: - # type: string - # returns: - # schema: - # type: string - - name: parse_ioc - description: Parse IOC's based on https://github.com/fhightower/ioc-finder - parameters: - - name: input_string - description: The string to check - required: true - multiline: true - example: "123ijq192.168.3.6kljqwiejs8 https://shuffler.io" - schema: - type: string - - name: input_type - description: The string to check - required: false - multiline: false - example: "md5s" - schema: - type: string - returns: - schema: - type: string - - name: parse_file_ioc - description: Parse IOC's based on https://github.com/fhightower/ioc-finder - parameters: - - name: file_ids - description: The shuffle file to check - required: true - multiline: false - schema: - type: string - - name: input_type - description: The string to check - required: false - multiline: false - example: "md5s" - schema: - type: string - returns: - schema: - type: string - - name: translate_value - description: Takes a list of values and translates it in your input data - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: Hello this is an md5 - schema: - type: string - - name: translate_from - description: The source items to look for - required: true - multiline: false - example: sha256,md5,sha1 - schema: - type: string - - name: translate_to - description: The destination data to change to - required: true - multiline: true - example: hash - schema: - type: string - - name: else_value - description: The value to set if it DOESNT match. Default to nothing. - required: false - multiline: false - example: - schema: - type: string - returns: - returns: - schema: - type: string - - name: map_value - description: Takes a mapping dictionary and translates the input data. This is a search and replace for multiple fields. - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: $exec.field1 - schema: - type: string - - name: mapping - description: The mapping dictionary - required: true - multiline: true - example: | - { - "Low": 1, - "Medium": 2, - "High": 3, - } - schema: - type: string - returns: - schema: - type: string - - name: regex_capture_group - description: Returns objects matching the capture group(s) - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: This is some text a domain that is with.com - schema: - type: string - - name: regex - description: Your regular expression - multiline: false - example: "some text <[a-zA-Z0-9.]+> a domain" - required: true - schema: - type: string - returns: - schema: - type: string - - name: regex_replace - description: Replace all instances matching a regular expression - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: This is some text a domain that is with.com - schema: - type: string - - name: regex - description: Your regular expression - multiline: false - example: "some text <[a-zA-Z0-9.]+> a domain" - required: true - schema: - type: string - - name: replace_string - description: Replacement string (capture groups with \1 \2) - multiline: true - example: "some text a domain" - required: false - schema: - type: string - - name: ignore_case - description: "Make regex case insensitive (Default: False)" - multiline: false - options: - - false - - true - example: "False" - required: false - schema: - type: string - returns: - schema: - type: string - - name: parse_list - description: Parses a list and returns it as a json object - parameters: - - name: items - description: List of items - required: true - multiline: true - example: shuffler.io,test.com,test.no - schema: - type: string - - name: splitter - description: The splitter to use - required: false - multiline: false - example: "," - schema: - type: string - returns: - schema: - type: string - - name: execute_bash - description: Runs bash with the data input - parameters: - - name: code - description: The code to run - required: true - multiline: true - example: echo "Hello" - schema: - type: string - - name: shuffle_input - description: Alternative data to add - required: false - multiline: true - example: '{"data": "Hello world"}' - schema: - type: string - - name: execute_python - description: Runs python with the data input. Any prints will be returned. - parameters: - - name: code - description: The code to run. Can be a file ID from within Shuffle. - required: true - multiline: true - example: print("hello world") - schema: - type: string - - name: get_file_value - description: This function is made for reading file(s), printing their data - parameters: - - name: filedata - description: The files - required: true - multiline: false - example: "a2f89576-a9ec-479e-8c83-da69f468c90a" - schema: - type: string - returns: - schema: - type: string - - name: create_file - description: Returns uploaded file data - parameters: - - name: filename - description: - required: true - multiline: false - example: "test.csv" - schema: - type: string - - name: data - description: - required: true - multiline: true - example: "EventID,username\n4137,frikky" - schema: - type: string - - name: download_remote_file - description: Downloads a file from a URL - parameters: - - name: url - description: - required: true - multiline: false - example: "https://secure.eicar.org/eicar.com.txt" - schema: - type: string - returns: - schema: - type: string - - name: get_file_meta - description: Gets the file meta - parameters: - - name: file_id - description: - required: true - multiline: false - example: "" - schema: - type: string - returns: - schema: - type: string - - name: delete_file - description: Deletes a file based on ID - parameters: - - name: file_id - description: - required: true - multiline: false - example: "Some data to put in the file" - schema: - type: string - returns: - schema: - type: string - - name: extract_archive - description: Extract compressed files, return file ids - parameters: - - name: file_ids - description: - required: true - multiline: false - schema: - type: string - - name: fileformat - description: - required: true - multiline: false - options: - - zip - - rar - - 7zip - - tar - - tar.gz - schema: - type: string - - name: password - description: - required: false - multiline: false - schema: - type: string - returns: - schema: - type: string - - name: inflate_archive - description: Compress files in archive, return archive's file id - parameters: - - name: file_ids - description: - required: true - multiline: true - schema: - type: string - - name: fileformat - description: - required: true - multiline: false - options: - - zip - - 7zip - schema: - type: string - - name: name - description: - required: false - multiline: false - schema: - type: string - - name: password - description: - required: false - multiline: false - schema: - type: string - returns: - schema: - type: string - - name: xml_json_convertor - description: Converts xml to json and vice versa - parameters: - - name: convertto - required: true - multiline: false - options: - - json - - xml - schema: - type: string - - name: data - description: - required: true - multiline: false - example: 'xml data / json data' - schema: - type: string - returns: - schema: - type: string - - name: date_to_epoch - description: Converts a date field with a given format to an epoch time - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: 2010-11-04T04:15:22.123Z - schema: - type: dict - - name: date_field - description: The field containing the date to parse - required: true - multiline: false - example: currentDateTime - schema: - type: string - - name: date_format - # yamllint disable-line rule:line-length - description: The datetime format of the field to parse (strftime format). - required: true - multiline: false - example: '%Y-%m-%dT%H:%M:%s.%f%Z' - schema: - type: string - returns: - schema: - type: dict - - name: compare_relative_date - # yamllint disable-line rule:line-length - description: Compares an input date to a relative date and returns a True/False result - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: 2010-11-04T04:15:22.123Z - schema: - type: string - - name: date_format - description: The format of the input date field (strftime format) - required: true - multiline: false - example: '%Y-%m-%dT%H:%M:%S.%f%Z' - options: - - '%Y-%m-%dT%H:%M%z' - - '%Y-%m-%dT%H:%M:%SZ' - - '%Y-%m-%dT%H:%M:%S%Z' - - '%Y-%m-%dT%H:%M:%S%z' - - '%Y-%m-%dT%H:%M:%S.%f%z' - - '%Y-%m-%d' - - '%H:%M:%S' - - '%s' - schema: - type: string - - name: equality_test - description: How to compare the input date and offset date - required: true - multiline: false - example: '>' - options: - - '>' - - '<' - - '=' - - '!=' - - '>=' - - '<=' - schema: - type: string - - name: offset - description: Numeric offset from current time - required: true - multiline: false - example: 60 - schema: - type: string - - name: units - description: The units of the provided value - required: true - multiline: false - example: 'seconds' - options: - - seconds - - minutes - - hours - - days - schema: - type: string - - name: direction - description: Whether the comparison should be in the past or future - required: true - multiline: false - example: 'ago' - options: - - ago - - ahead - schema: - type: string - returns: - schema: - type: strings - - name: add_list_to_list - description: Adds items of second list (list_two) to the first one (list_one). Can also append a single item (dict) to a list. - parameters: - - name: list_one - description: The first list - multiline: true - example: "{'key': 'value'}" - required: true - schema: - type: string - - name: list_two - description: The second list to use - multiline: true - required: true - example: "{'key2': 'value2'}" - schema: - type: string - - name: merge_lists - description: Merges two lists of same type AND length. - parameters: - - name: list_one - description: The first list - multiline: true - example: "{'key': 'value'}" - required: true - schema: - type: string - - name: list_two - description: The second list to use - multiline: true - required: true - example: "{'key2': 'value2'}" - schema: - type: string - - name: set_field - description: If items in list 2 are strings, but first is JSON, sets the values to the specified key. Defaults to key "new_shuffle_key" - required: false - example: "json_key" - schema: - type: string - - name: sort_key_list_one - description: Sort by this key before using list one for merging - required: false - example: "json_key" - schema: - type: string - - name: sort_key_list_two - description: Sort by this key before using list two for merging - required: false - example: "json_key" - schema: - type: string - - name: diff_lists - description: Diffs two lists of strings or integers and finds what's missing - parameters: - - name: list_one - description: The first list - multiline: true - example: "{'key': 'value'}" - required: true - schema: - type: string - - name: list_two - description: The second list to use - multiline: true - required: true - example: "{'key2': 'value2'}" - schema: - type: string - - name: set_json_key - description: Adds a JSON key to an existing object - parameters: - - name: json_object - description: The object to edit - multiline: true - example: "recipients" - required: true - schema: - type: string - - name: key - description: The object to add - multiline: false - example: "recipients" - required: true - schema: - type: string - - name: value - description: The value to set it to in the JSON object - multiline: true - required: true - example: "frikky@shuffler.io" - schema: - type: string - - name: delete_json_keys - description: Deletes keys in a json object - parameters: - - name: json_object - description: The object to edit - multiline: true - example: "{'key': 'value', 'key2': 'value2', 'key3': 'value3'}" - required: true - schema: - type: string - - name: keys - description: The key(s) to remove - multiline: true - required: true - example: "key, key3" - schema: - type: string - - name: convert_json_to_tags - description: Creates key:value pairs and - parameters: - - name: json_object - description: The object to make into a key:value pair - multiline: true - example: "{'key': 'value', 'key2': 'value2', 'key3': 'value3'}" - required: true - schema: - type: string - - name: split_value - description: The way to split the values. Defaults to comma. - multiline: false - required: false - example: "," - schema: - type: string - - name: include_key - description: Whether it should include the key or not - options: - - true - - false - schema: - type: string - - name: lowercase - description: Whether it should be lowercase or not - options: - - true - - false - schema: - type: string - - name: run_math_operation - description: Takes a math input and gives you the result - parameters: - - name: operation - description: The operation to perform - required: true - multiline: true - example: "5+10" - schema: - type: string - returns: - schema: - type: string - - name: escape_html - description: Performs HTML escaping on a field - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: $exec.field1 - schema: - type: string - - name: field_name - description: The field to HTML escape - required: true - multiline: true - example: my_unsafe_field - schema: - type: string - returns: - schema: - type: string - - name: base64_conversion - description: Encode or decode a Base64 string - parameters: - - name: string - description: string to process - multiline: true - example: "This is a string to be encoded" - required: true - schema: - type: string - - name: operation - description: Choose to encode or decode the string - example: "encode" - required: true - options: - - encode - - decode - schema: - type: string - - name: get_timestamp - description: Gets a timestamp for right now. Default returns an epoch timestamp - parameters: - - name: time_format - description: The format to use - multiline: false - required: True - options: - - epoch - - unix - schema: - type: string - returns: - schema: - type: string - - name: get_hash_sum - description: Returns multiple formats of hashes based on the input value - parameters: - - name: value - description: The value to hash - multiline: false - example: "1.1.1.1" - required: True - schema: - type: string - returns: - schema: - type: string - - name: cidr_ip_match - description: Check if an IP is contained in a CIDR defined network - parameters: - - name: ip - description: IP to check - multiline: false - example: "1.1.1.1" - required: True - schema: - type: string - - name: networks - description: List of network in CIDR format - multiline: true - required: true - example: "['10.0.0.0/8', '192.168.10.0/24']" - schema: - type: string - returns: - schema: - type: string - -# yamllint disable-line rule:line-length -large_image: data:image/png;base64,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 diff --git a/shuffle-tools/1.1.0/docker-compose.yml b/shuffle-tools/1.1.0/docker-compose.yml deleted file mode 100644 index e48c6b2f..00000000 --- a/shuffle-tools/1.1.0/docker-compose.yml +++ /dev/null @@ -1,15 +0,0 @@ -version: '3.4' -services: - shuffle-tools: - build: - context: . - dockerfile: Dockerfile -# image: walkoff_registry:5000/walkoff_app_HelloWorld-v1-0 - deploy: - mode: replicated - replicas: 10 - restart_policy: - condition: none - restart: "no" - secrets: - - secret1 diff --git a/shuffle-tools/1.1.0/requirements.txt b/shuffle-tools/1.1.0/requirements.txt deleted file mode 100644 index 6b792a90..00000000 --- a/shuffle-tools/1.1.0/requirements.txt +++ /dev/null @@ -1,9 +0,0 @@ -ioc_finder==6.0.1 -py7zr==0.11.3 -rarfile==4.0 -pyminizip==0.2.4 -requests==2.25.1 -xmltodict==0.11.0 -json2xml==3.6.0 -ipaddress==1.0.23 -liquidpy==0.7.1 diff --git a/shuffle-tools/1.1.0/src/app.py b/shuffle-tools/1.1.0/src/app.py deleted file mode 100644 index 6da2f2aa..00000000 --- a/shuffle-tools/1.1.0/src/app.py +++ /dev/null @@ -1,1810 +0,0 @@ -import asyncio -import datetime -import json -import time -import markupsafe -import os -import re -import subprocess -import tempfile -import zipfile -import base64 -import ipaddress -import hashlib -from io import StringIO -from contextlib import redirect_stdout -from liquid import Liquid -import liquid - -import py7zr -import pyminizip -import rarfile -import requests -import tarfile - -import xmltodict -from json2xml import json2xml -from json2xml.utils import readfromstring - -from ioc_finder import find_iocs -from walkoff_app_sdk.app_base import AppBase - -import binascii -import struct - -class Tools(AppBase): - """ - An example of a Walkoff App. - Inherit from the AppBase class to have Redis, logging, and console - logging set up behind the scenes. - """ - - __version__ = "1.1.0" - app_name = ( - "Shuffle Tools" # this needs to match "name" in api.yaml for WALKOFF to work - ) - - def __init__(self, redis, logger, console_logger=None): - """ - Each app should have this __init__ to set up Redis and logging. - :param redis: - :param logger: - :param console_logger: - """ - super().__init__(redis, logger, console_logger) - - def router(self): - return "This action should be skipped" - - def base64_conversion(self, string, operation): - if operation == "encode": - encoded_bytes = base64.b64encode(string.encode("utf-8")) - encoded_string = str(encoded_bytes, "utf-8") - return encoded_string - - elif operation == "decode": - try: - decoded_bytes = base64.b64decode(string) - try: - decoded_bytes = str(decoded_bytes, "utf-8") - except: - pass - - return decoded_bytes - except Exception as e: - #return string.decode("utf-16") - - self.logger.info(f"[WARNING] Error in normal decoding: {e}") - return { - "success": False, - "reason": f"Error decoding the base64: {e}", - } - #newvar = binascii.a2b_base64(string) - #try: - # if str(newvar).startswith("b'") and str(newvar).endswith("'"): - # newvar = newvar[2:-1] - #except Exception as e: - # self.logger.info(f"Encoding issue in base64: {e}") - #return newvar - - #try: - # return newvar - #except: - # pass - - return { - "success": False, - "reason": "Error decoding the base64", - } - - return json.dumps({ - "success": False, - "reason": "No base64 to be converted", - }) - - def parse_list(self, input_list): - try: - input_list = json.loads(input_list) - if isinstance(input_list, list): - input_list = ",".join(input_list) - else: - return json.dumps(input_list) - except: - pass - - input_list = input_list.replace(", ", ",", -1) - return input_list - - # This is an SMS function of Shuffle - def send_sms_shuffle(self, apikey, phone_numbers, body): - phone_numbers = self.parse_list(phone_numbers) - - targets = [phone_numbers] - if ", " in phone_numbers: - targets = phone_numbers.split(", ") - elif "," in phone_numbers: - targets = phone_numbers.split(",") - - data = {"numbers": targets, "body": body} - - url = "https://shuffler.io/api/v1/functions/sendsms" - headers = {"Authorization": "Bearer %s" % apikey} - return requests.post(url, headers=headers, json=data).text - - # This is an email function of Shuffle - def send_email_shuffle(self, apikey, recipients, subject, body, attachments=""): - recipients = self.parse_list(recipients) - - - targets = [recipients] - if ", " in recipients: - targets = recipients.split(", ") - elif "," in recipients: - targets = recipients.split(",") - - data = { - "targets": targets, - "subject": subject, - "body": body, - "type": "alert", - } - - # Read the attachments - if attachments != None and len(attachments) > 0: - try: - attachments = parse_list(attachments, splitter=",") - files = [] - for item in attachments: - new_file = self.get_file(file_ids) - files.append(new_file) - - data["attachments"] = files - except Exception as e: - self.logger.info(f"Error in attachment parsing for email: {e}") - - - url = "https://shuffler.io/api/v1/functions/sendmail" - headers = {"Authorization": "Bearer %s" % apikey} - return requests.post(url, headers=headers, json=data).text - - def repeat_back_to_me(self, call): - return call - - # https://github.com/fhightower/ioc-finder - def parse_file_ioc(self, file_ids, input_type="all"): - def parse(data): - try: - iocs = find_iocs(str(data)) - newarray = [] - for key, value in iocs.items(): - if input_type != "all": - if key not in input_type: - continue - if len(value) > 0: - for item in value: - if isinstance(value, dict): - for subkey, subvalue in value.items(): - if len(subvalue) > 0: - for subitem in subvalue: - data = { - "data": subitem, - "data_type": "%s_%s" - % (key[:-1], subkey), - } - if data not in newarray: - newarray.append(data) - else: - data = {"data": item, "data_type": key[:-1]} - if data not in newarray: - newarray.append(data) - for item in newarray: - if "ip" in item["data_type"]: - item["data_type"] = "ip" - return {"success": True, "items": newarray} - except Exception as excp: - return {"success": False, "message": "{}".format(excp)} - - if input_type == "": - input_type = "all" - else: - input_type = input_type.split(",") - - try: - file_ids = eval(file_ids) # nosec - except SyntaxError: - file_ids = file_ids - except NameError: - file_ids = file_ids - - return_value = None - if type(file_ids) == str: - return_value = parse(self.get_file(file_ids)["data"]) - elif type(file_ids) == list and type(file_ids[0]) == str: - return_value = [ - parse(self.get_file(file_id)["data"]) for file_id in file_ids - ] - elif ( - type(file_ids) == list - and type(file_ids[0]) == list - and type(file_ids[0][0]) == str - ): - return_value = [ - [parse(self.get_file(file_id2)["data"]) for file_id2 in file_id] - for file_id in file_ids - ] - else: - return "Invalid input" - return return_value - - # https://github.com/fhightower/ioc-finder - def parse_ioc(self, input_string, input_type="all"): - input_string = str(input_string) - if input_type == "": - input_type = "all" - else: - input_type = input_type.split(",") - - iocs = find_iocs(input_string) - newarray = [] - for key, value in iocs.items(): - if input_type != "all": - if key not in input_type: - continue - - if len(value) > 0: - for item in value: - # If in here: attack techniques. Shouldn't be 3 levels so no - # recursion necessary - if isinstance(value, dict): - for subkey, subvalue in value.items(): - if len(subvalue) > 0: - for subitem in subvalue: - data = { - "data": subitem, - "data_type": "%s_%s" % (key[:-1], subkey), - } - if data not in newarray: - newarray.append(data) - else: - data = {"data": item, "data_type": key[:-1]} - if data not in newarray: - newarray.append(data) - - # Reformatting IP - for item in newarray: - if "ip" in item["data_type"]: - item["data_type"] = "ip" - try: - item["is_private_ip"] = ipaddress.ip_address(item["data"]).is_private - except: - self.logger.info("Error parsing %s" % item["data"]) - - try: - newarray = json.dumps(newarray) - except json.decoder.JSONDecodeError as e: - return "Failed to parse IOC's: %s" % e - - return newarray - - def parse_list(self, items, splitter="\n"): - if splitter == "": - splitter = "\n" - - splititems = items.split(splitter) - - return str(splititems) - - def get_length(self, item): - if item.startswith("[") and item.endswith("]"): - try: - item = item.replace("'", '"', -1) - item = json.loads(item) - except json.decoder.JSONDecodeError as e: - self.logger.info("Parse error: %s" % e) - - return str(len(item)) - - def set_json_key(self, json_object, key, value): - self.logger.info(f"OBJ: {json_object}\nKEY: {key}\nVAL: {value}") - if isinstance(json_object, str): - try: - json_object = json.loads(json_object) - except json.decoder.JSONDecodeError as e: - return { - "success": False, - "reason": "Item is not valid JSON" - } - - if isinstance(json_object, list): - if len(json_object) == 1: - json_object = json_object[0] - else: - return { - "success": False, - "reason": "Item is valid JSON, but can't handle lists. Use .#" - } - - if not isinstance(json_object, object): - return { - "success": False, - "reason": "Item is not valid JSON (2)" - } - - if isinstance(value, str): - try: - value = json.loads(value) - except json.decoder.JSONDecodeError as e: - pass - - # Handle JSON paths - if "." in key: - base_object = json.loads(json.dumps(json_object)) - #base_object.output.recipients.notificationEndpointIds = ... - - keys = key.split(".") - if len(keys) >= 1: - first_object = keys[0] - - # This is awful :) - buildstring = "base_object" - for subkey in keys: - buildstring += f"[\"{subkey}\"]" - - buildstring += f" = {value}" - self.logger.info("BUILD: %s" % buildstring) - - #output = - exec(buildstring) - json_object = base_object - #json_object[first_object] = base_object - else: - json_object[key] = value - - return json_object - - def delete_json_keys(self, json_object, keys): - keys = self.parse_list(keys) - - splitdata = [keys] - if ", " in keys: - splitdata = keys.split(", ") - elif "," in keys: - splitdata = keys.split(",") - - for key in splitdata: - key = key.strip() - try: - del json_object[key] - except: - self.logger.info(f"[ERROR] Key {key} doesn't exist") - - return json_object - - def translate_value(self, input_data, translate_from, translate_to, else_value=""): - splitdata = [translate_from] - if ", " in translate_from: - splitdata = translate_from.split(", ") - elif "," in translate_from: - splitdata = translate_from.split(",") - - if isinstance(input_data, list) or isinstance(input_data, dict): - input_data = json.dumps(input_data) - - to_return = input_data - if isinstance(input_data, str): - found = False - for item in splitdata: - item = item.strip() - if item in input_data: - input_data = input_data.replace(item, translate_to) - found = True - - if not found and len(else_value) > 0: - input_data = else_value - - if input_data.lower() == "false": - return False - elif input_data.lower() == "true": - return True - - return input_data - - def map_value(self, input_data, mapping, default_value=""): - if not isinstance(mapping, dict) and not isinstance(mapping, object): - try: - mapping = json.loads(mapping) - except json.decoder.JSONDecodeError as e: - return { - "success": False, - "reason": "Mapping is not valid JSON: %s" % e, - } - - for key, value in mapping.items(): - try: - input_data = input_data.replace(key, str(value), -1) - except: - self.logger.info(f"Failed mapping output data for key {key}") - - return input_data - - # Changed with 1.1.0 to run with different returns - def regex_capture_group(self, input_data, regex): - try: - returnvalues = { - "success": True, - } - - matches = re.findall(regex, input_data) - self.logger.info(f"{matches}") - for item in matches: - if isinstance(item, str): - name = "group_0" - try: - returnvalues[name].append(item) - except: - returnvalues[name] = [item] - - else: - for i in range(0, len(item)): - name = "group_%d" % i - try: - returnvalues[name].append(item[i]) - except: - returnvalues[name] = [item[i]] - - return returnvalues - except re.error as e: - return { - "success": False, - "reason": "Bad regex pattern: %s" % e, - } - - def regex_replace( - self, input_data, regex, replace_string="", ignore_case="False" - ): - - #self.logger.info("=" * 80) - #self.logger.info(f"Regex: {regex}") - #self.logger.info(f"replace_string: {replace_string}") - #self.logger.info("=" * 80) - - if ignore_case.lower().strip() == "true": - return re.sub(regex, replace_string, input_data, flags=re.IGNORECASE) - else: - return re.sub(regex, replace_string, input_data) - - def execute_python(self, code): - self.logger.info(f"Python code {len(code)} {code}. If uuid, we'll try to download and use the file.") - - if len(code) == 36 and "-" in code: - filedata = self.get_file(code) - if filedata["success"] == False: - return { - "success": False, - "message": f"Failed to get file for ID {code}", - } - - if ".py" not in filedata["filename"]: - return { - "success": False, - "message": f"Filename needs to contain .py", - } - - - # Write the code to a file - # 1. Take the data into a file - # 2. Subprocess execute file? - try: - f = StringIO() - with redirect_stdout(f): - exec(code) # nosec :( - - s = f.getvalue() - - #try: - # s = s.encode("utf-8") - #except Exception as e: - # self.logger.info(f"Failed utf-8 encoding response: {e}") - - try: - return { - "success": True, - "message": s.strip(), - } - except Exception as e: - return { - "success": True, - "message": s, - } - - except Exception as e: - return { - "success": False, - "message": f"exception: {e}", - } - - def execute_bash(self, code, shuffle_input): - process = subprocess.Popen( - code, - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - text=True, - shell=True, # nosec - ) - stdout = process.communicate() - item = "" - if len(stdout[0]) > 0: - self.logger.info("[DEBUG] Succesfully ran bash!") - item = stdout[0] - else: - self.logger.info(f"[ERROR] FAILED to run bash command {code}!") - item = stdout[1] - - try: - ret = item.decode("utf-8") - return ret - except Exception: - return item - - return item - - def filter_list(self, input_list, field, check, value, opposite): - self.logger.info(f"\nRunning function with list {input_list}") - - flip = False - if str(opposite).lower() == "true": - flip = True - - try: - #input_list = eval(input_list) # nosec - input_list = json.loads(input_list) - except Exception: - try: - input_list = input_list.replace("'", '"', -1) - input_list = json.loads(input_list) - except Exception: - self.logger.info("[WARNING] Error parsing string to array. Continuing anyway.") - - # Workaround D: - if not isinstance(input_list, list): - return { - "success": False, - "reason": "Error: input isnt a list. Remove # to use this action.", - "valid": [], - "invalid": [], - } - - input_list = [input_list] - - self.logger.info(f"\nRunning with check \"%s\" on list of length %d\n" % (check, len(input_list))) - found_items = [] - new_list = [] - failed_list = [] - for item in input_list: - try: - try: - item = json.loads(item) - except Exception: - pass - - # Support for nested dict key - tmp = item - if field and field.strip() != "": - for subfield in field.split("."): - tmp = tmp[subfield] - - if isinstance(tmp, dict) or isinstance(tmp, list): - try: - tmp = json.dumps(tmp) - except json.decoder.JSONDecodeError as e: - self.logger.info("FAILED DECODING: %s" % e) - pass - - #self.logger.info("PRE CHECKS FOR TMP: %") - - # EQUALS JUST FOR STR - if check == "equals": - # Mostly for bools - # value = tmp.lower() - - if str(tmp).lower() == str(value).lower(): - self.logger.info("APPENDED BECAUSE %s %s %s" % (field, check, value)) - if not flip: - new_list.append(item) - else: - failed_list.append(item) - else: - if flip: - new_list.append(item) - else: - failed_list.append(item) - - # IS EMPTY FOR STR OR LISTS - elif check == "is empty": - if tmp == "[]": - tmp = [] - - if type(tmp) == list and len(tmp) == 0 and not flip: - new_list.append(item) - elif type(tmp) == list and len(tmp) > 0 and flip: - new_list.append(item) - elif type(tmp) == str and not tmp and not flip: - new_list.append(item) - elif type(tmp) == str and tmp and flip: - new_list.append(item) - else: - failed_list.append(item) - - # STARTS WITH = FOR STR OR [0] FOR LIST - elif check == "starts with": - if type(tmp) == list and tmp[0] == value and not flip: - new_list.append(item) - elif type(tmp) == list and tmp[0] != value and flip: - new_list.append(item) - elif type(tmp) == str and tmp.startswith(value) and not flip: - new_list.append(item) - elif type(tmp) == str and not tmp.startswith(value) and flip: - new_list.append(item) - else: - failed_list.append(item) - - # ENDS WITH = FOR STR OR [-1] FOR LIST - elif check == "ends with": - if type(tmp) == list and tmp[-1] == value and not flip: - new_list.append(item) - elif type(tmp) == list and tmp[-1] != value and flip: - new_list.append(item) - elif type(tmp) == str and tmp.endswith(value) and not flip: - new_list.append(item) - elif type(tmp) == str and not tmp.endswith(value) and flip: - new_list.append(item) - else: - failed_list.append(item) - - # CONTAINS FIND FOR LIST AND IN FOR STR - elif check == "contains": - if type(tmp) == list and value.lower() in tmp and not flip: - new_list.append(item) - elif type(tmp) == list and value.lower() not in tmp and flip: - new_list.append(item) - elif ( - type(tmp) == str - and tmp.lower().find(value.lower()) != -1 - and not flip - ): - new_list.append(item) - elif ( - type(tmp) == str - and tmp.lower().find(value.lower()) == -1 - and flip - ): - new_list.append(item) - else: - failed_list.append(item) - elif check == "contains any of": - self.logger.info("Inside contains any of") - checklist = value.split(",") - self.logger.info("Checklist and tmp: %s - %s" % (checklist, tmp)) - found = False - for subcheck in checklist: - subcheck = subcheck.strip().lower() - #ext.lower().strip() == value.lower().strip() - if type(tmp) == list and subcheck in tmp and not flip: - new_list.append(item) - found = True - break - elif type(tmp) == list and subcheck in tmp and flip: - failed_list.append(item) - found = True - break - elif type(tmp) == list and subcheck not in tmp and not flip: - new_list.append(item) - found = True - break - elif type(tmp) == list and subcheck not in tmp and flip: - failed_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) != -1 and not flip): - new_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) != -1 and flip): - failed_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) == -1 and not flip): - failed_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) == -1 and flip): - new_list.append(item) - found = True - break - - if not found: - failed_list.append(item) - - # CONTAINS FIND FOR LIST AND IN FOR STR - elif check == "field is unique": - #self.logger.info("FOUND: %s" - if tmp.lower() not in found_items and not flip: - new_list.append(item) - found_items.append(tmp.lower()) - elif tmp.lower() in found_items and flip: - new_list.append(item) - found_items.append(tmp.lower()) - else: - failed_list.append(item) - - #tmp = json.dumps(tmp) - - #for item in new_list: - #if type(tmp) == list and value.lower() in tmp and not flip: - # new_list.append(item) - # found = True - # break - #elif type(tmp) == list and value.lower() not in tmp and flip: - # new_list.append(item) - # found = True - # break - - # CONTAINS FIND FOR LIST AND IN FOR STR - elif check == "contains any of": - value = self.parse_list(value) - checklist = value.split(",") - tmp = tmp.lower() - self.logger.info("CHECKLIST: %s. Value: %s" % (checklist, tmp)) - found = False - for value in checklist: - if value in tmp and not flip: - new_list.append(item) - found = True - break - elif value not in tmp and flip: - new_list.append(item) - found = True - break - - if not found: - failed_list.append(item) - - elif check == "larger than": - if int(tmp) > int(value) and not flip: - new_list.append(item) - elif int(tmp) > int(value) and flip: - new_list.append(item) - else: - failed_list.append(item) - elif check == "less than": - if int(tmp) < int(value) and not flip: - new_list.append(item) - elif int(tmp) < int(value) and flip: - new_list.append(item) - else: - failed_list.append(item) - - # SINGLE ITEM COULD BE A FILE OR A LIST OF FILES - elif check == "files by extension": - if type(tmp) == list: - file_list = [] - - for file_id in tmp: - filedata = self.get_file(file_id) - _, ext = os.path.splitext(filedata["filename"]) - if ( - ext.lower().strip() == value.lower().strip() - and not flip - ): - file_list.append(file_id) - elif ext.lower().strip() != value.lower().strip() and flip: - file_list.append(file_id) - # else: - # failed_list.append(file_id) - - tmp = item - if field and field.strip() != "": - for subfield in field.split(".")[:-1]: - tmp = tmp[subfield] - tmp[field.split(".")[-1]] = file_list - new_list.append(item) - else: - new_list = file_list - # else: - # failed_list = file_list - - elif type(tmp) == str: - filedata = self.get_file(tmp) - _, ext = os.path.splitext(filedata["filename"]) - if ext.lower().strip() == value.lower().strip() and not flip: - new_list.append(item) - elif ext.lower().strip() != value.lower().strip() and flip: - new_list.append((item, ext)) - else: - failed_list.append(item) - - except Exception as e: - # "Error: %s" % e - self.logger.info("[WARNING] FAILED WITH EXCEPTION: %s" % e) - failed_list.append(item) - # return - - try: - return json.dumps( - { - "success": True, - "valid": new_list, - "invalid": failed_list, - } - ) - # new_list = json.dumps(new_list) - except json.decoder.JSONDecodeError as e: - return json.dumps( - { - "success": False, - "reason": "Failed parsing filter list output" + e, - } - ) - - return new_list - - #def multi_list_filter(self, input_list, field, check, value): - # input_list = input_list.replace("'", '"', -1) - # input_list = json.loads(input_list) - - # fieldsplit = field.split(",") - # if ", " in field: - # fieldsplit = field.split(", ") - - # valuesplit = value.split(",") - # if ", " in value: - # valuesplit = value.split(", ") - - # checksplit = check.split(",") - # if ", " in check: - # checksplit = check.split(", ") - - # new_list = [] - # for list_item in input_list: - # list_item = json.loads(list_item) - - # index = 0 - # for check in checksplit: - # if check == "equals": - # self.logger.info( - # "Checking %s vs %s" - # % (list_item[fieldsplit[index]], valuesplit[index]) - # ) - # if list_item[fieldsplit[index]] == valuesplit[index]: - # new_list.append(list_item) - - # index += 1 - - # # "=", - # # "equals", - # # "!=", - # # "does not equal", - # # ">", - # # "larger than", - # # "<", - # # "less than", - # # ">=", - # # "<=", - # # "startswith", - # # "endswith", - # # "contains", - # # "re", - # # "matches regex", - - # try: - # new_list = json.dumps(new_list) - # except json.decoder.JSONDecodeError as e: - # return "Failed parsing filter list output" % e - - # return new_list - - # Gets the file's metadata, e.g. md5 - def get_file_meta(self, file_id): - headers = { - "Authorization": "Bearer %s" % self.authorization, - } - - ret = requests.get( - "%s/api/v1/files/%s?execution_id=%s" - % (self.url, file_id, self.current_execution_id), - headers=headers, - ) - self.logger.info(f"RET: {ret}") - - return ret.text - - # Use data from AppBase to talk to backend - def delete_file(self, file_id): - headers = { - "Authorization": "Bearer %s" % self.authorization, - } - self.logger.info("HEADERS: %s" % headers) - - ret = requests.delete( - "%s/api/v1/files/%s?execution_id=%s" - % (self.url, file_id, self.current_execution_id), - headers=headers, - ) - return ret.text - - def create_file(self, filename, data): - self.logger.info("Inside function") - - #try: - # if str(data).startswith("b'") and str(data).endswith("'"): - # data = data[2:-1] - #except Exception as e: - # self.logger.info(f"Exception: {e}") - - filedata = { - "filename": filename, - "data": data, - } - - fileret = self.set_files([filedata]) - value = {"success": True, "file_ids": fileret} - if len(fileret) == 1: - value = {"success": True, "file_ids": fileret[0]} - - return value - - # Input is WAS a file, hence it didn't get the files - def get_file_value(self, filedata): - filedata = self.get_file(filedata) - if filedata is None: - return "File is empty?" - - self.logger.info("INSIDE APP DATA: %s" % filedata) - try: - return filedata["data"].decode() - except: - try: - return filedata["data"].decode("utf-16") - except: - return { - "success": False, - "reason": "Got the file, but the encoding can't be printed", - } - - def download_remote_file(self, url): - ret = requests.get(url, verify=False) # nosec - filename = url.split("/")[-1] - fileret = self.set_files( - [ - { - "filename": filename, - "data": ret.content, - } - ] - ) - - if len(fileret) > 0: - value = {"success": True, "file_id": fileret[0]} - else: - value = {"success": False, "reason": "No files downloaded"} - - return value - - def extract_archive(self, file_ids, fileformat="zip", password=None): - try: - return_data = {"success": False, "files": []} - - try: - file_ids = eval(file_ids) # nosec - except SyntaxError: - file_ids = file_ids - - self.logger.info("IDS: %s" % file_ids) - items = file_ids if type(file_ids) == list else file_ids.split(",") - for file_id in items: - - item = self.get_file(file_id) - return_ids = None - - self.logger.info("Working with fileformat %s" % fileformat) - with tempfile.TemporaryDirectory() as tmpdirname: - - # Get archive and save phisically - with open(os.path.join(tmpdirname, "archive"), "wb") as f: - f.write(item["data"]) - - # Grab files before, upload them later - to_be_uploaded = [] - - # Zipfile for zipped archive - if fileformat.strip().lower() == "zip": - try: - with zipfile.ZipFile( - os.path.join(tmpdirname, "archive") - ) as z_file: - if password: - z_file.setpassword(bytes(password.encode())) - for member in z_file.namelist(): - filename = os.path.basename(member) - if not filename: - continue - source = z_file.open(member) - to_be_uploaded.append( - {"filename": source.name, "data": source.read()} - ) - return_data["success"] = True - except (zipfile.BadZipFile, Exception): - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": "File is not a valid zip archive", - } - ) - - continue - - elif fileformat.strip().lower() == "rar": - try: - with rarfile.RarFile( - os.path.join(tmpdirname, "archive") - ) as z_file: - if password: - z_file.setpassword(password) - for member in z_file.namelist(): - filename = os.path.basename(member) - if not filename: - continue - source = z_file.open(member) - to_be_uploaded.append( - {"filename": source.name, "data": source.read()} - ) - return_data["success"] = True - except Exception: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": "File is not a valid rar archive", - } - ) - continue - - elif fileformat.strip().lower() == "tar": - try: - with tarfile.open( - os.path.join(tmpdirname, "archive"), mode="r" - ) as z_file: - for member in z_file.getnames(): - member_files = z_file.extractfile(member) - to_be_uploaded.append( - { - "filename": member, - "data": member_files.read(), - } - ) - return_data["success"] = True - except Exception as e: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": e, - } - ) - continue - elif fileformat.strip().lower() == "tar.gz": - try: - with tarfile.open( - os.path.join(tmpdirname, "archive"), mode="r:gz" - ) as z_file: - for member in z_file.getnames(): - member_files = z_file.extractfile(member) - to_be_uploaded.append( - { - "filename": member, - "data": member_files.read(), - } - ) - return_data["success"] = True - except Exception as e: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": e, - } - ) - continue - - elif fileformat.strip().lower() == "7zip": - try: - with py7zr.SevenZipFile( - os.path.join(tmpdirname, "archive"), - mode="r", - password=password if password else None, - ) as z_file: - for filename, source in z_file.readall().items(): - # Removes paths - filename = filename.split("/")[-1] - to_be_uploaded.append( - { - "filename": item["filename"], - "data": source.read(), - } - ) - return_data["success"] = True - except Exception: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": "File is not a valid 7zip archive", - } - ) - continue - else: - return "No such format: %s" % fileformat - - if len(to_be_uploaded) > 0: - return_ids = self.set_files(to_be_uploaded) - return_data["files"].append( - { - "success": True, - "file_id": file_id, - "filename": item["filename"], - "file_ids": return_ids, - } - ) - else: - return_data["files"].append( - { - "success": False, - "file_id": file_id, - "filename": item["filename"], - "message": "Archive is empty", - } - ) - - return return_data - - except Exception as excp: - return {"success": False, "message": "%s" % excp} - - def inflate_archive(self, file_ids, fileformat, name, password=None): - - try: - # TODO: will in future support multiple files instead of string ids? - file_ids = file_ids.split() - self.logger.info("picking {}".format(file_ids)) - - # GET all items from shuffle - items = [self.get_file(file_id) for file_id in file_ids] - - if len(items) == 0: - return "No file to inflate" - - # Dump files on disk, because libs want path :( - with tempfile.TemporaryDirectory() as tmpdir: - paths = [] - self.logger.info("Number 1") - for item in items: - with open(os.path.join(tmpdir, item["filename"]), "wb") as f: - f.write(item["data"]) - paths.append(os.path.join(tmpdir, item["filename"])) - - # Create archive temporary - self.logger.info("{} items to inflate".format(len(items))) - with tempfile.NamedTemporaryFile() as archive: - - if fileformat == "zip": - archive_name = "archive.zip" if not name else name - pyminizip.compress_multiple( - paths, [], archive.name, password, 5 - ) - - elif fileformat == "7zip": - archive_name = "archive.7z" if not name else name - with py7zr.SevenZipFile( - archive.name, - "w", - password=password if len(password) > 0 else None, - ) as sz_archive: - for path in paths: - sz_archive.write(path) - - else: - return "Format {} not supported".format(fileformat) - - return_id = self.set_files( - [{"filename": archive_name, "data": open(archive.name, "rb")}] - ) - - if len(return_id) == 1: - # Returns the first file's ID - return {"success": True, "id": return_id[0]} - else: - return { - "success": False, - "message": "Upload archive returned {}".format(return_id), - } - - except Exception as excp: - return {"success": False, "message": excp} - - def add_list_to_list(self, list_one, list_two): - if isinstance(list_one, str): - if not list_one or list_one == " " or list_one == "None" or list_one == "null": - list_one = "[]" - - try: - list_one = json.loads(list_one) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list1 as json: %s" % e) - if list_one == None: - list_one = [] - else: - return { - "success": False, - "reason": f"List one is not a valid list: {list_one}" - } - - if isinstance(list_two, str): - if not list_two or list_two == " " or list_two == "None" or list_two == "null": - list_two = "[]" - try: - list_two = json.loads(list_two) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list2 as json: %s" % e) - if list_one == None: - list_one = [] - else: - return { - "success": False, - "reason": f"List two is not a valid list: {list_two}" - } - - if isinstance(list_one, dict): - list_one = [list_one] - if isinstance(list_two, dict): - list_two = [list_two] - - for item in list_two: - list_one.append(item) - - return list_one - - def diff_lists(self, list_one, list_two): - if isinstance(list_one, str): - try: - list_one = json.loads(list_one) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list1 as json: %s" % e) - - if isinstance(list_two, str): - try: - list_two = json.loads(list_two) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list2 as json: %s" % e) - - def diff(li1, li2): - return list(set(li1) - set(li2)) + list(set(li2) - set(li1)) - - return diff(list_one, list_two) - - def merge_lists(self, list_one, list_two, set_field="", sort_key_list_one="", sort_key_list_two=""): - if isinstance(list_one, str): - try: - list_one = json.loads(list_one) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list1 as json: %s" % e) - - if isinstance(list_two, str): - try: - list_two = json.loads(list_two) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list2 as json: %s" % e) - - if len(list_one) != len(list_two): - return {"success": False, "message": "Lists length must be the same. %d vs %d" % (len(list_one), len(list_two))} - - if len(sort_key_list_one) > 0: - self.logger.info("Sort 1 %s by key: %s" % (list_one, sort_key_list_one)) - try: - list_one = sorted(list_one, key=lambda k: k.get(sort_key_list_one), reverse=True) - except: - self.logger.info("Failed to sort list one") - pass - - if len(sort_key_list_two) > 0: - #self.logger.info("Sort 2 %s by key: %s" % (list_two, sort_key_list_two)) - try: - list_two = sorted(list_two, key=lambda k: k.get(sort_key_list_two), reverse=True) - except: - self.logger.info("Failed to sort list one") - pass - - # Loops for each item in sub array and merges items together - # List one is being overwritten - base_key = "shuffle_auto_merge" - try: - for i in range(len(list_one)): - #self.logger.info(list_two[i]) - if isinstance(list_two[i], dict): - for key, value in list_two[i].items(): - list_one[i][key] = value - elif isinstance(list_two[i], str) and list_two[i] == "": - continue - elif isinstance(list_two[i], str) or isinstance(list_two[i], int) or isinstance(list_two[i], bool): - self.logger.info("IN SETTER FOR %s" % list_two[i]) - if len(set_field) == 0: - self.logger.info("Define a JSON key to set for List two (Set Field)") - list_one[i][base_key] = list_two[i] - else: - list_one[i][set_field] = list_two[i] - except Exception as e: - return { - "success": False, - "reason": "An error occurred while merging the lists. PS: List one can NOT be a list of integers. If this persists, contact us at support@shuffler.io", - "exception": f"{e}", - } - - - return list_one - - def xml_json_convertor(self, convertto, data): - try: - if convertto == "json": - ans = xmltodict.parse(data) - json_data = json.dumps(ans) - return json_data - else: - ans = readfromstring(data) - return json2xml.Json2xml(ans, wrapper="all", pretty=True).to_xml() - except Exception as e: - return e - - def date_to_epoch(self, input_data, date_field, date_format): - - self.logger.info( - "Executing with {} on {} with format {}".format( - input_data, date_field, date_format - ) - ) - - result = json.loads(input_data) - #try: - #except json.decoder.JSONDecodeError as e: - # result = input_data - - # https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior - epoch = datetime.datetime.strptime(result[date_field], date_format).strftime( - "%s" - ) - result["epoch"] = epoch - return result - - def compare_relative_date( - self, input_data, date_format, equality_test, offset, units, direction - ): - - if input_data == "None": - return False - - self.logger.info("Converting input date.") - - if date_format != "%s": - input_dt = datetime.datetime.strptime(input_data, date_format) - else: - input_dt = datetime.datetime.utcfromtimestamp(float(input_data)) - - offset = int(offset) - if units == "seconds": - delta = datetime.timedelta(seconds=offset) - elif units == "minutes": - delta = datetime.timedelta(minutes=offset) - elif units == "hours": - delta = datetime.timedelta(hours=offset) - elif units == "days": - delta = datetime.timedelta(days=offset) - - utc_format = date_format - if utc_format.endswith("%z"): - utc_format = utc_format.replace("%z", "Z") - - if date_format != "%s": - formatted_dt = datetime.datetime.strptime( - datetime.datetime.utcnow().strftime(utc_format), date_format - ) - else: - formatted_dt = datetime.datetime.utcnow() - - self.logger.info("Formatted time is: {}".format(formatted_dt)) - if direction == "ago": - comparison_dt = formatted_dt - delta - else: - comparison_dt = formatted_dt + delta - self.logger.info("{} {} {} is {}".format(offset, units, direction, comparison_dt)) - - diff = (input_dt - comparison_dt).total_seconds() - self.logger.info( - "Difference between {} and {} is {}".format(input_data, comparison_dt, diff) - ) - result = False - if equality_test == ">": - result = 0 > diff - if direction == "ahead": - result = not (result) - elif equality_test == "<": - result = 0 < diff - if direction == "ahead": - result = not (result) - elif equality_test == "=": - result = diff == 0 - elif equality_test == "!=": - result = diff != 0 - elif equality_test == ">=": - result = 0 >= diff - if direction == "ahead" and diff != 0: - result = not (result) - elif equality_test == "<=": - result = 0 <= diff - if direction == "ahead" and diff != 0: - result = not (result) - - self.logger.info( - "At {}, is {} {} than {} {} {}? {}".format( - formatted_dt, - input_data, - equality_test, - offset, - units, - direction, - result, - ) - ) - - return result - - def run_math_operation(self, operation): - self.logger.info("Operation: %s" % operation) - result = eval(operation) - return result - - def escape_html(self, input_data, field_name): - - mapping = json.loads(input_data) - self.logger.info(f"Got mapping {json.dumps(mapping, indent=2)}") - - result = markupsafe.escape(mapping[field_name]) - self.logger.info(f"Mapping {input_data} to {result}") - - mapping[field_name] = result - return mapping - - def check_cache_contains(self, key, value, append): - org_id = self.full_execution["workflow"]["execution_org"]["id"] - url = "%s/api/v1/orgs/%s/get_cache" % (self.url, org_id) - data = { - "workflow_id": self.full_execution["workflow"]["id"], - "execution_id": self.current_execution_id, - "authorization": self.authorization, - "org_id": org_id, - "key": key, - } - - if append.lower() == "true": - append = True - else: - append = False - - get_response = requests.post(url, json=data) - try: - allvalues = get_response.json() - try: - if allvalues["value"] == None or allvalues["value"] == "null": - allvalues["value"] = "[]" - except: - pass - - if allvalues["success"] == False: - if append == True: - new_value = [str(value)] - data["value"] = json.dumps(new_value) - - set_url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) - set_response = requests.post(set_url, json=data) - try: - allvalues = set_response.json() - #allvalues["key"] = key - #return allvalues - - return { - "success": True, - "found": False, - "key": key, - "value": new_value, - } - except Exception as e: - return { - "success": False, - "found": False, - "key": key, - "reason": "Failed to find key, and failed to append", - } - else: - return { - "success": True, - "found": False, - "key": key, - "reason": "Not appended, not found", - } - else: - if allvalues["value"] == None or allvalues["value"] == "null": - allvalues["value"] = "[]" - - try: - parsedvalue = json.loads(allvalues["value"]) - except json.decoder.JSONDecodeError as e: - parsedvalue = [] - - #return parsedvalue - - for item in parsedvalue: - #return "%s %s" % (item, value) - if item == value: - if not append: - return { - "success": True, - "found": True, - "reason": "Found and not appending!", - "key": key, - "value": json.loads(allvalues["value"]), - } - else: - return { - "success": True, - "found": True, - "reason": "Found, was appending, but item already exists", - "key": key, - "value": json.loads(allvalues["value"]), - } - - # Lol - break - - if not append: - return { - "success": True, - "found": False, - "reason": "Not found, not appending (2)!", - "key": key, - "value": json.loads(allvalues["value"]), - } - - #parsedvalue = json.loads(allvalues["value"]) - #if parsedvalue == None: - # parsedvalue = [] - - #return parsedvalue - new_value = parsedvalue - if new_value == None: - new_value = [value] - - new_value.append(value) - - #return new_value - - data["value"] = json.dumps(new_value) - #return allvalues - - set_url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) - response = requests.post(set_url, json=data) - exception = "" - try: - allvalues = response.json() - #return allvalues - - return { - "success": True, - "found": False, - "reason": "Appended as it didn't exist", - "key": key, - "value": new_value, - } - except Exception as e: - exception = e - pass - - return { - "success": False, - "found": True, - "reason": f"Failed to set append the value: {exception}. This should never happen", - "key": key - } - - self.logger.info("Handle all values!") - - #return allvalues - - except Exception as e: - return { - "success": False, - "key": key, - "reason": f"Failed to get cache: {e}", - "found": False, - } - - return value.text - - def get_cache_value(self, key): - org_id = self.full_execution["workflow"]["execution_org"]["id"] - url = "%s/api/v1/orgs/%s/get_cache" % (self.url, org_id) - data = { - "workflow_id": self.full_execution["workflow"]["id"], - "execution_id": self.current_execution_id, - "authorization": self.authorization, - "org_id": org_id, - "key": key, - } - - value = requests.post(url, json=data) - try: - allvalues = value.json() - self.logger.info("VAL1: ", allvalues) - allvalues["key"] = key - self.logger.info("VAL2: ", allvalues) - - if allvalues["success"] == True: - allvalues["found"] = True - else: - allvalues["success"] = True - allvalues["found"] = False - - try: - parsedvalue = json.loads(allvalues["value"]) - allvalues["value"] = parsedvalue - - except: - self.logger.info("Parsing of value as JSON failed") - pass - - return json.dumps(allvalues) - except: - self.logger.info("Value couldn't be parsed, or json dump of value failed") - return value.text - - # FIXME: Add option for org only & sensitive data (not to be listed) - def set_cache_value(self, key, value): - org_id = self.full_execution["workflow"]["execution_org"]["id"] - url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) - data = { - "workflow_id": self.full_execution["workflow"]["id"], - "execution_id": self.current_execution_id, - "authorization": self.authorization, - "org_id": org_id, - "key": key, - "value": str(value), - } - - response = requests.post(url, json=data) - try: - allvalues = response.json() - allvalues["key"] = key - #allvalues["value"] = json.loads(json.dumps(value)) - - if (value.startswith("{") and value.endswith("}")) or (value.startswith("[") and value.endswith("]")): - try: - allvalues["value"] = json.loads(value) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed inner value parsing: %s" % e) - allvalues["value"] = str(value) - else: - allvalues["value"] = str(value) - - return json.dumps(allvalues) - except: - self.logger.info("Value couldn't be parsed") - return response.text - - def convert_json_to_tags(self, json_object, split_value=", ", include_key=True, lowercase=True): - try: - json_object = json.loads(json_object) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list2 as json: %s. Type: %s" % (e, type(json_object))) - - if isinstance(lowercase, str) and lowercase.lower() == "true": - lowercase = True - else: - lowercase = False - - if isinstance(include_key, str) or include_key.lower() == "true": - include_key = True - else: - include_key = False - - parsedstring = [] - try: - for key, value in json_object.items(): - self.logger.info("KV: %s:%s" % (key, value)) - if isinstance(value, str) or isinstance(value, int) or isinstance(value, bool): - if include_key == True: - parsedstring.append("%s:%s" % (key, value)) - else: - parsedstring.append("%s" % (value)) - else: - self.logger.info("Can't handle type %s" % type(value)) - except AttributeError as e: - return { - "success": False, - "reason": "Json Object is not a dictionary", - } - - fullstring = split_value.join(parsedstring) - if lowercase == True: - fullstring = fullstring.lower() - - return fullstring - - def cidr_ip_match(self, ip, networks): - self.logger.info("Executing with\nIP: {},\nNetworks: {}".format(ip, networks)) - - try: - networks = json.loads(networks) - except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse networks list as json: {}. Type: {}".format( - e, type(networks) - )) - return "Networks is not a valid list: {}".format(networks) - - try: - ip_networks = list(map(ipaddress.ip_network, networks)) - ip_address = ipaddress.ip_address(ip) - except ValueError as e: - return "IP or some networks are not in valid format.\nError: {}".format(e) - - matched_networks = list(filter(lambda net: (ip_address in net), ip_networks)) - - result = {} - result['networks'] = list(map(str, matched_networks)) - result['is_contained'] = True if len(result['networks']) > 0 else False - - return json.dumps(result) - - def get_timestamp(self, time_format): - timestamp = int(time.time()) - if time_format == "unix" or time_format == "epoch": - self.logger.info("Running default timestamp %s" % timestamp) - - return timestamp - - def get_hash_sum(self, value): - md5_value = "" - sha256_value = "" - - try: - md5_value = hashlib.md5(str(value).encode('utf-8')).hexdigest() - except Exception as e: - self.logger.info(f"Error in md5sum: {e}") - - try: - sha256_value = hashlib.sha256(str(value).encode('utf-8')).hexdigest() - except Exception as e: - self.logger.info(f"Error in sha256: {e}") - - parsedvalue = { - "success": True, - "original_value": value, - "md5": md5_value, - "sha256": sha256_value, - } - - return parsedvalue - -if __name__ == "__main__": - Tools.run() diff --git a/shuffle-tools/1.2.0/Dockerfile b/shuffle-tools/1.2.0/Dockerfile index 5c1a8af4..fac3aae2 100644 --- a/shuffle-tools/1.2.0/Dockerfile +++ b/shuffle-tools/1.2.0/Dockerfile @@ -5,13 +5,13 @@ FROM frikky/shuffle:app_sdk as base FROM base as builder # Install all alpine build tools needed for our pip installs -RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev git +RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev git zlib-dev python3-dev # Install all of our pip packages in a single directory that we can copy to our base image later RUN mkdir /install WORKDIR /install COPY requirements.txt /requirements.txt -RUN pip install --no-cache-dir --prefix="/install" -r /requirements.txt +RUN python3 -m pip install --no-cache-dir --upgrade --prefix="/install" -r /requirements.txt # Switch back to our base image and copy in all of our built packages and source code FROM base diff --git a/shuffle-tools/1.2.0/api.yaml b/shuffle-tools/1.2.0/api.yaml index b8fcff08..ab5337ee 100644 --- a/shuffle-tools/1.2.0/api.yaml +++ b/shuffle-tools/1.2.0/api.yaml @@ -1,13 +1,12 @@ --- app_version: 1.2.0 name: Shuffle Tools -description: A tool app for Shuffle. Gives access to most missing features along with Liquid. +description: A tool app for Shuffle. Gives access to most missing features along with Liquid. tags: - Testing - Shuffle categories: - - Testing - - Shuffle + - Other contact_info: name: "@frikkylikeme" url: https://shuffler.io @@ -26,39 +25,43 @@ actions: returns: schema: type: string - - name: router - description: Reroutes information between different nodes - returns: - schema: - type: string - - name: check_cache_contains - description: Checks Shuffle cache whether a user-provided key contains a value. Returns ALL the values previously appended. + - name: execute_python + description: Runs python with the data input. Any prints will be returned. parameters: - - name: key - description: The key to get + - name: code + description: The code to run. Can be a file ID from within Shuffle. required: true - multiline: false - example: "alert_ids" + multiline: true + example: print("hello world") schema: type: string - - name: value - description: The value to check for and append if applicable + + - name: search_datastore_category + description: Checks whether keys within a list are already in datastore, and returns whether they existed or not. They will be automatically appended. + parameters: + - name: input_list + description: The list to check from. Don't use .# in this. required: true - multiline: false - example: "1208301599081" + multiline: true + example: '[{"data": "1.2.3.4"}, {"data": "1.2.3.5"}]' schema: type: string - - name: append - description: Whether to auto-append the value if it doesn't exist in the cache + - name: key + description: The key to use for deduplication. MUST be a part of each key in the input_list. required: true - options: - - true - - false multiline: false - example: "timestamp" + example: "ticketname+username" schema: type: string - - name: get_cache_value + - name: category + description: The category you want to upload to. This can be a new category, or an existing one. + required: true + multiline: false + example: "tickets" + schema: + type: string + + - name: get_datastore_value description: Get a value saved to your organization in Shuffle parameters: - name: key @@ -68,10 +71,17 @@ actions: example: "timestamp" schema: type: string + - name: category + description: The category to get the value from. Not required. + required: false + multiline: false + example: "tickets" + schema: + type: string returns: schema: type: string - - name: set_cache_value + - name: set_datastore_value description: Set a value to be saved to your organization in Shuffle. parameters: - name: key @@ -88,6 +98,34 @@ actions: example: "1621959545" schema: type: string + - name: category + description: The category to get the value from. Not required. + required: false + multiline: false + example: "tickets" + schema: + type: string + returns: + schema: + type: string + + - name: delete_datastore_value + description: Delete a value saved to your organization in Shuffle + parameters: + - name: key + description: The key to delete + required: true + multiline: false + example: "timestamp" + schema: + type: string + - name: category + description: The category to get the value from. Not required. + required: false + multiline: false + example: "tickets" + schema: + type: string returns: schema: type: string @@ -118,76 +156,127 @@ actions: returns: schema: type: string - - name: send_email_shuffle - description: Send an email from Shuffle + + #- name: send_email_shuffle + # description: Send an email from Shuffle + # parameters: + # - name: apikey + # description: Your https://shuffler.io organization apikey + # multiline: false + # example: "https://shuffler.io apikey" + # required: true + # schema: + # type: string + # - name: recipients + # description: The recipients of the email + # multiline: false + # example: "test@example.com,frikky@shuffler.io" + # required: true + # schema: + # type: string + # - name: subject + # description: The subject to use + # multiline: false + # example: "SOS this is an alert :o" + # required: true + # schema: + # type: string + # - name: body + # description: The body to add to the email + # multiline: true + # example: "This is an email alert from Shuffler.io :)" + # required: true + # schema: + # type: string + # - name: attachments + # description: The ID of files in Shuffle to add as attachments + # multiline: false + # example: "file_id1,file_id2,file_id3" + # required: false + # schema: + # type: string + # returns: + # schema: + # type: string + - name: dedup_and_merge + description: Merges data from multiple apps within a set timeframe. Returns action as SKIPPED if the data is a duplicate. Returns with a list of all data if the data at the end parameters: - - name: apikey - description: Your https://shuffler.io organization apikey - multiline: false - example: "https://shuffler.io apikey" + - name: key + description: The key to use for deduplication required: true - schema: - type: string - - name: recipients - description: The recipients of the email multiline: false - example: "test@example.com,frikky@shuffler.io" - required: true + example: "ticketname+username" schema: type: string - - name: subject - description: The subject to use - multiline: false - example: "SOS this is an alert :o" + - name: value + description: The full value of the item required: true + multiline: true + example: "1208301599081" schema: type: string - - name: body - description: The body to add to the email - multiline: true - example: "This is an email alert from Shuffler.io :)" + - name: timeout + description: The timeout before returning required: true + options: + - 2 + - 3 + - 4 + - 5 + - 6 + - 7 + - 8 + - 9 + - 10 + - 15 + - 20 + - 25 + multiline: false + example: "1" schema: type: string - - name: attachments - description: The ID of files in Shuffle to add as attachments - multiline: true - example: "file_id1,file_id2,file_id3" - required: false + - name: set_skipped + description: Whether to set the action SKIPPED or not IF it matches another workflow in the same timeframe + required: true + options: + - true + - false + multiline: false + example: "true" schema: type: string - returns: - schema: - type: string + - name: filter_list description: Takes a list and filters based on your data skip_multicheck: true parameters: - name: input_list - description: The list to check + description: The list to filter from. Don't use .# into this. required: true multiline: false example: '[{"data": "1.2.3.4"}, {"data": "1.2.3.5"}]' schema: type: string - name: field - description: The field to check - required: false + description: The field to check in the input list + required: true multiline: false example: "data" schema: type: string - name: check description: Type of check - required: true + required: false example: "equals" options: - equals + - 'equals any of' - 'larger than' - 'less than' - is empty - contains - contains any of + - in cache key - starts with - ends with - field is unique @@ -195,15 +284,15 @@ actions: schema: type: string - name: value - description: The value to check with - required: false + description: The value to compare with + required: false multiline: false example: "1.2.3.4" schema: type: string - name: opposite description: Whether to add or to NOT add - required: true + required: false options: - False - True @@ -249,7 +338,7 @@ actions: # schema: # type: string - name: parse_ioc - description: Parse IOC's based on https://github.com/fhightower/ioc-finder + description: "Parse IOC's based on https://github.com/fhightower/ioc-finder. Specify input type to optimize speed: domains, urls, email_addresses, ipv4s, ipv4_cidrs, md5s, sha256s, sha1s, cves and more.." parameters: - name: input_string description: The string to check @@ -262,7 +351,9 @@ actions: description: The string to check required: false multiline: false - example: "md5s" + example: "domains,urls,email_addresses,ipv4s,ipv4_cidrs,ipv6s,md5s,sha256s,sha1s,cves" + value: "domains,urls,ipv4s,md5s,sha1s,email_addresses" + multiselect: true schema: type: string returns: @@ -318,7 +409,6 @@ actions: example: schema: type: string - returns: returns: schema: type: string @@ -404,6 +494,19 @@ actions: returns: schema: type: string + - name: list_file_category_ids + description: Lists the IDs within a File namespace (category) + parameters: + - name: file_category + description: The category to get files from + required: true + multiline: false + example: "default" + schema: + type: string + returns: + schema: + type: string - name: get_file_value description: This function is made for reading file(s), printing their data parameters: @@ -434,6 +537,13 @@ actions: example: "EventID,username\n4137,frikky" schema: type: string + - name: category + description: The category the file belongs to + required: false + multiline: false + example: "yara-rules" + schema: + type: string - name: download_remote_file description: Downloads a file from a URL parameters: @@ -544,7 +654,7 @@ actions: schema: type: string - name: xml_json_convertor - description: Converts xml to json and vice versa + description: Converts xml or html to json and vice versa. parameters: - name: convertto required: true @@ -609,6 +719,7 @@ actions: multiline: false example: '%Y-%m-%dT%H:%M:%S.%f%Z' options: + - 'autodetect' - '%Y-%m-%dT%H:%M%z' - '%Y-%m-%dT%H:%M:%SZ' - '%Y-%m-%dT%H:%M:%S%Z' @@ -738,6 +849,41 @@ actions: example: "json_key" schema: type: string + - name: merge_json_objects + description: Merges two lists of same type AND length. + parameters: + - name: list_one + description: The first list + multiline: true + example: "{'key': 'value'}" + required: true + schema: + type: string + - name: list_two + description: The second list to use + multiline: true + required: true + example: "{'key2': 'value2'}" + schema: + type: string + - name: set_field + description: If items in list 2 are strings, but first is JSON, sets the values to the specified key. Defaults to key "new_shuffle_key" + required: false + example: "json_key" + schema: + type: string + - name: sort_key_list_one + description: Sort by this key before using list one for merging + required: false + example: "json_key" + schema: + type: string + - name: sort_key_list_two + description: Sort by this key before using list two for merging + required: false + example: "json_key" + schema: + type: string - name: diff_lists description: Diffs two lists of strings or integers and finds what's missing parameters: @@ -827,26 +973,19 @@ actions: - false schema: type: string - - name: escape_html - description: Performs HTML escaping on a field - parameters: - - name: input_data - description: The input data to use - required: true - multiline: true - example: '{"html": "hello"}' - schema: - type: string - - name: field_name - description: The field to HTML escape - required: true - multiline: true - example: my_unsafe_field - schema: - type: string - returns: - schema: - type: string + #- name: escape_html + # description: Performs HTML escaping on a field. Can be done with Liquid formatting instead!! + # parameters: + # - name: input_data + # description: The input data to use + # required: true + # multiline: true + # example: 'hello' + # schema: + # type: string + # returns: + # schema: + # type: string - name: base64_conversion description: Encode or decode a Base64 string parameters: @@ -864,6 +1003,7 @@ actions: options: - encode - decode + - "to image" schema: type: string - name: get_timestamp @@ -894,6 +1034,19 @@ actions: returns: schema: type: string + - name: list_cidr_ips + description: Lists the IPs for a CIDR + parameters: + - name: cidr + description: IP CIDR to check + multiline: false + example: "1.1.1.0/24" + required: True + schema: + type: string + returns: + schema: + type: string - name: cidr_ip_match description: Check if an IP is contained in a CIDR defined network parameters: @@ -931,16 +1084,7 @@ actions: example: '{"data": "Hello world"}' schema: type: string - - name: execute_python - description: Runs python with the data input. Any prints will be returned. - parameters: - - name: code - description: The code to run. Can be a file ID from within Shuffle. - required: true - multiline: true - example: print("hello world") - schema: - type: string + - name: run_math_operation description: Takes a math input and gives you the result parameters: @@ -954,6 +1098,356 @@ actions: returns: schema: type: string + - name: get_jwt_from_file + description: 'Loads a file from Shuffles file storage, then generates a JWT token from the info in the file. Built for Google services, but works for others using JWT generation as well. Generic audience: https://oauth2.googleapis.com/token ' + parameters: + - name: file_id + description: The File ID of your stored credentials + required: true + multiline: false + example: "File ID from /admin?tab=files" + schema: + type: string + - name: jwt_audience + description: The audience to use. + required: true + multiline: false + example: "https://oauth2.googleapis.com/token" + schema: + type: string + - name: scopes + description: SPACE separated scopes to be used + required: true + multiline: false + example: "https://www.googleapis.com/auth/devstorage.full_control https://www.googleapis.com/auth/devstorage.read_only https://www.googleapis.com/auth/devstorage.read_write" + schema: + type: string + - name: complete_request + description: Whether to finish the Oauth2 connection or not + required: true + multiline: false + options: + - true + - false + schema: + type: string + returns: + schema: + type: string + #- name: get_standardized_data + # description: 'Used to run standardized synonym translations of data to make it easier to use in automation. This can be done automatically in subflows as well' + # parameters: + # - name: json_input + # description: The full JSON blob to automatically translate + # required: true + # multiline: true + # example: '{"ref": "1234"}' + # schema: + # type: string + # - name: input_type + # description: The data type of the input + # required: true + # multiline: true + # example: 'cases' + # options: + # - cases + # schema: + # type: string + - name: generate_random_string + description: 'Used to generate passwords and random strings' + parameters: + - name: length + description: The length of the string. Defaults to 16 + required: false + multiline: false + example: '16' + schema: + type: string + - name: special_characters + description: Whether to include special characters or not + required: false + multiline: false + example: 'true' + options: + - true + - false + schema: + type: string + - name: merge_incoming_branches + description: 'Merges the data of incoming branches. Uses the input type to determine how to merge the data, and removes duplicates' + parameters: + - name: input_type + description: What type to use + required: false + multiline: false + example: 'list' + options: + - list + - dict + schema: + type: string + - name: run_ssh_command + description: 'Run a command on remote machine with SSH' + parameters: + - name: host + description: Host IP + required: true + multiline: false + example: '192.168.55.11' + schema: + type: string + - name: port + description: A port on which SSH service is running + required: false + multiline: false + example: 'Default is 22' + schema: + type: string + - name: user_name + description: User on remote system + required: true + multiline: false + example: 'root' + schema: + type: string + - name: private_key_file_id + description: Private key file ID + required: false + multiline: false + example: 'file_c5c87a50-4146-40e2-a698-78cf13bf65c0' + schema: + type: string + - name: password + description: Password for SSH user. Use either password or private key. + required: false + multiline: false + example: '***' + schema: + type: string + - name: command + description: Command you want to run + required: true + multiline: true + example: 'ls -la' + schema: + type: string + - name: if_else_routing + description: Routes based on if-else statements + parameters: + - name: conditions + description: The conditions to be met + required: true + multiline: true + example: "REPEATING: Hello world" + schema: + type: string + returns: + schema: + type: string + + - name: check_datastore_contains + description: We recommend "Search datastore category" instead. Checks Shuffle datastore whether a user-provided key contains a value. Returns ALL the values previously appended. + parameters: + - name: key + description: The key to get + required: true + multiline: false + example: "alert_ids" + schema: + type: string + - name: value + description: The value to check for and append if applicable + required: true + multiline: false + example: "1208301599081" + schema: + type: string + - name: append + description: Whether to auto-append the value if it doesn't exist in the cache + required: true + options: + - true + - false + multiline: false + example: "timestamp" + schema: + type: string + - name: category + description: The category to get the value from. Not required. + required: false + multiline: false + example: "tickets" + schema: + type: string + - name: return_values + description: Whether to include the cache values in the response + required: false + options: + - true + - false + multiline: false + example: "false" + value: "true" + schema: + type: string + returns: + schema: + type: string + - name: get_cache_value + description: Get a value saved to your organization in Shuffle. Deprecated for "get_datastore_value" + parameters: + - name: key + description: The key to get + required: true + multiline: false + example: "timestamp" + schema: + type: string + - name: category + description: The category to get the value from. Not required. + required: false + multiline: false + example: "tickets" + schema: + type: string + returns: + schema: + type: string + - name: delete_cache_value + + description: Delete a value saved to your organization in Shuffle. Deprecated for "delete_datastore_value" + parameters: + - name: key + description: The key to delete + required: true + multiline: false + example: "timestamp" + schema: + type: string + - name: category + description: The category to get the value from. Not required. + required: false + multiline: false + example: "tickets" + schema: + type: string + returns: + schema: + type: string + + - name: set_cache_value + description: Set a value to be saved to your organization in Shuffle. Deprecated for "set_datastore_value" + parameters: + - name: key + description: The key to set the value for + required: true + multiline: false + example: "timestamp" + schema: + type: string + - name: value + description: The value to set + required: true + multiline: true + example: "1621959545" + schema: + type: string + - name: category + description: The category to get the value from. Not required. + required: false + multiline: false + example: "tickets" + schema: + type: string + returns: + schema: + type: string + - name: check_cache_contains + description: Checks Shuffle cache whether a user-provided key contains a value. Returns ALL the values previously appended. Deprecated for "check datastore contains" + parameters: + - name: key + description: The key to get + required: true + multiline: false + example: "alert_ids" + schema: + type: string + - name: value + description: The value to check for and append if applicable + required: true + multiline: false + example: "1208301599081" + schema: + type: string + - name: append + description: Whether to auto-append the value if it doesn't exist in the cache + required: true + options: + - true + - false + multiline: false + example: "timestamp" + schema: + type: string + - name: category + description: The category to get the value from. Not required. + required: false + multiline: false + example: "tickets" + schema: + type: string + - name: return_values + description: Whether to include the cache values in the response + required: false + options: + - true + - false + multiline: false + example: "false" + value: "true" + schema: + type: string + #- name: parse_ioc_new + # description: Parse IOC's based on https://github.com/fhightower/ioc-finder + # parameters: + # - name: input_string + # description: The string to check + # required: true + # multiline: true + # example: "123ijq192.168.3.6kljqwiejs8 https://shuffler.io" + # schema: + # type: string + # - name: input_type + # description: The string to check + # required: false + # multiline: false + # example: "md5s" + # schema: + # type: string + # returns: + # schema: + # type: string + # + - name: get_ioc + description: Get IOC's saved to your organization in Shuffle + parameters: + - name: ioc + description: The IOC to look for in Shuffle's datastore + required: true + multiline: true + example: "timestamp" + schema: + type: string + - name: data_type + description: The data type to get the IOC from. Discovered if not passed. + required: false + multiline: false + example: "ip" + schema: + type: string + returns: + schema: + type: string -# yamllint disable-line rule:line-length large_image: data:image/png;base64,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 +# yamllint disable-line rule:line-length diff --git a/shuffle-tools/1.2.0/docker-compose.yml b/shuffle-tools/1.2.0/docker-compose.yml deleted file mode 100644 index e48c6b2f..00000000 --- a/shuffle-tools/1.2.0/docker-compose.yml +++ /dev/null @@ -1,15 +0,0 @@ -version: '3.4' -services: - shuffle-tools: - build: - context: . - dockerfile: Dockerfile -# image: walkoff_registry:5000/walkoff_app_HelloWorld-v1-0 - deploy: - mode: replicated - replicas: 10 - restart_policy: - condition: none - restart: "no" - secrets: - - secret1 diff --git a/shuffle-tools/1.2.0/requirements.txt b/shuffle-tools/1.2.0/requirements.txt index 6b792a90..4fe45011 100644 --- a/shuffle-tools/1.2.0/requirements.txt +++ b/shuffle-tools/1.2.0/requirements.txt @@ -1,9 +1,11 @@ -ioc_finder==6.0.1 -py7zr==0.11.3 -rarfile==4.0 -pyminizip==0.2.4 -requests==2.25.1 -xmltodict==0.11.0 -json2xml==3.6.0 +ioc_finder==7.3.0 +py7zr==0.22.0 +rarfile==4.2 +pyzipper==0.3.6 +requests==2.32.3 +xmltodict==0.14.2 +json2xml==5.0.5 ipaddress==1.0.23 -liquidpy==0.7.1 +google.auth==2.37.0 +paramiko==3.5.0 +shuffle-sdk==0.0.31 diff --git a/shuffle-tools/1.2.0/run.sh b/shuffle-tools/1.2.0/run.sh old mode 100644 new mode 100755 index aaf4edf7..3480d2f8 --- a/shuffle-tools/1.2.0/run.sh +++ b/shuffle-tools/1.2.0/run.sh @@ -1,7 +1,7 @@ # Build testing -NAME=frikky/shuffle:shuffle-tools_1.1.0 +NAME=frikky/shuffle:shuffle-tools_1.2.0 docker rmi $NAME --force -docker build . -t frikky/shuffle:shuffle-tools_1.1.0 +docker build . -t frikky/shuffle:shuffle-tools_1.2.0 # Run testing #docker run -e SHUFFLE_SWARM_CONFIG=run -e SHUFFLE_APP_EXPOSED_PORT=33334 frikky/shuffle:shuffle-tools_1.1.0 diff --git a/shuffle-tools/1.2.0/src/app.py b/shuffle-tools/1.2.0/src/app.py index 982b4eb6..16323e4e 100644 --- a/shuffle-tools/1.2.0/src/app.py +++ b/shuffle-tools/1.2.0/src/app.py @@ -1,37 +1,56 @@ -import asyncio +import os +import sys +import builtins + +import hmac import datetime import json import time import markupsafe -import os import re import subprocess import tempfile import zipfile import base64 +import gzip import ipaddress import hashlib from io import StringIO from contextlib import redirect_stdout -from liquid import Liquid -import liquid - -import py7zr -import pyminizip -import rarfile -import requests -import tarfile +import random +import string import xmltodict from json2xml import json2xml from json2xml.utils import readfromstring from ioc_finder import find_iocs -from walkoff_app_sdk.app_base import AppBase +from dateutil.parser import parse as dateutil_parser +from google.auth import crypt +from google.auth import jwt +import py7zr +import pyzipper +import rarfile +import requests +import tarfile import binascii import struct +import paramiko +import concurrent.futures +import multiprocessing + +# from walkoff_app_sdk.app_base import AppBase +from shuffle_sdk import AppBase + +# Override exit(), sys.exit, and os._exit +# sys.exit() can be caught, meaning we can have a custom handler for it +builtins.exit = sys.exit +os.exit = sys.exit +os._exit = sys.exit + + class Tools(AppBase): __version__ = "1.2.0" app_name = ( @@ -45,6 +64,8 @@ def __init__(self, redis, logger, console_logger=None): :param logger: :param console_logger: """ + self.cache_update_buffer = [] + self.shared_cache = {} super().__init__(redis, logger, console_logger) def router(self): @@ -52,51 +73,100 @@ def router(self): def base64_conversion(self, string, operation): if operation == "encode": - encoded_bytes = base64.b64encode(string.encode("utf-8")) + # Try JSON decoding + try: + string = json.dumps(json.loads(string)) + except: + pass + + encoded_bytes = base64.b64encode(str(string).encode("utf-8")) encoded_string = str(encoded_bytes, "utf-8") return encoded_string + elif operation == "to image": + # Decode the base64 into an image and upload it as a file + decoded_bytes = base64.b64decode(string) + + # Make the bytes into unicode escaped bytes + # UnicodeDecodeError - 'utf-8' codec can't decode byte 0x89 in position 0: invalid start byte + try: + decoded_bytes = str(decoded_bytes, "utf-8") + except: + pass + + filename = "base64_image.png" + file = { + "filename": filename, + "data": decoded_bytes, + } + + fileret = self.set_files([file]) + value = {"success": True, "filename": filename, "file_id": fileret} + if len(fileret) == 1: + value = {"success": True, "filename": filename, "file_id": fileret[0]} + + return value + elif operation == "decode": + if "-" in string: + string = string.replace("-", "+", -1) + + if "_" in string: + string = string.replace("_", "/", -1) + + # Fix padding + if len(string) % 4 != 0: + string += "=" * (4 - len(string) % 4) + + # For loop this. It's stupid. + decoded_bytes = "" try: decoded_bytes = base64.b64decode(string) - try: - decoded_bytes = str(decoded_bytes, "utf-8") - except: - pass - - return decoded_bytes except Exception as e: - #return string.decode("utf-16") + return json.dumps( + { + "success": False, + "reason": "Invalid Base64 - %s" % e, + } + ) - self.logger.info(f"[WARNING] Error in normal decoding: {e}") - return { - "success": False, - "reason": f"Error decoding the base64: {e}", - } - #newvar = binascii.a2b_base64(string) - #try: - # if str(newvar).startswith("b'") and str(newvar).endswith("'"): - # newvar = newvar[2:-1] - #except Exception as e: - # self.logger.info(f"Encoding issue in base64: {e}") - #return newvar - - #try: - # return newvar - #except: - # pass + # if "incorrect padding" in str(e).lower(): + # try: + # decoded_bytes = base64.b64decode(string + "=") + # except Exception as e: + # if "incorrect padding" in str(e).lower(): + # try: + # decoded_bytes = base64.b64decode(string + "==") + # except Exception as e: + # if "incorrect padding" in str(e).lower(): + # try: + # decoded_bytes = base64.b64decode(string + "===") + # except Exception as e: + # if "incorrect padding" in str(e).lower(): + # return "Invalid Base64" - return { - "success": False, - "reason": "Error decoding the base64", - } + try: + decoded_bytes = str(decoded_bytes, "utf-8") + except: + pass + + # Check if json + try: + decoded_bytes = json.loads(decoded_bytes) + except: + pass + + return decoded_bytes - return json.dumps({ + return { "success": False, - "reason": "No base64 to be converted", - }) + "reason": "Invalid operation", + } def parse_list_internal(self, input_list): + if isinstance(input_list, list): + input_list = ",".join(input_list) + try: input_list = json.loads(input_list) if isinstance(input_list, list): @@ -123,13 +193,12 @@ def send_sms_shuffle(self, apikey, phone_numbers, body): url = "https://shuffler.io/api/v1/functions/sendsms" headers = {"Authorization": "Bearer %s" % apikey} - return requests.post(url, headers=headers, json=data).text + return requests.post(url, headers=headers, json=data, verify=False).text # This is an email function of Shuffle def send_email_shuffle(self, apikey, recipients, subject, body, attachments=""): recipients = self.parse_list_internal(recipients) - targets = [recipients] if ", " in recipients: targets = recipients.split(", ") @@ -137,10 +206,11 @@ def send_email_shuffle(self, apikey, recipients, subject, body, attachments=""): targets = recipients.split(",") data = { - "targets": targets, - "subject": subject, - "body": body, + "targets": targets, + "subject": subject, + "body": body, "type": "alert", + "email_app": True, } # Read the attachments @@ -151,19 +221,108 @@ def send_email_shuffle(self, apikey, recipients, subject, body, attachments=""): for item in attachments: new_file = self.get_file(file_ids) files.append(new_file) - + data["attachments"] = files except Exception as e: - self.logger.info(f"Error in attachment parsing for email: {e}") - + pass - url = "https://shuffler.io/api/v1/functions/sendmail" + url = "https://shuffler.io/functions/sendmail" headers = {"Authorization": "Bearer %s" % apikey} return requests.post(url, headers=headers, json=data).text def repeat_back_to_me(self, call): return call + def repeat_back_to_me2(self, body): + print("call:", body) + return body + + def dedup_and_merge(self, key, value, timeout, set_skipped=True): + timeout = int(timeout) + key = str(key) + + set_skipped = True + if str(set_skipped).lower() == "false": + set_skipped = False + else: + set_skipped = True + + cachekey = "dedup-%s" % (key) + response = { + "success": False, + "datastore_key": cachekey, + "info": "All keys from the last %d seconds with the key '%s' have been merged. The result was set to SKIPPED in all other actions." + % (timeout, key), + "timeout": timeout, + "original_value": value, + "all_values": [], + } + + found_cache = self.get_cache(cachekey) + + if found_cache["success"] == True and len(found_cache["value"]) > 0: + if "value" in found_cache: + if not str(found_cache["value"]).startswith("["): + found_cache["value"] = [found_cache["value"]] + else: + try: + found_cache["value"] = json.loads(found_cache["value"]) + except Exception as e: + self.logger.info("[ERROR] Failed parsing JSON: %s" % e) + else: + found_cache["value"] = [] + + found_cache["value"].append(value) + if "created" in found_cache: + if found_cache["created"] + timeout + 3 < time.time(): + set_skipped = False + response["success"] = True + response["all_values"] = found_cache["value"] + + self.delete_cache(cachekey) + + return json.dumps(response) + else: + self.logger.info( + "Dedup-key is already handled in another workflow with timeout %d" + % timeout + ) + + self.set_cache(cachekey, json.dumps(found_cache["value"])) + if set_skipped == True: + self.action_result["status"] = "SKIPPED" + self.action_result["result"] = json.dumps( + { + "status": False, + "reason": "Dedup-key is already handled in another workflow with timeout %d" + % timeout, + } + ) + + self.send_result( + self.action_result, + {"Authorization": "Bearer %s" % self.authorization}, + "/api/v1/streams", + ) + + return found_cache + + parsedvalue = [value] + resp = self.set_cache(cachekey, json.dumps(parsedvalue)) + + self.logger.info( + "Sleeping for %d seconds while waiting for cache to fill up elsewhere" + % timeout + ) + time.sleep(timeout) + found_cache = self.get_cache(cachekey) + + response["success"] = True + response["all_values"] = found_cache["value"] + + self.delete_cache(cachekey) + return json.dumps(response) + # https://github.com/fhightower/ioc-finder def parse_file_ioc(self, file_ids, input_type="all"): def parse(data): @@ -182,7 +341,8 @@ def parse(data): for subitem in subvalue: data = { "data": subitem, - "data_type": "%s_%s" % (key[:-1], subkey), + "data_type": "%s_%s" + % (key[:-1], subkey), } if data not in newarray: newarray.append(data) @@ -229,57 +389,16 @@ def parse(data): return "Invalid input" return return_value - # https://github.com/fhightower/ioc-finder - def parse_ioc(self, input_string, input_type="all"): - input_string = str(input_string) - if input_type == "": - input_type = "all" - else: - input_type = input_type.split(",") - - iocs = find_iocs(input_string) - newarray = [] - for key, value in iocs.items(): - if input_type != "all": - if key not in input_type: - continue - - if len(value) > 0: - for item in value: - # If in here: attack techniques. Shouldn't be 3 levels so no - # recursion necessary - if isinstance(value, dict): - for subkey, subvalue in value.items(): - if len(subvalue) > 0: - for subitem in subvalue: - data = { - "data": subitem, - "data_type": "%s_%s" % (key[:-1], subkey), - } - if data not in newarray: - newarray.append(data) - else: - data = {"data": item, "data_type": key[:-1]} - if data not in newarray: - newarray.append(data) - - # Reformatting IP - for item in newarray: - if "ip" in item["data_type"]: - item["data_type"] = "ip" - try: - item["is_private_ip"] = ipaddress.ip_address(item["data"]).is_private - except: - self.logger.info("Error parsing %s" % item["data"]) - + def parse_list(self, items, splitter="\n"): + # Check if it's already a list first try: - newarray = json.dumps(newarray) - except json.decoder.JSONDecodeError as e: - return "Failed to parse IOC's: %s" % e + newlist = json.loads(items) + if isinstance(newlist, list): + return newlist - return newarray + except Exception as e: + self.logger.info("[WARNING] Parse error - fallback: %s" % e) - def parse_list(self, items, splitter="\n"): if splitter == "": splitter = "\n" @@ -298,15 +417,11 @@ def get_length(self, item): return str(len(item)) def set_json_key(self, json_object, key, value): - self.logger.info(f"OBJ: {json_object}\nKEY: {key}\nVAL: {value}") if isinstance(json_object, str): try: json_object = json.loads(json_object) except json.decoder.JSONDecodeError as e: - return { - "success": False, - "reason": "Item is not valid JSON" - } + return {"success": False, "reason": "Item is not valid JSON"} if isinstance(json_object, list): if len(json_object) == 1: @@ -314,16 +429,15 @@ def set_json_key(self, json_object, key, value): else: return { "success": False, - "reason": "Item is valid JSON, but can't handle lists. Use .#" + "reason": "Item is valid JSON, but can't handle lists. Use .#", } - #if not isinstance(json_object, object): + # if not isinstance(json_object, object): # return { # "success": False, # "reason": "Item is not valid JSON (2)" # } - if isinstance(value, str): try: value = json.loads(value) @@ -333,7 +447,7 @@ def set_json_key(self, json_object, key, value): # Handle JSON paths if "." in key: base_object = json.loads(json.dumps(json_object)) - #base_object.output.recipients.notificationEndpointIds = ... + # base_object.output.recipients.notificationEndpointIds = ... keys = key.split(".") if len(keys) >= 1: @@ -342,15 +456,14 @@ def set_json_key(self, json_object, key, value): # This is awful :) buildstring = "base_object" for subkey in keys: - buildstring += f"[\"{subkey}\"]" + buildstring += f'["{subkey}"]' buildstring += f" = {value}" - self.logger.info("BUILD: %s" % buildstring) - #output = + # output = exec(buildstring) json_object = base_object - #json_object[first_object] = base_object + # json_object[first_object] = base_object else: json_object[key] = value @@ -419,9 +532,9 @@ def replace_value_from_dictionary(self, input_data, mapping, default_value=""): except: self.logger.info(f"Failed mapping output data for key {key}") - return input_data + return input_data - # Changed with 1.1.0 to run with different returns + # Changed with 1.1.0 to run with different returns def regex_capture_group(self, input_data, regex): try: returnvalues = { @@ -429,12 +542,11 @@ def regex_capture_group(self, input_data, regex): } matches = re.findall(regex, input_data) - self.logger.info(f"{matches}") found = False for item in matches: if isinstance(item, str): - found = True - name = "group_0" + found = True + name = "group_0" try: returnvalues[name].append(item) except: @@ -442,7 +554,7 @@ def regex_capture_group(self, input_data, regex): else: for i in range(0, len(item)): - found = True + found = True name = "group_%d" % i try: returnvalues[name].append(item[i]) @@ -458,23 +570,13 @@ def regex_capture_group(self, input_data, regex): "reason": "Bad regex pattern: %s" % e, } - def regex_replace( - self, input_data, regex, replace_string="", ignore_case="False" - ): - - #self.logger.info("=" * 80) - #self.logger.info(f"Regex: {regex}") - #self.logger.info(f"replace_string: {replace_string}") - #self.logger.info("=" * 80) - + def regex_replace(self, input_data, regex, replace_string="", ignore_case="False"): if ignore_case.lower().strip() == "true": return re.sub(regex, replace_string, input_data, flags=re.IGNORECASE) else: return re.sub(regex, replace_string, input_data) def execute_python(self, code): - self.logger.info(f"Python code {len(code)} {code}. If uuid, we'll try to download and use the file.") - if len(code) == 36 and "-" in code: filedata = self.get_file(code) if filedata["success"] == False: @@ -489,37 +591,82 @@ def execute_python(self, code): "message": f"Filename needs to contain .py", } - # Write the code to a file # 1. Take the data into a file # 2. Subprocess execute file? try: f = StringIO() - with redirect_stdout(f): - exec(code) # nosec :( + + def custom_print(*args, **kwargs): + return print(*args, file=f, **kwargs) + + # with redirect_stdout(f): # just in case + # Add globals in it too + globals_copy = globals().copy() + globals_copy["print"] = custom_print + try: + globals_copy["singul"] = self.singul + globals_copy["shuffle"] = self.singul + except Exception as e: + self.logger.info(f"Failed to add singul to python globals: {e}") + + # Add self to globals_copy + for key, value in locals().copy().items(): + if key not in globals_copy: + globals_copy[key] = value + + globals_copy["self"] = self + + try: + exec(code, globals_copy) + except SystemExit as e: + # Same as a return + pass + except SyntaxError as e: + # Special handler for return usage. Makes return act as + # an exit() + if "'return' outside function" in str(e): + return { + "success": False, + "message": f"SyntaxError - Shuffle Recommendation: Instead of using 'return' without a function, use 'exit()' to return when not inside a function. Raw Syntax error: {e}", + } + else: + return { + "success": False, + "message": f"Syntax Error: {e}", + } + + # this doesn't work to capture top-level returns + # Reason: SyntaxError makes it crash BEFORE it reaches the return s = f.getvalue() + f.close() # why: https://www.youtube.com/watch?v=6SA6S9Ca5-U - #try: + # try: # s = s.encode("utf-8") - #except Exception as e: - # self.logger.info(f"Failed utf-8 encoding response: {e}") + # except Exception as e: try: return { "success": True, - "message": s.strip(), + "message": json.loads(s.strip()), } except Exception as e: - return { - "success": True, - "message": s, - } - + try: + return { + "success": True, + "message": s.strip(), + } + except Exception as e: + return { + "success": True, + "message": s, + } + except Exception as e: return { "success": False, - "message": f"exception: {e}", + "message": f"Exception: {e}", } def execute_bash(self, code, shuffle_input): @@ -533,7 +680,6 @@ def execute_bash(self, code, shuffle_input): stdout = process.communicate() item = "" if len(stdout[0]) > 0: - self.logger.info("[DEBUG] Succesfully ran bash!") item = stdout[0] else: self.logger.info(f"[ERROR] FAILED to run bash command {code}!") @@ -547,35 +693,98 @@ def execute_bash(self, code, shuffle_input): return item + # Check if wildcardstring is in all_ips and support * as wildcard + def check_wildcard(self, wildcardstring, matching_string): + wildcardstring = str(wildcardstring.lower()) + if wildcardstring in str(matching_string).lower(): + return True + else: + wildcardstring = wildcardstring.replace(".", "\\.") + wildcardstring = wildcardstring.replace("*", ".*") + + if re.match(wildcardstring, str(matching_string).lower()): + return True + + return False + + def preload_cache(self, key): + org_id = self.full_execution["workflow"]["execution_org"]["id"] + url = f"{self.url}/api/v1/orgs/{org_id}/get_cache" + data = { + "workflow_id": self.full_execution["workflow"]["id"], + "execution_id": self.current_execution_id, + "authorization": self.authorization, + "org_id": org_id, + "key": key, + } + get_response = requests.post(url, json=data, verify=False) + response_data = get_response.json() + if "value" in response_data: + raw_value = response_data["value"] + if isinstance(raw_value, str): + try: + parsed = json.loads(raw_value) + except json.JSONDecodeError: + parsed = [raw_value] + else: + parsed = raw_value + + if not isinstance(parsed, list): + parsed = [parsed] + + response_data["value"] = parsed + return get_response.json() + + def update_cache(self, key): + org_id = self.full_execution["workflow"]["execution_org"]["id"] + url = f"{self.url}/api/v1/orgs/{org_id}/set_cache" + data = { + "workflow_id": self.full_execution["workflow"]["id"], + "execution_id": self.current_execution_id, + "authorization": self.authorization, + "org_id": org_id, + "key": key, + "value": json.dumps(self.shared_cache["value"]), + } + + get_response = requests.post(url, json=data, verify=False) + self.cache_update_buffer = [] + return get_response.json() + def filter_list(self, input_list, field, check, value, opposite): - self.logger.info(f"\nRunning function with list {input_list}") + # Remove hashtags on the fly + # E.g. #.fieldname or .#.fieldname flip = False if str(opposite).lower() == "true": flip = True try: - #input_list = eval(input_list) # nosec + # input_list = eval(input_list) # nosec input_list = json.loads(input_list) except Exception: try: input_list = input_list.replace("'", '"', -1) input_list = json.loads(input_list) except Exception: - self.logger.info("[WARNING] Error parsing string to array. Continuing anyway.") + self.logger.info( + "[WARNING] Error parsing string to array. Continuing anyway." + ) # Workaround D: if not isinstance(input_list, list): return { "success": False, - "reason": "Error: input isnt a list. Remove # to use this action.", + "reason": "Error: input isnt a list. Please use conditions instead if using JSON.", "valid": [], "invalid": [], } input_list = [input_list] - self.logger.info(f"\nRunning with check \"%s\" on list of length %d\n" % (check, len(input_list))) + if str(value).lower() == "null" or str(value).lower() == "none": + value = "none" + found_items = [] new_list = [] failed_list = [] @@ -596,127 +805,98 @@ def filter_list(self, input_list, field, check, value, opposite): try: tmp = json.dumps(tmp) except json.decoder.JSONDecodeError as e: - self.logger.info("FAILED DECODING: %s" % e) pass - #self.logger.info("PRE CHECKS FOR TMP: %") - # EQUALS JUST FOR STR if check == "equals": # Mostly for bools # value = tmp.lower() if str(tmp).lower() == str(value).lower(): - self.logger.info("APPENDED BECAUSE %s %s %s" % (field, check, value)) - if not flip: - new_list.append(item) - else: - failed_list.append(item) + new_list.append(item) else: - if flip: + failed_list.append(item) + + elif check == "equals any of": + value = self.parse_list_internal(value) + checklist = value.split(",") + found = False + for subcheck in checklist: + subcheck = str(subcheck).strip() + + # ext.lower().strip() == value.lower().strip() + if type(tmp) == list and subcheck in tmp: + new_list.append(item) + found = True + break + elif type(tmp) == str and tmp == subcheck: new_list.append(item) + found = True + break + elif type(tmp) == int and str(tmp) == subcheck: + new_list.append(item) + found = True + break else: - failed_list.append(item) + if str(tmp) == str(subcheck): + new_list.append(item) + found = True + break + + if not found: + failed_list.append(item) # IS EMPTY FOR STR OR LISTS elif check == "is empty": - if tmp == "[]": + if str(tmp) == "[]": tmp = [] - if type(tmp) == list and len(tmp) == 0 and not flip: - new_list.append(item) - elif type(tmp) == list and len(tmp) > 0 and flip: - new_list.append(item) - elif type(tmp) == str and not tmp and not flip: + if str(tmp) == "{}": + tmp = [] + + if type(tmp) == list and len(tmp) == 0: new_list.append(item) - elif type(tmp) == str and tmp and flip: + elif type(tmp) == str and not tmp: new_list.append(item) else: failed_list.append(item) # STARTS WITH = FOR STR OR [0] FOR LIST elif check == "starts with": - if type(tmp) == list and tmp[0] == value and not flip: - new_list.append(item) - elif type(tmp) == list and tmp[0] != value and flip: + if type(tmp) == list and tmp[0] == value: new_list.append(item) - elif type(tmp) == str and tmp.startswith(value) and not flip: - new_list.append(item) - elif type(tmp) == str and not tmp.startswith(value) and flip: + elif type(tmp) == str and tmp.startswith(value): new_list.append(item) else: failed_list.append(item) # ENDS WITH = FOR STR OR [-1] FOR LIST elif check == "ends with": - if type(tmp) == list and tmp[-1] == value and not flip: - new_list.append(item) - elif type(tmp) == list and tmp[-1] != value and flip: + if type(tmp) == list and tmp[-1] == value: new_list.append(item) - elif type(tmp) == str and tmp.endswith(value) and not flip: - new_list.append(item) - elif type(tmp) == str and not tmp.endswith(value) and flip: + elif type(tmp) == str and tmp.endswith(value): new_list.append(item) else: failed_list.append(item) # CONTAINS FIND FOR LIST AND IN FOR STR elif check == "contains": - if type(tmp) == list and value.lower() in tmp and not flip: - new_list.append(item) - elif type(tmp) == list and value.lower() not in tmp and flip: - new_list.append(item) - elif ( - type(tmp) == str - and tmp.lower().find(value.lower()) != -1 - and not flip - ): - new_list.append(item) - elif ( - type(tmp) == str - and tmp.lower().find(value.lower()) == -1 - and flip + # if str(value).lower() in str(tmp).lower(): + if str(value).lower() in str(tmp).lower() or self.check_wildcard( + value, tmp ): new_list.append(item) else: failed_list.append(item) + elif check == "contains any of": - self.logger.info("Inside contains any of") + value = self.parse_list_internal(value) checklist = value.split(",") - self.logger.info("Checklist and tmp: %s - %s" % (checklist, tmp)) found = False - for subcheck in checklist: - subcheck = subcheck.strip().lower() - #ext.lower().strip() == value.lower().strip() - if type(tmp) == list and subcheck in tmp and not flip: - new_list.append(item) - found = True - break - elif type(tmp) == list and subcheck in tmp and flip: - failed_list.append(item) - found = True - break - elif type(tmp) == list and subcheck not in tmp and not flip: - new_list.append(item) - found = True - break - elif type(tmp) == list and subcheck not in tmp and flip: - failed_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) != -1 and not flip): - new_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) != -1 and flip): - failed_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) == -1 and not flip): - failed_list.append(item) - found = True - break - elif (type(tmp) == str and tmp.lower().find(subcheck) == -1 and flip): + for checker in checklist: + if str(checker).lower() in str( + tmp + ).lower() or self.check_wildcard(checker, tmp): new_list.append(item) found = True break @@ -726,63 +906,93 @@ def filter_list(self, input_list, field, check, value, opposite): # CONTAINS FIND FOR LIST AND IN FOR STR elif check == "field is unique": - #self.logger.info("FOUND: %s" - if tmp.lower() not in found_items and not flip: - new_list.append(item) - found_items.append(tmp.lower()) - elif tmp.lower() in found_items and flip: + if tmp.lower() not in found_items: new_list.append(item) found_items.append(tmp.lower()) else: failed_list.append(item) - #tmp = json.dumps(tmp) - - #for item in new_list: - #if type(tmp) == list and value.lower() in tmp and not flip: - # new_list.append(item) - # found = True - # break - #elif type(tmp) == list and value.lower() not in tmp and flip: - # new_list.append(item) - # found = True - # break - # CONTAINS FIND FOR LIST AND IN FOR STR - elif check == "contains any of": - value = self.parse_list_internal(value) - checklist = value.split(",") - tmp = tmp.lower() - self.logger.info("CHECKLIST: %s. Value: %s" % (checklist, tmp)) - found = False - for value in checklist: - if value in tmp and not flip: - new_list.append(item) - found = True - break - elif value not in tmp and flip: + elif check == "larger than": + list_set = False + try: + if str(tmp).isdigit() and str(value).isdigit(): + if int(tmp) > int(value): + new_list.append(item) + list_set = True + except AttributeError as e: + pass + + try: + value = len(json.loads(value)) + except Exception as e: + pass + + try: + # Check if it's a list in autocast and if so, check the length + if len(json.loads(tmp)) > int(value): new_list.append(item) - found = True - break + list_set = True + except Exception as e: + pass - if not found: + if not list_set: failed_list.append(item) + elif check == "less than": + # Old + # if int(tmp) < int(value): + # new_list.append(item) + # else: + # failed_list.append(item) - elif check == "larger than": - if int(tmp) > int(value) and not flip: - new_list.append(item) - elif int(tmp) > int(value) and flip: - new_list.append(item) - else: + list_set = False + try: + if str(tmp).isdigit() and str(value).isdigit(): + if int(tmp) < int(value): + new_list.append(item) + list_set = True + except AttributeError as e: + pass + + try: + value = len(json.loads(value)) + except Exception as e: + pass + + try: + # Check if it's a list in autocast and if so, check the length + if len(json.loads(tmp)) < int(value): + new_list.append(item) + list_set = True + except Exception as e: + pass + + if not list_set: failed_list.append(item) - elif check == "less than": - if int(tmp) < int(value) and not flip: - new_list.append(item) - elif int(tmp) < int(value) and flip: + + elif check == "in cache key": + if item == input_list[0]: + self.shared_cache = self.preload_cache(key=value) + + ret = self.check_cache_contains(value, tmp, "true") + + if ret["success"] == True and ret["found"] == True: new_list.append(item) else: failed_list.append(item) + if len(self.cache_update_buffer) > 400 or ( + item == input_list[-1] and len(self.cache_update_buffer) > 0 + ): + self.update_cache(value) + + # return { + # "success": True, + # "found": False, + # "key": key, + # "value": new_value, + # } + # SINGLE ITEM COULD BE A FILE OR A LIST OF FILES elif check == "files by extension": if type(tmp) == list: @@ -791,12 +1001,7 @@ def filter_list(self, input_list, field, check, value, opposite): for file_id in tmp: filedata = self.get_file(file_id) _, ext = os.path.splitext(filedata["filename"]) - if ( - ext.lower().strip() == value.lower().strip() - and not flip - ): - file_list.append(file_id) - elif ext.lower().strip() != value.lower().strip() and flip: + if ext.lower().strip() == value.lower().strip(): file_list.append(file_id) # else: # failed_list.append(file_id) @@ -815,26 +1020,28 @@ def filter_list(self, input_list, field, check, value, opposite): elif type(tmp) == str: filedata = self.get_file(tmp) _, ext = os.path.splitext(filedata["filename"]) - if ext.lower().strip() == value.lower().strip() and not flip: + if ext.lower().strip() == value.lower().strip(): new_list.append(item) - elif ext.lower().strip() != value.lower().strip() and flip: - new_list.append((item, ext)) else: failed_list.append(item) except Exception as e: - self.logger.info("[WARNING] FAILED WITH EXCEPTION: %s" % e) failed_list.append(item) # return + if flip: + tmplist = new_list + new_list = failed_list + failed_list = tmplist + try: - return json.dumps( - { - "success": True, - "valid": new_list, - "invalid": failed_list, - } - ) + data = { + "success": True, + "valid": new_list, + "invalid": failed_list, + } + + return json.dumps(data) # new_list = json.dumps(new_list) except json.decoder.JSONDecodeError as e: return json.dumps( @@ -846,7 +1053,7 @@ def filter_list(self, input_list, field, check, value, opposite): return new_list - #def multi_list_filter(self, input_list, field, check, value): + # def multi_list_filter(self, input_list, field, check, value): # input_list = input_list.replace("'", '"', -1) # input_list = json.loads(input_list) @@ -911,8 +1118,8 @@ def get_file_meta(self, file_id): "%s/api/v1/files/%s?execution_id=%s" % (self.url, file_id, self.current_execution_id), headers=headers, + verify=False, ) - self.logger.info(f"RET: {ret}") return ret.text @@ -921,27 +1128,35 @@ def delete_file(self, file_id): headers = { "Authorization": "Bearer %s" % self.authorization, } - self.logger.info("HEADERS: %s" % headers) ret = requests.delete( "%s/api/v1/files/%s?execution_id=%s" % (self.url, file_id, self.current_execution_id), headers=headers, + verify=False, ) return ret.text - def create_file(self, filename, data): - self.logger.info("Inside function") + def create_file(self, filename, data, category=""): + try: + if str(data).startswith("b'") and str(data).endswith("'"): + data = data[2:-1] + if str(data).startswith('"') and str(data).endswith('"'): + data = data[2:-1] + except Exception as e: + self.logger.info(f"Exception: {e}") - #try: - # if str(data).startswith("b'") and str(data).endswith("'"): - # data = data[2:-1] - #except Exception as e: - # self.logger.info(f"Exception: {e}") + try: + # if not isinstance(data, str) and not isinstance(data, int) and not isinstance(float) and not isinstance(data, bool): + if isinstance(data, dict) or isinstance(data, list): + data = json.dumps(data) + except: + pass filedata = { "filename": filename, "data": data, + "namespace": category, } fileret = self.set_files([filedata]) @@ -949,27 +1164,47 @@ def create_file(self, filename, data): if len(fileret) == 1: value = {"success": True, "filename": filename, "file_id": fileret[0]} - return value + return value + + # Input is WAS a file, hence it didn't get the files + def list_file_category_ids(self, file_category): + return self.get_file_category_ids(file_category) - # Input is WAS a file, hence it didn't get the files - def get_file_value(self, filedata): - filedata = self.get_file(filedata) + # Input is WAS a file, hence it didn't get the files + # Category doesn't matter as it uses file ID, which is unique anyway + def get_file_value(self, filedata, category=""): + filedata = self.get_file(filedata, category) if filedata is None: - return "File is empty?" + return { + "success": False, + "reason": "File not found", + } + + if "data" not in filedata: + return { + "success": False, + "reason": "File content not found. File might be empty or not exist", + } - self.logger.info("INSIDE APP DATA: %s" % filedata) try: return filedata["data"].decode() except: try: return filedata["data"].decode("utf-16") except: - return { - "success": False, - "reason": "Got the file, but the encoding can't be printed", - } + try: + return filedata["data"].decode("utf-8") + except: + try: + return filedata["data"].decode("latin-1") + except: + return { + "success": False, + "reason": "Got the file, but the encoding can't be printed", + "size": len(filedata["data"]), + } - def download_remote_file(self, url, custom_filename=""): + def download_remote_file(self, url, custom_filename="", category=""): ret = requests.get(url, verify=False) # nosec filename = url.split("/")[-1] if "?" in filename: @@ -983,6 +1218,7 @@ def download_remote_file(self, url, custom_filename=""): { "filename": filename, "data": ret.content, + "namespace": category, } ] ) @@ -994,7 +1230,6 @@ def download_remote_file(self, url, custom_filename=""): return value - def extract_archive(self, file_id, fileformat="zip", password=None): try: return_data = {"success": False, "files": []} @@ -1002,9 +1237,7 @@ def extract_archive(self, file_id, fileformat="zip", password=None): item = self.get_file(file_id) return_ids = None - self.logger.info("Working with fileformat %s" % fileformat) with tempfile.TemporaryDirectory() as tmpdirname: - # Get archive and save phisically with open(os.path.join(tmpdirname, "archive"), "wb") as f: f.write(item["data"]) @@ -1014,13 +1247,12 @@ def extract_archive(self, file_id, fileformat="zip", password=None): # Zipfile for zipped archive if fileformat.strip().lower() == "zip": try: - self.logger.info("Starting zip extraction") - with zipfile.ZipFile(os.path.join(tmpdirname, "archive")) as z_file: + with zipfile.ZipFile( + os.path.join(tmpdirname, "archive") + ) as z_file: if password: - self.logger.info("In zip extraction with password") z_file.setpassword(bytes(password.encode())) - self.logger.info("Past zip extraction") for member in z_file.namelist(): filename = os.path.basename(member) if not filename: @@ -1028,7 +1260,10 @@ def extract_archive(self, file_id, fileformat="zip", password=None): source = z_file.open(member) to_be_uploaded.append( - {"filename": source.name, "data": source.read()} + { + "filename": source.name.split("/")[-1], + "data": source.read(), + } ) return_data["success"] = True @@ -1053,9 +1288,13 @@ def extract_archive(self, file_id, fileformat="zip", password=None): filename = os.path.basename(member) if not filename: continue + source = z_file.open(member) to_be_uploaded.append( - {"filename": source.name, "data": source.read()} + { + "filename": source.name.split("/")[-1], + "data": source.read(), + } ) return_data["success"] = True @@ -1076,9 +1315,13 @@ def extract_archive(self, file_id, fileformat="zip", password=None): ) as z_file: for member in z_file.getnames(): member_files = z_file.extractfile(member) + + if not member_files: + continue + to_be_uploaded.append( { - "filename": member, + "filename": member.split("/")[-1], "data": member_files.read(), } ) @@ -1099,13 +1342,19 @@ def extract_archive(self, file_id, fileformat="zip", password=None): ) as z_file: for member in z_file.getnames(): member_files = z_file.extractfile(member) + + if not member_files: + continue + to_be_uploaded.append( { - "filename": member, + "filename": member.split("/")[-1], "data": member_files.read(), } ) + return_data["success"] = True + except Exception as e: return_data["files"].append( { @@ -1128,7 +1377,7 @@ def extract_archive(self, file_id, fileformat="zip", password=None): filename = filename.split("/")[-1] to_be_uploaded.append( { - "filename": item["filename"], + "filename": item["filename"].split("/")[-1], "data": source.read(), } ) @@ -1145,10 +1394,8 @@ def extract_archive(self, file_id, fileformat="zip", password=None): else: return "No such format: %s" % fileformat - self.logger.info("Breaking as this only handles one archive at a time.") if len(to_be_uploaded) > 0: return_ids = self.set_files(to_be_uploaded) - self.logger.info(f"Got return ids from files: {return_ids}") for i in range(len(return_ids)): return_data["archive_id"] = file_id @@ -1168,7 +1415,6 @@ def extract_archive(self, file_id, fileformat="zip", password=None): } ) else: - self.logger.info(f"No file ids to upload.") return_data["success"] = False return_data["files"].append( { @@ -1202,7 +1448,6 @@ def create_archive(self, file_ids, fileformat, name, password=None): "reason": "Make sure to send valid file ids. Example: file_13eea837-c56a-4d52-a067-e673c7186483,file_13eea837-c56a-4d52-a067-e673c7186484", } - self.logger.info("picking {}".format(file_ids)) # GET all items from shuffle items = [self.get_file(file_id) for file_id in file_ids] @@ -1212,22 +1457,31 @@ def create_archive(self, file_ids, fileformat, name, password=None): # Dump files on disk, because libs want path :( with tempfile.TemporaryDirectory() as tmpdir: paths = [] - self.logger.info("Number 1") for item in items: with open(os.path.join(tmpdir, item["filename"]), "wb") as f: f.write(item["data"]) paths.append(os.path.join(tmpdir, item["filename"])) # Create archive temporary - self.logger.info("{} items to inflate".format(len(items))) with tempfile.NamedTemporaryFile() as archive: - if fileformat == "zip": archive_name = "archive.zip" if not name else name - pyminizip.compress_multiple( - paths, [], archive.name, password, 5 + + pwd = ( + password + if isinstance(password, (bytes, bytearray)) + else password.encode() ) + with pyzipper.AESZipFile( + archive.name, "w", compression=pyzipper.ZIP_DEFLATED + ) as zf: + zf.setpassword(pwd) + zf.setencryption(pyzipper.WZ_AES, nbits=256) + + for path in paths: + zf.write(path, arcname=os.path.basename(path)) + elif fileformat == "7zip": archive_name = "archive.7z" if not name else name with py7zr.SevenZipFile( @@ -1258,36 +1512,44 @@ def create_archive(self, file_ids, fileformat, name, password=None): return {"success": False, "message": excp} def add_list_to_list(self, list_one, list_two): - if not isinstance(list_one, list) and not isinstance(list_one, dict): - if not list_one or list_one == " " or list_one == "None" or list_one == "null": + if not isinstance(list_one, list) and not isinstance(list_one, dict): + if ( + not list_one + or list_one == " " + or list_one == "None" + or list_one == "null" + ): list_one = "[]" try: list_one = json.loads(list_one) except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list1 as json: %s" % e) if list_one == None: list_one = [] else: return { "success": False, - "reason": f"List one is not a valid list: {list_one}" + "reason": f"List one is not a valid list: {list_one}", } if not isinstance(list_two, list) and not isinstance(list_two, dict): - if not list_two or list_two == " " or list_two == "None" or list_two == "null": + if ( + not list_two + or list_two == " " + or list_two == "None" + or list_two == "null" + ): list_two = "[]" try: list_two = json.loads(list_two) except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list2 as json: %s" % e) if list_one == None: list_one = [] else: return { "success": False, - "reason": f"List two is not a valid list: {list_two}" + "reason": f"List two is not a valid list: {list_two}", } if isinstance(list_one, dict): @@ -1305,21 +1567,13 @@ def diff_lists(self, list_one, list_two): try: list_one = json.loads(list_one) except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list1 as json: %s" % e) - return { - "success": False, - "reason": "list_one is not a valid list." - } + return {"success": False, "reason": "list_one is not a valid list."} if isinstance(list_two, str): try: list_two = json.loads(list_two) except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list2 as json: %s" % e) - return { - "success": False, - "reason": "list_two is not a valid list." - } + return {"success": False, "reason": "list_two is not a valid list."} def diff(li1, li2): try: @@ -1328,7 +1582,7 @@ def diff(li1, li2): # Bad json diffing - at least order doesn't matter :) not_found = [] for item in list_one: - #item = sorted(item.items()) + # item = sorted(item.items()) if item in list_two: pass else: @@ -1356,39 +1610,59 @@ def diff(li1, li2): "diff": newdiff, } - def merge_lists(self, list_one, list_two, set_field="", sort_key_list_one="", sort_key_list_two=""): + def merge_lists( + self, + list_one, + list_two, + set_field="", + sort_key_list_one="", + sort_key_list_two="", + ): if isinstance(list_one, str): try: list_one = json.loads(list_one) except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list1 as json: %s" % e) + pass if isinstance(list_two, str): try: list_two = json.loads(list_two) except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list2 as json: %s" % e) + pass if not isinstance(list_one, list) or not isinstance(list_two, list): - return {"success": False, "message": "Input lists need to be valid JSON lists."} + if isinstance(list_one, dict) and isinstance(list_two, dict): + for key, value in list_two.items(): + list_one[key] = value + + return list_one + + return { + "success": False, + "message": "Both input lists need to be valid JSON lists.", + } if len(list_one) != len(list_two): - return {"success": False, "message": "Lists length must be the same. %d vs %d" % (len(list_one), len(list_two))} + return { + "success": False, + "message": "Lists length must be the same. %d vs %d. Are you trying to add them to a single list? Use add_list_to_list" + % (len(list_one), len(list_two)), + } if len(sort_key_list_one) > 0: - self.logger.info("Sort 1 %s by key: %s" % (list_one, sort_key_list_one)) try: - list_one = sorted(list_one, key=lambda k: k.get(sort_key_list_one), reverse=True) + list_one = sorted( + list_one, key=lambda k: k.get(sort_key_list_one), reverse=True + ) except: - self.logger.info("Failed to sort list one") pass if len(sort_key_list_two) > 0: - #self.logger.info("Sort 2 %s by key: %s" % (list_two, sort_key_list_two)) try: - list_two = sorted(list_two, key=lambda k: k.get(sort_key_list_two), reverse=True) + list_two = sorted( + list_two, key=lambda k: k.get(sort_key_list_two), reverse=True + ) except: - self.logger.info("Failed to sort list one") pass # Loops for each item in sub array and merges items together @@ -1396,16 +1670,17 @@ def merge_lists(self, list_one, list_two, set_field="", sort_key_list_one="", so base_key = "shuffle_auto_merge" try: for i in range(len(list_one)): - #self.logger.info(list_two[i]) if isinstance(list_two[i], dict): for key, value in list_two[i].items(): list_one[i][key] = value elif isinstance(list_two[i], str) and list_two[i] == "": continue - elif isinstance(list_two[i], str) or isinstance(list_two[i], int) or isinstance(list_two[i], bool): - self.logger.info("IN SETTER FOR %s" % list_two[i]) + elif ( + isinstance(list_two[i], str) + or isinstance(list_two[i], int) + or isinstance(list_two[i], bool) + ): if len(set_field) == 0: - self.logger.info("Define a JSON key to set for List two (Set Field)") list_one[i][base_key] = list_two[i] else: set_field = set_field.replace(" ", "_", -1) @@ -1419,6 +1694,57 @@ def merge_lists(self, list_one, list_two, set_field="", sort_key_list_one="", so return list_one + def merge_json_objects( + self, + list_one, + list_two, + set_field="", + sort_key_list_one="", + sort_key_list_two="", + ): + return self.merge_lists( + list_one, + list_two, + set_field=set_field, + sort_key_list_one=sort_key_list_one, + sort_key_list_two=sort_key_list_two, + ) + + def fix_json(self, json_data): + try: + deletekeys = [] + copied_dict = json_data.copy() + + for key, value in copied_dict.items(): + if "@" in key or "." in key or " " in key: + deletekeys.append(key) + + key = key.replace("@", "", -1) + key = key.replace(".", "", -1) + key = key.replace(" ", "_", -1) + json_data[key] = value + + if isinstance(value, dict): + json_data[key] = self.fix_json(value) + else: + json_data[key] = value + + # elif isinstance(value, list): + # json_data[key] = value + # else: + # json_data[key] = value + # #for item in json_data[key]: + # # if isinstance(item, dict): + # # json_data[ + + for key in deletekeys: + del json_data[key] + + except Exception as e: + pass + + return json_data + def xml_json_convertor(self, convertto, data): if isinstance(data, dict) or isinstance(data, list): try: @@ -1428,28 +1754,19 @@ def xml_json_convertor(self, convertto, data): try: if convertto == "json": - data = data.replace(" encoding=\"utf-8\"", " ") + data = data.replace(' encoding="utf-8"', " ") ans = xmltodict.parse(data) + ans = self.fix_json(ans) json_data = json.dumps(ans) + return json_data else: ans = readfromstring(data) return json2xml.Json2xml(ans, wrapper="all", pretty=True).to_xml() except Exception as e: - return { - "success": False, - "input": data, - "reason": f"{e}" - } + return {"success": False, "input": data, "reason": f"{e}"} def date_to_epoch(self, input_data, date_field, date_format): - - self.logger.info( - "Executing with {} on {} with format {}".format( - input_data, date_field, date_format - ) - ) - if isinstance(input_data, str): result = json.loads(input_data) else: @@ -1465,13 +1782,12 @@ def date_to_epoch(self, input_data, date_field, date_format): def compare_relative_date( self, timestamp, date_format, equality_test, offset, units, direction ): - - if timestamp== "None": + if timestamp == "None": return False - self.logger.info("Converting input date.") - - if date_format != "%s": + if date_format == "autodetect": + input_dt = dateutil_parser(timestamp).replace(tzinfo=None) + elif date_format != "%s": input_dt = datetime.datetime.strptime(timestamp, date_format) else: input_dt = datetime.datetime.utcfromtimestamp(float(timestamp)) @@ -1490,35 +1806,54 @@ def compare_relative_date( if utc_format.endswith("%z"): utc_format = utc_format.replace("%z", "Z") - if date_format != "%s": + # if date_format != "%s" and date_format != "autodetect": + if date_format == "autodetect": + formatted_dt = datetime.datetime.utcnow() + delta + elif date_format != "%s": formatted_dt = datetime.datetime.strptime( datetime.datetime.utcnow().strftime(utc_format), date_format ) + else: formatted_dt = datetime.datetime.utcnow() - self.logger.info("Formatted time is: {}".format(formatted_dt)) - if direction == "ago": + if date_format == "autodetect": + comparison_dt = formatted_dt + elif direction == "ago": comparison_dt = formatted_dt - delta + # formatted_dt - delta + # comparison_dt = datetime.datetime.utcnow() else: comparison_dt = formatted_dt + delta - self.logger.info("{} {} {} is {}".format(offset, units, direction, comparison_dt)) + # comparison_dt = datetime.datetime.utcnow() + + diff = int((input_dt - comparison_dt).total_seconds()) + + if units == "seconds": + diff = diff + elif units == "minutes": + diff = int(diff / 60) + elif units == "hours": + diff = int(diff / 3600) + elif units == "days": + diff = int(diff / 86400) + elif units == "week": + diff = int(diff / 604800) - diff = (input_dt - comparison_dt).total_seconds() - self.logger.info( - "Difference between {} and {} is {}".format(timestamp, comparison_dt, diff) - ) result = False if equality_test == ">": result = 0 > diff if direction == "ahead": result = not (result) + elif equality_test == "<": result = 0 < diff if direction == "ahead": result = not (result) + elif equality_test == "=": result = diff == 0 + elif equality_test == "!=": result = diff != 0 elif equality_test == ">=": @@ -1530,41 +1865,43 @@ def compare_relative_date( if direction == "ahead" and diff != 0: result = not (result) - self.logger.info( - "At {}, is {} {} than {} {} {}? {}".format( - formatted_dt, - timestamp, - equality_test, - offset, - units, - direction, - result, - ) - ) + parsed_string = "%s %s %s %s" % (equality_test, offset, units, direction) + newdiff = diff + if newdiff < 0: + newdiff = newdiff * -1 - return result + return { + "success": True, + "date": timestamp, + "check": parsed_string, + "result": result, + "diff": { + "days": int(int(newdiff) / 86400), + }, + } def run_math_operation(self, operation): - self.logger.info("Operation: %s" % operation) result = eval(operation) return result # This is kind of stupid - def escape_html(self, input_data, field_name): + def escape_html(self, input_data): if isinstance(input_data, str): mapping = json.loads(input_data) else: mapping = input_data - self.logger.info(f"Got mapping {json.dumps(mapping, indent=2)}") - - result = markupsafe.escape(mapping[field_name]) - self.logger.info(f"Mapping {input_data} to {result}") - - mapping[field_name] = result + result = markupsafe.escape(mapping) return mapping - def check_cache_contains(self, key, value, append): + def check_datastore_contains( + self, key, value, append, category="", return_values="true" + ): + return check_cache_contains(self, key, value, append, category, return_values) + + def check_cache_contains( + self, key, value, append, category="", return_values="true" + ): org_id = self.full_execution["workflow"]["execution_org"]["id"] url = "%s/api/v1/orgs/%s/get_cache" % (self.url, org_id) data = { @@ -1572,25 +1909,69 @@ def check_cache_contains(self, key, value, append): "execution_id": self.current_execution_id, "authorization": self.authorization, "org_id": org_id, + "search": str(value), "key": key, } + if category: + data["category"] = category + + directcall = False + allvalues = {} + try: + for item in self.local_storage: + if ( + item["execution_id"] == self.current_execution_id + and item["key"] == key + ): + # Max keeping the local cache properly for 5 seconds due to workflow continuations + elapsed_time = time.time() - item["time_set"] + if elapsed_time > 5: + break + + allvalues = item["data"] + + except Exception as e: + print( + "[ERROR] Failed cache contains for current execution id local storage: %s" + % e + ) + if isinstance(value, dict) or isinstance(value, list): try: value = json.dumps(value) except Exception as e: - self.logger.info(f"[WARNING] Error in JSON dumping (cache contains): {e}") - elif not isinstance(value, str): + pass + + if not isinstance(value, str): value = str(value) - if append.lower() == "true": + data["search"] = value + + if str(append).lower() == "true": append = True else: - append = False + append = False + + include_values = str(return_values).lower() == "true" + + if "success" not in allvalues: + # get_response = requests.post(url, json=data, verify=False) + pass - get_response = requests.post(url, json=data) try: - allvalues = get_response.json() + if "success" not in allvalues: + # allvalues = get_response.json() + allvalues = self.shared_cache + + if "success" not in allvalues: + if category: + data["category"] = category + + get_response = requests.post(url, json=data, verify=False) + allvalues = get_response.json() + directcall = True + try: if allvalues["value"] == None or allvalues["value"] == "null": allvalues["value"] = "[]" @@ -1601,25 +1982,36 @@ def check_cache_contains(self, key, value, append): if append == True: new_value = [str(value)] data["value"] = json.dumps(new_value) + if category: + data["category"] = category set_url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) - set_response = requests.post(set_url, json=data) + set_response = requests.post(set_url, json=data, verify=False) try: allvalues = set_response.json() - #allvalues["key"] = key - #return allvalues + self.shared_cache = self.preload_cache(key=key) - return { + newvalue = data["value"] + try: + newvalue = json.loads(data["value"]) + except json.JSONDecodeError: + pass + + response = { "success": True, "found": False, "key": key, - "value": new_value, + "search": value, } + if include_values: + response["value"] = newvalue + return response except Exception as e: return { "success": False, "found": False, "key": key, + "search": value, "reason": "Failed to find key, and failed to append", } else: @@ -1627,81 +2019,126 @@ def check_cache_contains(self, key, value, append): "success": True, "found": False, "key": key, + "search": value, "reason": "Not appended, not found", } else: if allvalues["value"] == None or allvalues["value"] == "null": allvalues["value"] = "[]" + if isinstance(allvalues["value"], str): + try: + allvalues["value"] = json.loads(allvalues["value"]) + except json.JSONDecodeError: + self.logger.info("[WARNING] Failed inner value cache parsing") + allvalues["value"] = [allvalues["value"]] + + if not isinstance(allvalues["value"], list): + allvalues["value"] = [allvalues["value"]] + try: - parsedvalue = json.loads(allvalues["value"]) + parsedvalue = json.loads(str(allvalues["value"])) except json.decoder.JSONDecodeError as e: - parsedvalue = [] - - #return parsedvalue - - for item in parsedvalue: - #return "%s %s" % (item, value) - if item == value: - if not append: - return { - "success": True, - "found": True, - "reason": "Found and not appending!", - "key": key, - "value": json.loads(allvalues["value"]), - } - else: - return { - "success": True, - "found": True, - "reason": "Found, was appending, but item already exists", - "key": key, - "value": json.loads(allvalues["value"]), - } - - # Lol - break + parsedvalue = allvalues["value"] + + try: + for item in parsedvalue: + # return "%s %s" % (item, value) + # self.logger.info(f"{item} == {value}") + if str(item) == str(value): + if not append: + try: + newdata = json.loads(json.dumps(data)) + newdata["time_set"] = time.time() + newdata["data"] = allvalues + self.local_storage.append(newdata) + except Exception as e: + print( + "[ERROR] Failed in local storage append: %s" % e + ) + + response = { + "success": True, + "found": True, + "reason": "Found and not appending!", + "key": key, + "search": value, + } + if include_values: + response["value"] = allvalues["value"] + return response + else: + response = { + "success": True, + "found": True, + "reason": "Found, was appending, but item already exists", + "key": key, + "search": value, + } + if include_values: + response["value"] = allvalues["value"] + return response + + # Lol + break + except Exception as e: + parsedvalue = [str(parsedvalue)] + append = True if not append: - return { + response = { "success": True, "found": False, "reason": "Not found, not appending (2)!", "key": key, - "value": json.loads(allvalues["value"]), + "search": value, } + if include_values: + response["value"] = allvalues["value"] + return response - #parsedvalue = json.loads(allvalues["value"]) - #if parsedvalue == None: - # parsedvalue = [] - - #return parsedvalue - new_value = parsedvalue - if new_value == None: - new_value = [value] + # parsedvalue.append(value) - new_value.append(value) + # data["value"] = json.dumps(parsedvalue) - #return new_value + if value not in allvalues["value"] and isinstance( + allvalues["value"], list + ): + self.cache_update_buffer.append(value) + allvalues["value"].append(value) - data["value"] = json.dumps(new_value) - #return allvalues - - set_url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) - response = requests.post(set_url, json=data) exception = "" try: - allvalues = response.json() - #return allvalues + # FIXME: This is a hack, but it works + if directcall: + new_value = allvalues["value"] + if new_value == None: + new_value = [value] - return { + data["value"] = json.dumps(new_value) + if category: + data["category"] = category + + set_url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) + response = requests.post(set_url, json=data, verify=False) + allvalues = response.json() + + newvalue = data["value"] + try: + newvalue = json.loads(data["value"]) + except: + pass + + response = { "success": True, "found": False, "reason": "Appended as it didn't exist", "key": key, - "value": new_value, + "search": value, } + if include_values: + response["value"] = newvalue + return response except Exception as e: exception = e pass @@ -1710,62 +2147,33 @@ def check_cache_contains(self, key, value, append): "success": False, "found": True, "reason": f"Failed to set append the value: {exception}. This should never happen", - "key": key + "search": value, + "key": key, } - - self.logger.info("Handle all values!") - #return allvalues + # return allvalues except Exception as e: + print("[ERROR] Failed check cache contains: %s" % e) return { "success": False, "key": key, - "reason": f"Failed to get cache: {e}", + "reason": f"Failed to handle cache contains. Is the original value a list?: {e}", + "search": value, "found": False, } - return value.text - - def get_cache_value(self, key): - org_id = self.full_execution["workflow"]["execution_org"]["id"] - url = "%s/api/v1/orgs/%s/get_cache" % (self.url, org_id) - data = { - "workflow_id": self.full_execution["workflow"]["id"], - "execution_id": self.current_execution_id, - "authorization": self.authorization, - "org_id": org_id, - "key": key, - } - - value = requests.post(url, json=data) - try: - allvalues = value.json() - self.logger.info("VAL1: ", allvalues) - allvalues["key"] = key - self.logger.info("VAL2: ", allvalues) - - if allvalues["success"] == True: - allvalues["found"] = True - else: - allvalues["success"] = True - allvalues["found"] = False - - try: - parsedvalue = json.loads(allvalues["value"]) - allvalues["value"] = parsedvalue - - except: - self.logger.info("Parsing of value as JSON failed") - pass + return value.text - return json.dumps(allvalues) - except: - self.logger.info("Value couldn't be parsed, or json dump of value failed") - return value.text + ## Adds value to a subkey of the cache + ## subkey = "hi", value = "test", overwrite=False + ## {"subkey": "hi", "value": "test"} + ## subkey = "hi", value = "test2", overwrite=True + ## {"subkey": "hi", "value": "test2"} + ## subkey = "hi", value = "test3", overwrite=False + ## {"subkey": "hi", "value": ["test2", "test3"]} - # FIXME: Add option for org only & sensitive data (not to be listed) - def set_cache_value(self, key, value): + def change_cache_subkey(self, key, subkey, value, overwrite, category=""): org_id = self.full_execution["workflow"]["execution_org"]["id"] url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) @@ -1774,6 +2182,7 @@ def set_cache_value(self, key, value): value = json.dumps(value) except Exception as e: self.logger.info(f"[WARNING] Error in JSON dumping (set cache): {e}") + elif not isinstance(value, str): value = str(value) @@ -1786,17 +2195,24 @@ def set_cache_value(self, key, value): "value": value, } - response = requests.post(url, json=data) + if category: + data["category"] = category + + response = requests.post(url, json=data, verify=False) try: allvalues = response.json() allvalues["key"] = key - #allvalues["value"] = json.loads(json.dumps(value)) + # allvalues["value"] = json.loads(json.dumps(value)) - if (value.startswith("{") and value.endswith("}")) or (value.startswith("[") and value.endswith("]")): + if (value.startswith("{") and value.endswith("}")) or ( + value.startswith("[") and value.endswith("]") + ): try: allvalues["value"] = json.loads(value) except json.decoder.JSONDecodeError as e: - self.logger.info("[WARNING] Failed inner value cache parsing: %s" % e) + self.logger.info( + "[WARNING] Failed inner value cache parsing: %s" % e + ) allvalues["value"] = str(value) else: allvalues["value"] = str(value) @@ -1806,12 +2222,302 @@ def set_cache_value(self, key, value): self.logger.info("Value couldn't be parsed") return response.text - def convert_json_to_tags(self, json_object, split_value=", ", include_key=True, lowercase=True): - if isinstance(json_object, str): - try: - json_object = json.loads(json_object) + def delete_datastore_value(self, key, category=""): + return self.delete_cache(key, category=category) + + def delete_cache_value(self, key, category=""): + return self.delete_cache(key, category=category) + + def get_datastore_value(self, key, category=""): + return self.get_cache_value(key, category=category) + + def get_ioc(self, ioc, data_type=""): + if len(data_type) == 0: + ioc_types = [ + "domains", + "urls", + "email_addresses", + "ipv4s", + "ipv6s", + "ipv4_cidrs", + "md5s", + "sha256s", + "sha1s", + "cves", + ] + + iocs = find_iocs(str(ioc)) + for key, value in iocs.items(): + for item in value: + if item.lower() == ioc.lower(): + print("[DEBUG] Found IOC %s in type %s" % (ioc, key)) + data_type = key[:-1] + break + + if len(data_type) > 0: + break + + org_id = self.full_execution["workflow"]["execution_org"]["id"] + url = "%s/api/v1/orgs/%s/get_cache" % (self.url, org_id) + data = { + "workflow_id": self.full_execution["workflow"]["id"], + "execution_id": self.current_execution_id, + "authorization": self.authorization, + "org_id": org_id, + "key": str(key), + "category": "ioc_%s" % data_type.replace(" ", "_").lower(), + } + + value = requests.post(url, json=data, verify=False) + try: + allvalues = value.json() + allvalues["key"] = key + + if allvalues["success"] == True and len(allvalues["value"]) > 0: + allvalues["found"] = True + else: + allvalues["success"] = True + allvalues["found"] = False + + try: + parsedvalue = json.loads(allvalues["value"]) + allvalues["value"] = parsedvalue + + except: + pass + + return json.dumps(allvalues) + except: + self.logger.info("Value couldn't be parsed, or json dump of value failed") + return value.text + + def get_cache_value(self, key, category=""): + org_id = self.full_execution["workflow"]["execution_org"]["id"] + url = "%s/api/v1/orgs/%s/get_cache" % (self.url, org_id) + data = { + "workflow_id": self.full_execution["workflow"]["id"], + "execution_id": self.current_execution_id, + "authorization": self.authorization, + "org_id": org_id, + "key": str(key), + } + + if category: + data["category"] = category + + value = requests.post(url, json=data, verify=False) + try: + allvalues = value.json() + allvalues["key"] = key + + if allvalues["success"] == True and len(allvalues["value"]) > 0: + allvalues["found"] = True + else: + allvalues["success"] = True + allvalues["found"] = False + + try: + parsedvalue = json.loads(allvalues["value"]) + allvalues["value"] = parsedvalue + + except: + pass + + return json.dumps(allvalues) + except: + self.logger.info("Value couldn't be parsed, or json dump of value failed") + return value.text + + def set_datastore_value(self, key, value, category=""): + return set_cache_value(self, key, value, category=category) + + # Check if a specific key exists in a datastore category or not + # Otherwise appends it automatically + def search_datastore_category(self, input_list, key, category): + returnvalue = { + "success": False, + "category": category, + "new": [], + "exists": [], + } + + if len(key) == 0 or len(category) == 0: + returnvalue["reason"] = "Key and/or Category is empty" + return returnvalue + + data = [] + if isinstance(input_list, dict): + input_list = [input_list] + + if not isinstance(input_list, list): + try: + input_list = json.loads(str(input_list)) + except Exception as e: + returnvalue["reason"] = ( + f"Input list is not a valid JSON list: {input_list}", + ) + returnvalue["details"] = str(e) + return returnvalue + + org_id = self.full_execution["workflow"]["execution_org"]["id"] + cnt = -1 + for item in input_list: + cnt += 1 + if not isinstance(item, dict): + try: + item = json.loads(str(item)) + except Exception as e: + self.logger.info( + "[ERROR][%s] Failed to parse item as JSON: %s" + % (self.current_execution_id, e) + ) + continue + + input_list[cnt] = item + if key not in item: + returnvalue["reason"] = ( + "Couldn't find key '%s' in every item. Make sure to use a key that exists in every entry." + % (key), + ) + return returnvalue + + data.append( + { + "workflow_id": self.full_execution["workflow"]["id"], + "execution_id": self.current_execution_id, + "authorization": self.authorization, + "org_id": org_id, + "key": str(item[key]), + "value": json.dumps(item), + "category": category, + } + ) + + url = f"{self.url}/api/v2/datastore?bulk=true&execution_id={self.current_execution_id}&authorization={self.authorization}" + response = requests.post(url, json=data, verify=False) + + if response.status_code != 200: + returnvalue["reason"] = "Failed to check datastore key exists" + returnvalue["details"] = response.text + returnvalue["status"] = response.status_code + return returnvalue + + data = "" + try: + data = response.json() + except json.decoder.JSONDecodeError as e: + return response.text + + if "keys_existed" not in data: + returnvalue["error"] = ( + "Invalid response from backend during bulk update of keys" + ) + returnvalue["details"] = data + + return returnvalue + + not_found_keys = [] + returnvalue["success"] = True + for datastore_item in input_list: + found = False + for existing_item in data["keys_existed"]: + if str(existing_item["key"]) != str(datastore_item[key]): + continue + + if existing_item["existed"] == True: + returnvalue["exists"].append(datastore_item) + else: + returnvalue["new"].append(datastore_item) + + found = True + break + + if not found: + print( + "[ERROR][%s] Key %s not found in datastore response, adding as new" + % (self.current_execution_id, datastore_item[key]) + ) + # returnvalue["new"].append(datastore_item) + not_found_keys.append(datastore_item[key]) + + if len(not_found_keys) > 0: + returnvalue["unhandled_keys"] = not_found_keys + returnvalue["reason"] = ( + "Something went wrong updating the unhandled_keys. Please contact support@shuffler.io if this persists." + ) + + return json.dumps(returnvalue, indent=4) + + def set_cache_value(self, key, value, category=""): + org_id = self.full_execution["workflow"]["execution_org"]["id"] + url = "%s/api/v1/orgs/%s/set_cache" % (self.url, org_id) + + if isinstance(value, dict) or isinstance(value, list): + try: + value = json.dumps(value) + except Exception as e: + self.logger.info(f"[WARNING] Error in JSON dumping (set cache): {e}") + + if not isinstance(value, str): + value = str(value) + + data = { + "workflow_id": self.full_execution["workflow"]["id"], + "execution_id": self.current_execution_id, + "authorization": self.authorization, + "org_id": org_id, + "key": str(key), + "value": value, + } + + if category: + data["category"] = category + + response = requests.post(url, json=data, verify=False) + try: + allvalues = response.json() + allvalues["key"] = key + # allvalues["value"] = json.loads(json.dumps(value)) + + allvalues["existed"] = False + if "keys_existed" in allvalues: + for key_info in allvalues["keys_existed"]: + if key_info["key"] == key: + allvalues["existed"] = key_info["existed"] + break + + if (value.startswith("{") and value.endswith("}")) or ( + value.startswith("[") and value.endswith("]") + ): + try: + allvalues["value"] = json.loads(value) + except json.decoder.JSONDecodeError as e: + self.logger.info( + "[WARNING] Failed inner value cache parsing: %s" % e + ) + allvalues["value"] = str(value) + else: + allvalues["value"] = str(value) + + if category: + allvalues["category"] = category + + return json.dumps(allvalues) + except: + self.logger.info("Value couldn't be parsed") + return response.text + + def convert_json_to_tags( + self, json_object, split_value=", ", include_key=True, lowercase=True + ): + if isinstance(json_object, str): + try: + json_object = json.loads(json_object) except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse list2 as json: %s. Type: %s" % (e, type(json_object))) + self.logger.info( + "Failed to parse list2 as json: %s. Type: %s" + % (e, type(json_object)) + ) if isinstance(lowercase, str) and lowercase.lower() == "true": lowercase = True @@ -1826,8 +2532,11 @@ def convert_json_to_tags(self, json_object, split_value=", ", include_key=True, parsedstring = [] try: for key, value in json_object.items(): - self.logger.info("KV: %s:%s" % (key, value)) - if isinstance(value, str) or isinstance(value, int) or isinstance(value, bool): + if ( + isinstance(value, str) + or isinstance(value, int) + or isinstance(value, bool) + ): if include_key == True: parsedstring.append("%s:%s" % (key, value)) else: @@ -1846,23 +2555,37 @@ def convert_json_to_tags(self, json_object, split_value=", ", include_key=True, return fullstring - def cidr_ip_match(self, ip, networks): - self.logger.info("Executing with\nIP: {},\nNetworks: {}".format(ip, networks)) + def autofix_network(self, ip_with_cidr): + try: + # Parse the input as an IPv4 network object + network = ipaddress.IPv4Network(ip_with_cidr, strict=False) + # Return the corrected network address + return str(network) + except ValueError as e: + print(f"Error: {e}") + return None + def cidr_ip_match(self, ip, networks): if isinstance(networks, str): try: networks = json.loads(networks) except json.decoder.JSONDecodeError as e: - self.logger.info("Failed to parse networks list as json: {}. Type: {}".format( - e, type(networks) - )) return { "success": False, "reason": "Networks is not a valid list: {}".format(networks), } + new_networks = [] + for network in networks: + new_network = self.autofix_network(network) + if new_network: + new_networks.append(new_network) + + networks = new_networks + try: ip_networks = list(map(ipaddress.ip_network, networks)) + # ip_address = ipaddress.ip_address(ip, False) ip_address = ipaddress.ip_address(ip) except ValueError as e: return "IP or some networks are not in valid format.\nError: {}".format(e) @@ -1871,15 +2594,15 @@ def cidr_ip_match(self, ip, networks): result = {} result["ip"] = ip - result['networks'] = list(map(str, matched_networks)) - result['is_contained'] = True if len(result['networks']) > 0 else False + result["networks"] = list(map(str, matched_networks)) + result["is_contained"] = True if len(result["networks"]) > 0 else False return json.dumps(result) def get_timestamp(self, time_format): timestamp = int(time.time()) if time_format == "unix" or time_format == "epoch": - self.logger.info("Running default timestamp %s" % timestamp) + pass return timestamp @@ -1888,14 +2611,14 @@ def get_hash_sum(self, value): sha256_value = "" try: - md5_value = hashlib.md5(str(value).encode('utf-8')).hexdigest() + md5_value = hashlib.md5(str(value).encode("utf-8")).hexdigest() except Exception as e: - self.logger.info(f"Error in md5sum: {e}") + pass try: - sha256_value = hashlib.sha256(str(value).encode('utf-8')).hexdigest() + sha256_value = hashlib.sha256(str(value).encode("utf-8")).hexdigest() except Exception as e: - self.logger.info(f"Error in sha256: {e}") + pass parsedvalue = { "success": True, @@ -1904,7 +2627,763 @@ def get_hash_sum(self, value): "sha256": sha256_value, } - return parsedvalue + return parsedvalue + + def run_oauth_request(self, url, jwt): + headers = { + "Content-Type": "application/x-www-form-urlencoded", + } + + data = ( + "grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=%s" + % jwt + ) + + return requests.post(url, data=data, headers=headers, verify=False).text + + # Based on https://google-auth.readthedocs.io/en/master/reference/google.auth.crypt.html + def get_jwt_from_file(self, file_id, jwt_audience, scopes, complete_request=True): + allscopes = scopes + + if "," in scopes: + allscopes = " ".join(scopes.split(",")) + + # Service account key path + filedata = self.get_file(file_id) + if filedata["success"] == False: + return { + "success": False, + "message": f"Failed to get file for ID {file_id}", + } + + data = json.loads(filedata["data"], strict=False) + # sa_keyfile = "" + sa_keyfile = data["private_key"] + sa_email = data["client_email"] + + # The audience to target + audience = jwt_audience + + """Generates a signed JSON Web Token using a Google API Service Account or similar.""" + + def get_jwt(sa_keyfile, sa_email, audience, allscopes, expiry_length=3600): + now = int(time.time()) + + # build payload + payload = { + # expires after 'expiry_length' seconds. + # iss must match 'issuer' in the security configuration in your + # swagger spec (e.g. service account email). It can be any string. + "iss": sa_email, + # aud must be either your Endpoints service name, or match the value + # specified as the 'x-google-audience' in the OpenAPI document. + "scope": allscopes, + "aud": audience, + "exp": now + expiry_length, + "iat": now, + # sub and email should match the service account's email address + "sub": sa_email, + "email": sa_email, + } + + # sign with keyfile + # signer = crypt.RSASigner.from_service_account_file(sa_keyfile) + signer = crypt.RSASigner.from_string(sa_keyfile) + jwt_token = jwt.encode(signer, payload) + return jwt_token + + signed_jwt = get_jwt(sa_keyfile, sa_email, audience, allscopes) + + if str(complete_request).lower() == "true": + return self.run_oauth_request(audience, signed_jwt.decode()) + else: + return { + "success": True, + "jwt": signed_jwt.decode(), + } + + def get_synonyms(self, input_type): + if input_type == "cases": + return { + "id": [ + "id", + "ref", + "sourceref", + "reference", + "sourcereference", + "alertid", + "caseid", + "incidentid", + "serviceid", + "sid", + "uid", + "uuid", + "teamid", + "messageid", + ], + "title": ["title", "message", "subject", "name"], + "description": [ + "description", + "status", + "explanation", + "story", + "details", + "snippet", + ], + "email": ["mail", "email", "sender", "receiver", "recipient"], + "data": [ + "data", + "ip", + "domain", + "url", + "hash", + "md5", + "sha2", + "sha256", + "value", + "item", + "rules", + ], + "tags": ["tags", "taxonomies", "labels", "labelids"], + "assignment": [ + "assignment", + "user", + "assigned_to", + "users", + "closed_by", + "closing_user", + "opened_by", + ], + "severity": [ + "severity", + "sev", + "magnitude", + "relevance", + ], + } + + return [] + + def find_key(self, inputkey, synonyms): + inputkey = inputkey.lower().replace(" ", "").replace(".", "") + for key, value in synonyms.items(): + if inputkey in value: + return key + + return inputkey + + def run_key_recursion(self, json_input, synonyms): + if ( + isinstance(json_input, str) + or isinstance(json_input, int) + or isinstance(json_input, float) + ): + return json_input, {} + + if isinstance(json_input, list): + if len(json_input) != 1: + return json_input, {} + else: + json_input = json_input[0] + + # new_list = [] + # for item in json_input: + # run_key_recursion(item, synonyms) + # new_dict[new_key], found_important = run_key_recursion(value, synonyms) + + # Looks for exact key:value stuff in other format + if len(json_input.keys()) == 2: + newkey = "" + newvalue = "" + for key, value in json_input.items(): + if key == "key" or key == "name": + newkey = value + elif key == "value": + newvalue = value + + if len(newkey) > 0 and len(newvalue) > 0: + json_input[newkey] = newvalue + try: + del json_input["name"] + except: + pass + + try: + del json_input["value"] + except: + pass + + try: + del json_input["key"] + except: + pass + + important_fields = {} + new_dict = {} + for key, value in json_input.items(): + new_key = self.find_key(key, synonyms) + + if isinstance(value, list): + new_list = [] + for subitem in value: + returndata, found_important = self.run_key_recursion( + subitem, synonyms + ) + + new_list.append(returndata) + for subkey, subvalue in found_important.items(): + important_fields[subkey] = subvalue + + new_dict[new_key] = new_list + + elif isinstance(value, dict): + # FIXMe: Try to understand Key:Values as well by translating them + # name/key: subject + # value: This is a subject + # will become: + # subject: This is a subject + + new_dict[new_key], found_important = self.run_key_recursion( + value, synonyms + ) + + for subkey, subvalue in found_important.items(): + important_fields[subkey] = subvalue + else: + new_dict[new_key] = value + + # Translated fields are added as important + if key.lower().replace(" ", "").replace(".", "") != new_key: + try: + if len(new_dict[new_key]) < str(important_fields[new_key]): + important_fields[new_key] = new_dict[new_key] + except KeyError as e: + important_fields[new_key] = new_dict[new_key] + except: + important_fields[new_key] = new_dict[new_key] + + # break + + return new_dict, important_fields + + # Should translate the data to something more useful + def get_standardized_data(self, json_input, input_type): + if isinstance(json_input, str): + json_input = json.loads(json_input, strict=False) + + input_synonyms = self.get_synonyms(input_type) + parsed_data, important_fields = self.run_key_recursion( + json_input, input_synonyms + ) + + # Try base64 decoding and such too? + for key, value in important_fields.items(): + try: + important_fields[key] = important_fields[key][key] + except: + pass + + try: + important_fields[key] = base64.b64decode(important_fields[key]) + except: + pass + + return { + "success": True, + "original": json_input, + "parsed": parsed_data, + "changed_fields": important_fields, + } + + def generate_random_string(self, length=16, special_characters=True): + try: + length = int(length) + except: + return { + "success": False, + "error": "Length needs to be a whole number", + } + + # get random password pf length 8 with letters, digits, and symbols + characters = string.ascii_letters + string.digits + string.punctuation + if str(special_characters).lower() == "false": + characters = string.ascii_letters + string.digits + string.punctuation + + password = "".join(random.choice(characters) for i in range(length)) + + return { + "success": True, + "password": password, + } + + def run_ssh_command( + self, host, port, user_name, private_key_file_id, password, command + ): + ssh_client = paramiko.SSHClient() + ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) + + if port: + port = int(port) + else: + port = 22 + + if private_key_file_id: + new_file = self.get_file(private_key_file_id) + + try: + key_data = new_file["data"].decode() + except Exception as e: + return {"success": "false", "message": str(e)} + + private_key_file = StringIO() + private_key_file.write(key_data) + private_key_file.seek(0) + private_key = paramiko.RSAKey.from_private_key(private_key_file) + + try: + ssh_client.connect( + hostname=host, username=user_name, port=port, pkey=private_key + ) + except Exception as e: + return {"success": "false", "message": str(e)} + else: + try: + ssh_client.connect( + hostname=host, username=user_name, port=port, password=str(password) + ) + except Exception as e: + return {"success": "false", "message": str(e)} + + try: + stdin, stdout, stderr = ssh_client.exec_command(str(command)) + try: + errorLog = stderr.read().decode(errors="ignore") + except Exception as e: + errorLog = f"Failed to read stderr {e}" + try: + output = stdout.read().decode(errors="ignore") + except Exception as e: + output = f"Failed to read stdout {e}" + + except Exception as e: + return {"success": "false", "message": str(e)} + + return {"success": "true", "output": output, "error_logs": errorLog} + + def cleanup_ioc_data(self, input_data): + # Remove unecessary parts like { and }, quotes etc + input_data = str(input_data) + input_data = input_data.replace("{", "") + input_data = input_data.replace("}", "") + input_data = input_data.replace('"', "") + input_data = input_data.replace("'", "") + + input_data = input_data.replace("\t", " ") + input_data = input_data.replace(" ", " ") + input_data = input_data.replace("\n\n", "\n") + + # Remove html tags + input_data = re.sub(r"<[^>]*>", "", input_data) + + return input_data + + def parse_ioc(self, input_string, input_type="all"): + ioc_types = [ + "domains", + "urls", + "email_addresses", + "ipv4s", + "ipv6s", + "ipv4_cidrs", + "md5s", + "sha256s", + "sha1s", + "cves", + ] + # ioc_types = ["ipv4s"] + + try: + input_string = self.cleanup_ioc_data(input_string) + except Exception as e: + self.logger.info("[ERROR] Failed to cleanup ioc data: %s" % e) + + # Remember overriding ioc types we care about + if input_type == "" or input_type == "all": + input_type = "all" + else: + input_type = input_type.split(",") + + new_input_types = [] + for i in range(len(input_type)): + item = input_type[i] + + item = item.strip() + if not item.endswith("s"): + item = "%ss" % item + + if item not in ioc_types: + continue + + new_input_types.append(item) + + ioc_types = new_input_types + if len(ioc_types) == 0: + input_type = "all" + + # Not used for anything after cleanup fixes + max_size = 7500000 + # if len(input_string) > max_size: + # input_string = input_string[:max_size] + + self.logger.info( + "[DEBUG] Parsing data of length %d with types %s. Max size: %d" + % (len(input_string), ioc_types, max_size) + ) + self.logger.info(f"STRING: {input_string}") + + # iocs = find_iocs(str(input_string), included_ioc_types=ioc_types) + iocs = find_iocs(str(input_string)) + # self.logger.info("[DEBUG] Found %d ioc types" % len(iocs)) + + newarray = [] + for key, value in iocs.items(): + if input_type != "all": + if key not in input_type: + print("Invalid key: %s" % key) + continue + + if len(value) == 0: + continue + + for item in value: + # If in here: attack techniques. Shouldn't be 3 levels so no + # recursion necessary + if isinstance(value, dict): + for subkey, subvalue in value.items(): + if len(subvalue) > 0: + for subitem in subvalue: + data = { + "data": subitem, + "data_type": "%s_%s" % (key[:-1], subkey), + } + if data not in newarray: + newarray.append(data) + else: + data = {"data": item, "data_type": key[:-1]} + if data not in newarray: + newarray.append(data) + + # Reformatting IP + for item in newarray: + if "cidr" in item["data_type"]: + pass + elif "ip" in item["data_type"]: + item["data_type"] = "ip" + try: + item["is_private_ip"] = ipaddress.ip_address( + item["data"] + ).is_private + except: + pass + + try: + newarray = json.dumps(newarray) + except json.decoder.JSONDecodeError as e: + return "Failed to parse IOC's: %s" % e + + return newarray + + def split_text(self, text): + # Split text into chunks of 10kb. Add each 10k to array + # In case e.g. 1.2.3.4 lands exactly on 20k boundary, it may be useful to overlap here. + # (just shitty code to reduce chance of issues) while still going fast + arr_one = [] + max_len = 5000 + current_string = "" + overlaps = 100 + + for i in range(0, len(text)): + current_string += text[i] + if len(current_string) > max_len: + # Appending just in case even with overlaps + if len(text) > i + overlaps: + current_string += text[i + 1 : i + overlaps] + else: + current_string += text[i + 1 :] + + arr_one.append(current_string) + current_string = "" + + if len(current_string) > 0: + arr_one.append(current_string) + + return arr_one + + def _format_result(self, result): + final_result = {} + + for res in result: + for key, val in res.items(): + if key in final_result: + if isinstance(val, list) and len(val) > 0: + for i in val: + final_result[key].append(i) + elif isinstance(val, dict): + if key in final_result: + if isinstance(val, dict): + for k, v in val.items(): + val[k].append(v) + else: + final_result[key] = val + + return final_result + + # See function for how it works~: parse_ioc_new(..) + def _with_concurency(self, array_of_strings, ioc_types): + results = [] + # start = time.perf_counter() + + # Workers dont matter..? + # What can we use instead? + + workers = 4 + with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor: + # Submit the find_iocs function for each string in the array + futures = [ + executor.submit( + find_iocs, + text=string, + included_ioc_types=ioc_types, + ) + for string in array_of_strings + ] + + # Wait for all tasks to complete + concurrent.futures.wait(futures) + + # Retrieve the results if needed + results = [future.result() for future in futures] + + return self._format_result(results) + + # FIXME: Make this good and actually faster than normal + # For now: Concurrency doesn't make it faster due to GIL in python. + # May need to offload this to an executable or something + def parse_ioc_new(self, input_string, input_type="all"): + if input_type == "": + input_type = "all" + + ioc_types = [ + "domains", + "urls", + "email_addresses", + "ipv4s", + "ipv4_cidrs", + "md5s", + "sha256s", + "sha1s", + "cves", + ] + + if input_type == "" or input_type == "all": + ioc_types = ioc_types + else: + input_type = input_type.split(",") + for item in input_type: + item = item.strip() + + ioc_types = input_type + + input_string = str(input_string) + + if len(input_string) > 10000: + iocs = self._with_concurency( + self.split_text(input_string), ioc_types=ioc_types + ) + else: + iocs = find_iocs(input_string, included_ioc_types=ioc_types) + + newarray = [] + for key, value in iocs.items(): + if input_type != "all": + if key not in input_type: + continue + + if len(value) == 0: + continue + + for item in value: + # If in here: attack techniques. Shouldn't be 3 levels so no + # recursion necessary + if isinstance(value, dict): + for subkey, subvalue in value.items(): + if len(subvalue) == 0: + continue + + for subitem in subvalue: + data = { + "data": subitem, + "data_type": "%s_%s" % (key[:-1], subkey), + } + + if data not in newarray: + newarray.append(data) + else: + data = {"data": item, "data_type": key[:-1]} + if data not in newarray: + newarray.append(data) + + # Reformatting IP + i = -1 + for item in newarray: + i += 1 + if "ip" not in item["data_type"]: + continue + + newarray[i]["data_type"] = "ip" + try: + newarray[i]["is_private_ip"] = ipaddress.ip_address( + item["data"] + ).is_private + except Exception as e: + pass + + try: + newarray = json.dumps(newarray) + except json.decoder.JSONDecodeError as e: + return "Failed to parse IOC's: %s" % e + + return newarray + + def merge_incoming_branches(self, input_type="list"): + wf = self.full_execution["workflow"] + if "branches" not in wf or not wf["branches"]: + return {"success": False, "reason": "No branches found"} + + if "results" not in self.full_execution or not self.full_execution["results"]: + return { + "success": False, + "reason": "No results for previous actions not found", + } + + if not input_type: + input_type = "list" + + branches = wf["branches"] + cur_action = self.action + # print("Found %d branches" % len(branches)) + + results = [] + for branch in branches: + if branch["destination_id"] != cur_action["id"]: + continue + + # Find result for the source + source_id = branch["source_id"] + + for res in self.full_execution["results"]: + if res["action"]["id"] != source_id: + continue + + try: + parsed = json.loads(res["result"]) + results.append(parsed) + except Exception as e: + results.append(res["result"]) + + break + + if input_type == "list": + newlist = [] + for item in results: + if not isinstance(item, list): + continue + + for subitem in item: + if subitem in newlist: + continue + + newlist.append(subitem) + # newlist.append(item) + + results = newlist + elif input_type == "dict": + new_dict = {} + for item in results: + if not isinstance(item, dict): + continue + + new_dict = self.merge_lists(new_dict, item) + + results = json.dumps(new_dict) + else: + return { + "success": False, + "reason": "No results from source branches with type %s" % input_type, + } + + return results + + def bodyparse_test(self, body): + return body + + def list_cidr_ips(self, cidr): + defaultreturn = {"success": False, "reason": "Invalid CIDR address"} + + if not cidr: + return defaultreturn + + if "/" not in cidr: + defaultreturn["reason"] = "CIDR address must contain / (e.g. /12)" + return defaultreturn + + try: + cidrnumber = int(cidr.split("/")[1]) + except ValueError as e: + defaultreturn["exception"] = str(e) + return defaultreturn + + if cidrnumber < 12: + defaultreturn["reason"] = "CIDR address too large. Please stay above /12" + return defaultreturn + + try: + net = ipaddress.ip_network(cidr) + except ValueError as e: + defaultreturn["exception"] = str(e) + return defaultreturn + + ips = [str(ip) for ip in net] + returnvalue = {"success": True, "amount": len(ips), "ips": ips} + + return returnvalue + + def switch(self, conditions): + # Check if conditions is a list or not + if not isinstance(conditions, list): + conditions = [conditions] + + # True by default + to_return = { + "success": True, + "run_else": True, + } + + if len(conditions) == 0: + conditions = [] + + for condition in conditions: + pass + + # Loop conditions + # Return them without a loop to make it EASY to understand + # Validation should be: + # Continuation based on .id.valid + # .valid -> true/false + # If no id exists, use name? + + return to_return + if __name__ == "__main__": Tools.run() diff --git a/shuffle-tools/1.2.0/src/concurrency.py b/shuffle-tools/1.2.0/src/concurrency.py new file mode 100644 index 00000000..420d1686 --- /dev/null +++ b/shuffle-tools/1.2.0/src/concurrency.py @@ -0,0 +1,201 @@ +import time +import json +import ipaddress +import concurrent.futures +from functools import partial +from ioc_finder import find_iocs + +class Test(): + def split_text(self, text): + # Split text into chunks of 10kb. Add each 10k to array + # In case e.g. 1.2.3.4 lands exactly on 20k boundary, it may be useful to overlap here. + # (just shitty code to reduce chance of issues) while still going fast + + arr_one = [] + max_len = 2500 + current_string = "" + overlaps = 100 + + + for i in range(0, len(text)): + current_string += text[i] + if len(current_string) > max_len: + # Appending just in case even with overlaps + if len(text) > i+overlaps: + current_string += text[i+1:i+overlaps] + else: + current_string += text[i+1:] + + arr_one.append(current_string) + current_string = "" + + if len(current_string) > 0: + arr_one.append(current_string) + + #print("DATA:", arr_one) + print("Strings:", len(arr_one)) + #exit() + + return arr_one + + def _format_result(self, result): + final_result = {} + + for res in result: + for key, val in res.items(): + if key in final_result: + if isinstance(val, list) and len(val) > 0: + for i in val: + final_result[key].append(i) + elif isinstance(val, dict): + #print(key,":::",val) + if key in final_result: + if isinstance(val, dict): + for k,v in val.items(): + #print("k:",k,"v:",v) + val[k].append(v) + #print(val) + #final_result[key].append([i for i in val if len(val) > 0]) + else: + final_result[key] = val + + return final_result + + def worker_function(self, inputdata): + return find_iocs(inputdata["data"], included_ioc_types=inputdata["ioc_types"]) + + def _with_concurency(self, array_of_strings, ioc_types): + results = [] + #start = time.perf_counter() + + # Workers dont matter..? + # What can we use instead? + + results = [] + workers = 4 + with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor: + # Submit the find_iocs function for each string in the array + futures = [executor.submit( + find_iocs, + text=string, + included_ioc_types=ioc_types, + ) for string in array_of_strings] + + # Wait for all tasks to complete + concurrent.futures.wait(futures) + + # Retrieve the results if needed + results = [future.result() for future in futures] + + return self._format_result(results) + + def parse_ioc_new(self, input_string, input_type="all"): + if input_type == "": + input_type = "all" + + #ioc_types = ["domains", "urls", "email_addresses", "ipv6s", "ipv4s", "ipv4_cidrs", "md5s", "sha256s", "sha1s", "cves"] + ioc_types = ["domains", "urls", "email_addresses", "ipv4s", "ipv4_cidrs", "md5s", "sha256s", "sha1s", "cves"] + + # urls = 10.4 -> 9.1 + # emails = 10.4 -> 9.48 + # ipv6s = 10.4 -> 7.37 + # ipv4 cidrs = 10.4 -> 10.44 + + if input_type == "" or input_type == "all": + ioc_types = ioc_types + else: + input_type = input_type.split(",") + for item in input_type: + item = item.strip() + + ioc_types = input_type + + input_string = str(input_string) + if len(input_string) > 10000: + iocs = self._with_concurency(self.split_text(input_string), ioc_types=ioc_types) + else: + iocs = find_iocs(input_string, included_ioc_types=ioc_types) + + newarray = [] + for key, value in iocs.items(): + if input_type != "all": + if key not in input_type: + continue + + if len(value) == 0: + continue + + for item in value: + # If in here: attack techniques. Shouldn't be 3 levels so no + # recursion necessary + if isinstance(value, dict): + for subkey, subvalue in value.items(): + if len(subvalue) == 0: + continue + + for subitem in subvalue: + data = { + "data": subitem, + "data_type": "%s_%s" % (key[:-1], subkey), + } + + if data not in newarray: + newarray.append(data) + else: + data = {"data": item, "data_type": key[:-1]} + if data not in newarray: + newarray.append(data) + + # Reformatting IP + i = -1 + for item in newarray: + i += 1 + if "ip" not in item["data_type"]: + continue + + newarray[i]["data_type"] = "ip" + try: + newarray[i]["is_private_ip"] = ipaddress.ip_address(item["data"]).is_private + except Exception as e: + print("Error parsing %s: %s" % (item["data"], e)) + + try: + newarray = json.dumps(newarray) + except json.decoder.JSONDecodeError as e: + return "Failed to parse IOC's: %s" % e + + return newarray + +# Make it not run this for multithreads +if __name__ == "__main__": + + input_string = "" + with open("testdata.txt", "r") as f: + input_string = f.read() + + try: + json_data = json.loads(input_string) + # If array, loop + if isinstance(json_data, list): + cnt = 0 + start = time.perf_counter() + for item in json_data: + cnt += 1 + classdata = Test() + + ret = classdata.parse_ioc_new(item) + #print("OUTPUT1: ", ret) + + #if cnt == 5: + # break + + print("Total time taken:", time.perf_counter()-start) + else: + classdata = Test() + ret = classdata.parse_ioc_new(input_string) + print("OUTPUT2: ", ret) + except Exception as e: + classdata = Test() + ret = classdata.parse_ioc_new(json_data) + print("OUTPUT3: ", ret) + diff --git a/shuffle-tools/1.2.0/src/switch.py b/shuffle-tools/1.2.0/src/switch.py new file mode 100644 index 00000000..78ede505 --- /dev/null +++ b/shuffle-tools/1.2.0/src/switch.py @@ -0,0 +1,203 @@ +# self, sourcevalue, condition, destinationvalue +def validate_condition(sourcevalue, check, destinationvalue): + if check == "=" or check == "==" or check.lower() == "equals": + if str(sourcevalue).lower() == str(destinationvalue).lower(): + return True + elif check == "!=" or check.lower() == "does not equal": + if str(sourcevalue).lower() != str(destinationvalue).lower(): + return True + elif check.lower() == "startswith": + if str(sourcevalue).lower().startswith(str(destinationvalue).lower()): + return True + + + elif check.lower() == "endswith": + if str(sourcevalue).lower().endswith(str(destinationvalue).lower()): + return True + elif check.lower() == "contains": + if destinationvalue.lower() in sourcevalue.lower(): + return True + + elif check.lower() == "is empty" or check.lower() == "is_empty": + try: + if len(json.loads(sourcevalue)) == 0: + return True + except Exception as e: + print("[ERROR] Failed to check if empty as list: {e}") + + if len(str(sourcevalue)) == 0: + return True + + elif check.lower() == "contains_any_of": + newvalue = [destinationvalue.lower()] + if "," in destinationvalue: + newvalue = destinationvalue.split(",") + elif ", " in destinationvalue: + newvalue = destinationvalue.split(", ") + + for item in newvalue: + if not item: + continue + + if item.strip() in sourcevalue: + return True + + elif check.lower() == "larger than" or check.lower() == "bigger than" or check == ">" or check == ">=": + try: + if str(sourcevalue).isdigit() and str(destinationvalue).isdigit(): + if int(sourcevalue) > int(destinationvalue): + return True + + except AttributeError as e: + print("[WARNING] Condition larger than failed with values %s and %s: %s" % (sourcevalue, destinationvalue, e)) + + try: + destinationvalue = len(json.loads(destinationvalue)) + except Exception as e: + print("[WARNING] Failed to convert destination to list: {e}") + try: + # Check if it's a list in autocast and if so, check the length + if len(json.loads(sourcevalue)) > int(destinationvalue): + return True + except Exception as e: + print("[WARNING] Failed to check if larger than as list: {e}") + + + elif check.lower() == "smaller than" or check.lower() == "less than" or check == "<" or check == "<=": + print("In smaller than check: %s %s" % (sourcevalue, destinationvalue)) + + try: + if str(sourcevalue).isdigit() and str(destinationvalue).isdigit(): + if int(sourcevalue) < int(destinationvalue): + return True + + except AttributeError as e: + pass + + try: + destinationvalue = len(json.loads(destinationvalue)) + except Exception as e: + print("[WARNING] Failed to convert destination to list: {e}") + + try: + # Check if it's a list in autocast and if so, check the length + if len(json.loads(sourcevalue)) < int(destinationvalue): + return True + except Exception as e: + print("[WARNING] Failed to check if smaller than as list: {e}") + + elif check.lower() == "re" or check.lower() == "matches regex": + try: + found = re.search(str(destinationvalue), str(sourcevalue)) + except re.error as e: + return False + except Exception as e: + return False + + if found == None: + return False + + return True + else: + print("[DEBUG] Condition: can't handle %s yet. Setting to true" % check) + + return False + +def evaluate_conditions(condition_structure): + operator = condition_structure.get('operator') + + # Base case: Single condition + if 'source' in condition_structure: + source = condition_structure['source'] + condition = condition_structure['condition'] + destination = condition_structure['destination'] + + # self. + return validate_condition(source, condition, destination) + + # Recursive case: Logical operator + elif operator == "AND": + return all(evaluate_conditions(sub_condition) for sub_condition in condition_structure['conditions']) + + elif operator == "OR": + return any(evaluate_conditions(sub_condition) for sub_condition in condition_structure['conditions']) + + elif operator == "NOT": + return not evaluate_conditions(condition_structure['conditions'][0]) + + else: + raise ValueError(f"Unknown operator: {operator}") + + +def switch(conditions): + to_return = { + "success": True, + "run_else": True, + } + + for condition in conditions: + if "id" not in condition: + print("Condition ID not found") + continue + + evaluated = False + try: + evaluated = evaluate_conditions(condition) + except Exception as e: + print(f"Failed to evaluate condition {condition['id']}: {e}") + + if evaluated == True: + to_return["run_else"] = False + + to_return[condition["id"]] = evaluated + + return to_return + +# Example usage + +condition_structure = { + "id": "lol", + "operator": "AND", + "conditions": [ + { # true + "source": "20", # age + "condition": ">", + "destination": 18 + }, + { # true + "operator": "OR", + "conditions": [ + { + "source": "active", # status + "condition": "==", + "destination": "active" + }, + { + "source": "1500", # balance + "condition": ">=", + "destination": 1000 + } + ] + }, + { + "operator": "NOT", + "conditions": [ + { + "source": "user", # user + "condition": "==", + "destination": "admin" + } + ] + } + ] +} + +newcondition = condition_structure.copy() +testconditions = [condition_structure] +newcondition['id'] = "lol2" +testconditions.append(newcondition) + +result = switch(testconditions) +print() +print() +print("Output: ", result) diff --git a/shuffle-tools/README.md b/shuffle-tools/README.md index 45bb5642..0a3518ac 100644 --- a/shuffle-tools/README.md +++ b/shuffle-tools/README.md @@ -1,77 +1,43 @@ # Shuffle tools App documentation Shuffle tools is a utility app that simplifies your understanding of what happens in a node and also allows you to test on the fly. + ## Actions The Shuffle-tools app comes with a multitude of different actions, here we will check a few out and give a brief description. -1. Repeat back to me - This action does exactly what it says, repeats back to you what you want it to. Why is this important? You need to test as you go whilst creating your workflow, what results does the first node give and are the results okay to use in the subsequent nodes? - -2. Router - Reroutes data between different nodes. - -3. Check cache contains - Checks Shuffle cache whether a key contains a value in a list - -4. Get cache value - Get a value savesd in your Shuffle organization - -5. Send SMS Shuffle - Sends an SMS from Shuffle, currently working on getting a few demo trials. - -6. Send E-mail Shuffle - Sends an Email from shuffle, currently working on getting a few demo trials. - -7. Filter list - Takes a list and filters based on the data - -8. Parse IOC - Parses Indicators of Compromise based on https://github.com/fhightower/ioc-finder - -9. Translate Value - Takes a list of values and translates it in your input data - -10. Map value - Takes a mapping dictionary and translates the input data. This is a search and replace for multiple fields. - -11. Regex Capture Group - Returns objects matching the capture group - -12. Regex replace - Replace all instances matching the regular expression - -13. Parse List - Parses a list and returns it as a JSON object - -14. Execute Bash - Runs bash with the data input - -15. Execute Python - Runs python with the data input. Any prints will be returned. - -16. Get file value - This function is made for reading files. Prints out their data. - -17. Download remote file - Downloads a file from a url - -18. Get file meta - Gets file metadata - -19. Delete file - Delete's file based on id - -20. Extract archive - Extracts compressed files and returns file ids - -21. Inflate archive - Compress files in an archive. Return file archive ids - -22. XML JSON converter - Converts XML to JSON and vice versa - -23. Date to epoch - converts a date field with a given format to an epoch time - -24. Compare relative date - Compares an input date and a relative date and returns a True/False response - -25. Add list to list - Can append single items to a list, can also add items of a list to another list - -26. Merge lists - Merge lists of the same type and length - -27. Diff Lists - Differentiates two lists of strings or integers and finds what's missing - -28. Set JSON Key - Adds a JSON key to an existing object - -29. Delete JSON Keys - Deletes keys in a JSON object - -30. Convert JSON tags - Creates Key:Value pairs and converts JSON to tags - -31. Run Math Operation - Runs an arithmetic operation - -32. Escape HTML - Performs HTML escaping on field - -33. Base 64 Conversion - Encodes or Decodes a base64 string - -34. Get time stamp - Gets a timestamp for right now. Default returns epoch time - -35. Get Hash sum - Returns multiple format of hashes based on the input value - -36. Cidr IP match - Check if an IP is contained in a CIDR defined network \ No newline at end of file +- 1. Repeat back to me - This action does exactly what it says, repeats back to you what you want it to. Why is this important? You need to test as you go whilst creating your workflow, what results does the first node give and are the results okay to use in the subsequent nodes? +- 2. Router - Reroutes data between different nodes. +- 3. Check cache contains - Checks Shuffle cache whether a key contains a value in a list +- 4. Get cache value - Get a value savesd in your Shuffle organization +- 5. Send SMS Shuffle - Sends an SMS from Shuffle, currently working on getting a few demo trials. +- 6. Send E-mail Shuffle - Sends an Email from shuffle, currently working on getting a few demo trials. +- 7. Filter list - Takes a list and filters based on the data +- 8. Parse IOC - Parses Indicators of Compromise based on https://github.com/fhightower/ioc-finder +- 9. Translate Value - Takes a list of values and translates it in your input data +- 10. Map value - Takes a mapping dictionary and translates the input data. This is a search and replace for multiple fields. +- 11. Regex Capture Group - Returns objects matching the capture group +- 12. Regex replace - Replace all instances matching the regular expression +- 13. Parse List - Parses a list and returns it as a JSON object +- 14. Execute Bash - Runs bash with the data input +- 15. Execute Python - Runs python with the data input. Any prints will be returned. +- 16. Get file value - This function is made for reading files. Prints out their data. +- 17. Download remote file - Downloads a file from a url +- 18. Get file meta - Gets file metadata +- 19. Delete file - Delete's file based on id +- 20. Extract archive - Extracts compressed files and returns file ids +- 21. Inflate archive - Compress files in an archive. Return file archive ids +- 22. XML JSON converter - Converts XML to JSON and vice versa +- 23. Date to epoch - converts a date field with a given format to an epoch time +- 24. Compare relative date - Compares an input date and a relative date and returns a True/False response +- 25. Add list to list - Can append single items to a list, can also add items of a list to another list +- 26. Merge lists - Merge lists of the same type and length +- 27. Diff Lists - Differentiates two lists of strings or integers and finds what's missing +- 28. Set JSON Key - Adds a JSON key to an existing object +- 29. Delete JSON Keys - Deletes keys in a JSON object +- 30. Convert JSON tags - Creates Key:Value pairs and converts JSON to tags +- 31. Run Math Operation - Runs an arithmetic operation +- 32. Escape HTML - Performs HTML escaping on field +- 33. Base 64 Conversion - Encodes or Decodes a base64 string +- 34. Get time stamp - Gets a timestamp for right now. Default returns epoch time +- 35. Get Hash sum - Returns multiple format of hashes based on the input value +- 36. Cidr IP match - Check if an IP is contained in a CIDR defined network diff --git a/siemonster/1.0.0/requirements.txt b/siemonster/1.0.0/requirements.txt index fd7d3e06..480d0c4b 100644 --- a/siemonster/1.0.0/requirements.txt +++ b/siemonster/1.0.0/requirements.txt @@ -1 +1 @@ -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/sigma/1.0.0/api.yaml b/sigma/1.0.0/api.yaml index 9dab6387..4fdc5ef6 100644 --- a/sigma/1.0.0/api.yaml +++ b/sigma/1.0.0/api.yaml @@ -8,7 +8,7 @@ contact_info: tags: - Testing categories: - - Testing + - SIEM actions: - name: get_searches description: Runs a python script defined by YOU @@ -66,7 +66,7 @@ actions: multiline: false schema: type: string - - name: shuffle_namespace + - name: shuffle_category description: The Shuffle required: true multiline: false diff --git a/sigma/1.0.0/requirements.txt b/sigma/1.0.0/requirements.txt index b49a2451..755761ce 100644 --- a/sigma/1.0.0/requirements.txt +++ b/sigma/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 +requests==2.32.4 sigmatools==0.20 diff --git a/snort3/1.0.0/requirements.txt b/snort3/1.0.0/requirements.txt index 64fe70a3..090113b4 100644 --- a/snort3/1.0.0/requirements.txt +++ b/snort3/1.0.0/requirements.txt @@ -1,2 +1,2 @@ # No extra requirements needed -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/sooty/1.0.0/requirements.txt b/sooty/1.0.0/requirements.txt index 897de537..0ade4fc4 100644 --- a/sooty/1.0.0/requirements.txt +++ b/sooty/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 +requests==2.32.4 ipwhois==1.2.0 \ No newline at end of file diff --git a/testing/1.0.0/requirements.txt b/testing/1.0.0/requirements.txt deleted file mode 100644 index fd7d3e06..00000000 --- a/testing/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests==2.25.1 \ No newline at end of file diff --git a/thehive/1.0.0/run b/thehive/1.0.0/run deleted file mode 100644 index 6127bfb7..00000000 --- a/thehive/1.0.0/run +++ /dev/null @@ -1,17 +0,0 @@ -#!/bin/sh -docker stop frikky/shuffle:thehive_1.0.0 --force -docker rm frikky/shuffle:thehive_1.0.0 --force -docker rmi frikky/shuffle:thehive_1.0.0 --force - -docker build . -t frikky/shuffle:thehive_1.0.0 - -echo "RUNNING!\n\n" -docker run \ - --env CALLBACK_URL="http://192.168.239.144:5001" \ - --env ACTION='{"app_name":"testing","app_version":"1.0.0","errors":[],"id_":"13fa4c3f-8991-3ade-b90d-f326fd4941dd","is_valid":true,"label":"random_number","environment":"onprem","name":"random_number","parameters":[],"position":{"x":178.07868996109607,"y":457.28345902971614},"priority":3}' \ - --env FUNCTION_APIKEY="asdasd" \ - --env EXECUTIONID="2349bf96-51ad-68d2-5ca6-75ef8f7ee814" \ - --env AUTHORIZATION="8e344a2e-db51-448f-804c-eb959a32c139" \ - frikky/shuffle:thehive_1.0.0 - -docker push frikky/shuffle:thehive_1.0.0 diff --git a/thehive/1.1.1/requirements.txt b/thehive/1.1.1/requirements.txt deleted file mode 100644 index 1d40c46a..00000000 --- a/thehive/1.1.1/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -requests==2.25.1 -thehive4py==1.8.1 -python-magic==0.4.18 diff --git a/thehive/1.1.2/docker-compose.yml b/thehive/1.1.2/docker-compose.yml deleted file mode 100644 index 47de05b2..00000000 --- a/thehive/1.1.2/docker-compose.yml +++ /dev/null @@ -1,14 +0,0 @@ -version: '3.4' -services: - thehive: - build: - context: . - dockerfile: Dockerfile - env_file: - - env.txt - restart: "no" - deploy: - mode: replicated - replicas: 10 - restart_policy: - condition: none diff --git a/thehive/1.1.2/env.txt b/thehive/1.1.2/env.txt deleted file mode 100644 index 1398a35f..00000000 --- a/thehive/1.1.2/env.txt +++ /dev/null @@ -1,4 +0,0 @@ -REDIS_URI=redis://redis -REDIS_ACTION_RESULT_CH=action-results -REDIS_ACTION_RESULTS_GROUP=action-results-group -APP_NAME=thehive diff --git a/thehive/1.1.2/requirements.txt b/thehive/1.1.2/requirements.txt deleted file mode 100644 index 1d40c46a..00000000 --- a/thehive/1.1.2/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -requests==2.25.1 -thehive4py==1.8.1 -python-magic==0.4.18 diff --git a/thehive/1.1.3/docker-compose.yml b/thehive/1.1.3/docker-compose.yml deleted file mode 100644 index 47de05b2..00000000 --- a/thehive/1.1.3/docker-compose.yml +++ /dev/null @@ -1,14 +0,0 @@ -version: '3.4' -services: - thehive: - build: - context: . - dockerfile: Dockerfile - env_file: - - env.txt - restart: "no" - deploy: - mode: replicated - replicas: 10 - restart_policy: - condition: none diff --git a/thehive/1.1.3/env.txt b/thehive/1.1.3/env.txt deleted file mode 100644 index 1398a35f..00000000 --- a/thehive/1.1.3/env.txt +++ /dev/null @@ -1,4 +0,0 @@ -REDIS_URI=redis://redis -REDIS_ACTION_RESULT_CH=action-results -REDIS_ACTION_RESULTS_GROUP=action-results-group -APP_NAME=thehive diff --git a/thehive/1.1.3/requirements.txt b/thehive/1.1.3/requirements.txt deleted file mode 100644 index 1d40c46a..00000000 --- a/thehive/1.1.3/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -requests==2.25.1 -thehive4py==1.8.1 -python-magic==0.4.18 diff --git a/http/1.2.0/Dockerfile b/twilio/1.9.0/Dockerfile similarity index 100% rename from http/1.2.0/Dockerfile rename to twilio/1.9.0/Dockerfile diff --git a/twilio/1.9.0/api.yaml b/twilio/1.9.0/api.yaml new file mode 100644 index 00000000..af084706 --- /dev/null +++ b/twilio/1.9.0/api.yaml @@ -0,0 +1,107 @@ +walkoff_version: 1.9.0 +app_version: 1.9.0 +name: twilio +description: Send SMS from Shuffle through Twilio.com +tags: + - HTTP +categories: + - HTTP +contact_info: + name: "Entwicklungsleiter" + url: https://github.com/Entwicklungsleiter + email: "50797003+Entwicklungsleiter@users.noreply.github.com" +authentication: + required: true + parameters: + - name: url + description: Twilio API URL. + example: "https://api.twilio.com/2010-04-01/Accounts/TWILIO_ACCOUNT_SID/Messages.json" + required: true + schema: + type: string + - name: username + description: Your Twilio account SID + multiline: false + required: true + example: "Username" + schema: + type: string + - name: password + description: Your Twilio account secret + multiline: false + required: true + example: "*****" + schema: + type: string + - name: headers + description: Headers to use + multiline: true + required: false + example: "Content-Type: application/x-www-form-urlencoded" + schema: + type: string +actions: + - name: Send_SMS + description: sends an SMS to Twilio API endpoint + parameters: + - name: url + description: Twilio API URL + multiline: false + example: "https://api.twilio.com/2010-04-01/Accounts/TWILIO_ACCOUNT_SID/Messages.json" + required: true + schema: + type: string + - name: headers + description: Headers to use + multiline: true + required: false + example: "Content-Type: application/x-www-form-urlencoded" + schema: + type: string + - name: username + description: Your Twilio account SID + multiline: false + required: true + example: "Username" + schema: + type: string + - name: password + description: Your Twilio account secret + multiline: false + required: true + example: "*****" + schema: + type: string + - name: timeout + description: Add a timeout (in seconds) for the request + multiline: false + required: false + example: "10" + schema: + type: bool + - name: body + description: The message to send. + multiline: true + example: "I did not have any sexual relationship with Miss Lewinsky!" + required: true + schema: + type: string + - name: From + description: The senders phone number, see Your Twilio account for accepted phone numbers. + multiline: false + example: "+1234567890" + required: true + schema: + type: string + - name: To + description: The message receiver phone number (or a comma separated list of phone numbers). + multiline: false + example: "+9876543210,+1928374650" + required: true + schema: + type: string + returns: + schema: + type: string + example: "404 NOT FOUND" +large_image: data:image/png;base64,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 diff --git a/twilio/1.9.0/requirements.txt b/twilio/1.9.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/twilio/1.9.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/twilio/1.9.0/src/app.py b/twilio/1.9.0/src/app.py new file mode 100755 index 00000000..d43533ff --- /dev/null +++ b/twilio/1.9.0/src/app.py @@ -0,0 +1,206 @@ +import json +import ast +import requests + +from walkoff_app_sdk.app_base import AppBase + +class TWILIO(AppBase): + __version__ = "1.9.0" + app_name = "twilio" + + def __init__(self, redis, logger, console_logger=None): + print("INIT") + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def splitheaders(self, headers): + parsed_headers = {} + if headers: + split_headers = headers.split("\n") + self.logger.info(split_headers) + for header in split_headers: + if ": " in header: + splititem = ": " + elif ":" in header: + splititem = ":" + elif "= " in header: + splititem = "= " + elif "=" in header: + splititem = "=" + else: + self.logger.info("Skipping header %s as its invalid" % header) + continue + + splitheader = header.split(splititem) + if len(splitheader) == 2: + parsed_headers[splitheader[0]] = splitheader[1] + else: + self.logger.info("Skipping header %s with split %s cus only one item" % (header, splititem)) + continue + + return parsed_headers + + def checkbody(self, body): + # Indicates json + if isinstance(body, str): + if body.strip().startswith("{"): + body = json.dumps(ast.literal_eval(body)) + + + # Not sure if loading is necessary + # Seemed to work with plain string into data=body too, and not parsed json=body + #try: + # body = json.loads(body) + #except json.decoder.JSONDecodeError as e: + # return body + + return body + else: + return body + + if isinstance(body, dict) or isinstance(body, list): + try: + body = json.dumps(body) + except: + return body + + return body + + def fix_url(self, url): + # Random bugs seen by users + if "hhttp" in url: + url = url.replace("hhttp", "http") + + if "http:/" in url and not "http://" in url: + url = url.replace("http:/", "http://", -1) + if "https:/" in url and not "https://" in url: + url = url.replace("https:/", "https://", -1) + if "http:///" in url: + url = url.replace("http:///", "http://", -1) + if "https:///" in url: + url = url.replace("https:///", "https://", -1) + if not "http://" in url and not "http" in url: + url = f"http://{url}" + + return url + + def return_file(self, requestdata): + filedata = { + "filename": "response.txt", + "data": requestdata, + } + fileret = self.set_files([filedata]) + if len(fileret) == 1: + return {"success": True, "file_id": fileret[0]} + + return fileret + + def prepare_response(self, request): + try: + parsedheaders = {} + for key, value in request.headers.items(): + parsedheaders[key] = value + + cookies = {} + if request.cookies: + for key, value in request.cookies.items(): + cookies[key] = value + + + jsondata = request.text + try: + jsondata = json.loads(jsondata) + except: + pass + + return { + "success": True, + "status": request.status_code, + "url": request.url, + "headers": parsedheaders, + "body": jsondata, + "cookies":cookies, + } + except Exception as e: + print(f"[WARNING] Failed in request: {e}") + return { + "success": False, + "status": "XXX", + "error": request.text + } + + + def summarize_responses(self, one_response, summary): + summary["results"].append(one_response) + + # if ONE request fails, summary is marked as failed + if False == one_response["success"]: + summary["success"] = False + + # if one status code is not 200, use this failure status code for summary + if "200" != one_response["status"]: + summary["status"] = one_response["status"] + + return summary + + + def Send_SMS(self, url, headers="", username="", password="", body="", From="", To="", timeout=5): + url = self.fix_url(url) + + parsed_headers = self.splitheaders(headers) + parsed_headers["User-Agent"] = "Shuffle Automation" + body = self.checkbody(body) + + auth=None + if username or password: + # Shouldn't be used if authorization headers exist + if "Authorization" in parsed_headers: + #print("Found authorization - skipping username & pw") + pass + else: + auth = requests.auth.HTTPBasicAuth(username, password) + + if not timeout: + timeout = 5 + if timeout: + timeout = int(timeout) + + summary = { + "success": True, + "status": "200", + "url": url, + "results": [] + } + + # send Twilio API request for every single receiver number + for receiver in To.split(","): + data = {'Body' : body, 'From' : From, 'To' : receiver.strip()} + request = requests.post(url, headers=parsed_headers, auth=auth, data=data, timeout=timeout) + response = self.prepare_response(request) + summary = self.summarize_responses(response, summary) + + return json.dumps(summary) + + +# Run the actual thing after we've checked params +def run(request): + print("Starting cloud!") + action = request.get_json() + print(action) + print(type(action)) + authorization_key = action.get("authorization") + current_execution_id = action.get("execution_id") + + if action and "name" in action and "app_name" in action: + TWILIO.run(action) + return f'Attempting to execute function {action["name"]} in app {action["app_name"]}' + else: + return f'Invalid action' + +if __name__ == "__main__": + TWILIO.run() diff --git a/twitter/1.0.0/requirements.txt b/twitter/1.0.0/requirements.txt deleted file mode 100644 index 2f3005a4..00000000 --- a/twitter/1.0.0/requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -requests==2.25.1 -twython diff --git a/lastline/1.0.0/Dockerfile b/unsupported/DuoSecurity/1.0.0/Dockerfile similarity index 100% rename from lastline/1.0.0/Dockerfile rename to unsupported/DuoSecurity/1.0.0/Dockerfile diff --git a/unsupported/DuoSecurity/1.0.0/api.yaml b/unsupported/DuoSecurity/1.0.0/api.yaml new file mode 100644 index 00000000..d5367c0d --- /dev/null +++ b/unsupported/DuoSecurity/1.0.0/api.yaml @@ -0,0 +1,165 @@ +app_version: 1.0.0 +name: DuoSecurity +description: Easy, Flexible Cybersecurity Solutions for Everyone +contact_info: + name: "@BhavikPrajapati" + url: https://shuffler.io + email: bhavikp@infopercept.com +tags: + - Working With Duo Security Rest APIs +categories: + - Testing +authentication: + required: true + parameters: + - name: secret_key + description: Secret key of Duo security + example: "*****" + required: true + schema: + type: string + - name: itegration_key + description: Itegration key of Duo security + example: "*****" + required: true + schema: + type: string + - name: api_host + description: base url of Duo security server + example: "https://api-3646f74c.duosecurity.com/" + required: true + schema: + type: string + +actions: + - name: Ping + description: Endpoint to verify that Duo is up before trying to call other Auth API endpoints + returns: + schema: + type: string + + - name: Check + description: Endpoint to verify that the Auth API integration and secret keys are valid, and that the signature is being generated properly + returns: + schema: + type: string + + - name: GetLogo + description: Endpoint provides a programmatic way to retrieve your stored logo. + returns: + schema: + type: string + + - name: EnrollNewUser + description: Endpoint provides a programmatic way to enroll new users with Duo two-factor authentication. It creates the user in Duo and returns a code (as a QR code) that Duo Mobile can scan with its built-in camera. Scanning the QR code adds the user's account to the app so that they receive and respond to Duo Push login requests. + parameters: + - name: username + description: Username for the created user. If not given, a random username will be assigned and returned + required: true + multiline: false + example: "Your Name" + schema: + type: string + returns: + schema: + type: string + + - name: GetEnrollStatus + description: Endpoint to check whether a user has completed enrollment + parameters: + - name: user_id + description: ID of the user + required: true + multiline: false + example: "DU94SWSN4ADHHJHF2HXT" + schema: + type: string + - name: activation_code + description: Activation code, as returned from /enroll + required: true + multiline: false + example: "duo://8LIRa5danrICkhHtkLxi-cKLu2DWzDYCmBwBHY2YzW5ZYnYaRxA" + schema: + type: string + returns: + schema: + type: string + + - name: PreAuthCheck + description: Endpoint determines whether a user is authorized to log in, and (if so) returns the user's available authentication factors. + parameters: + - name: user_id + description: Permanent, unique identifier for the user as generated by Duo upon user creation + required: true + multiline: false + example: "DU94SWSN4ADHHJHF2HXT" + schema: + type: string + - name: username + description: Unique identifier for the user that is commonly specified by your application during user creation (e.g. user@domain.com). This value may also represent a username alias assigned to a user + required: true + multiline: false + example: "abc" + schema: + type: string + returns: + schema: + type: string + + - name: Auth + description: Endpoint performs second-factor authentication for a user by sending a push notification to the user's smartphone app, verifying a passcode, or placing a phone call. It is also used to send the user a new batch of passcodes via SMS. + parameters: + - name: user_id + description: Permanent, unique identifier for the user as generated by Duo upon user creation + required: true + multiline: false + example: "DU94SWSN4ADHHJHF2HXT" + schema: + type: string + - name: username + description: Unique identifier for the user that is commonly specified by your application during user creation (e.g. user@domain.com). This value may also represent a username alias assigned to a user + required: true + multiline: false + example: "abc" + schema: + type: string + - name: factor + description: Factor to use for authentication the following choices are supported auto,push,passcode,sms,phone Also see below for additional parameters that are necessary depending on the factor you specify. + required: true + multiline: false + example: "auto" + schema: + type: string + - name: device + description: ID of the device. This device must have the "push" capability.You may also specify "auto" to use the first of the user's devices with the "push" capability. + required: true + multiline: false + example: "auto" + schema: + type: string + - name: passcode + description: Passcode entered by the user. + required: true + multiline: false + example: "********" + schema: + type: string + returns: + schema: + type: string + + - name: GetAuthStatus + description: Endpoint "long-polls" for the next status update from the authentication process for a given transaction. That is to say, if no status update is available at the time the request is sent, it will wait until there is an update before returning a response. + parameters: + - name: txid + description: The transaction ID of the authentication attempt, as returned by the /auth endpoint. + required: true + multiline: false + example: "45f7c92b-f45f-4862-8545-e0f58e78075a" + schema: + type: string + returns: + schema: + type: string + +large_image: data:image/png;base64,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 \ No newline at end of file diff --git a/unsupported/DuoSecurity/1.0.0/requirements.txt b/unsupported/DuoSecurity/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/DuoSecurity/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/unsupported/DuoSecurity/1.0.0/src/app.py b/unsupported/DuoSecurity/1.0.0/src/app.py new file mode 100644 index 00000000..84f049d1 --- /dev/null +++ b/unsupported/DuoSecurity/1.0.0/src/app.py @@ -0,0 +1,231 @@ + +import base64 +import email.utils +import hmac +import hashlib +import urllib +import requests +import json +from walkoff_app_sdk.app_base import AppBase + + +class DuoSecurity(AppBase): + __version__ = "1.0.0" + app_name = "DuoSecurity" # this needs to match "name" in api.yaml + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def sign(self, secret_key, itegration_key, api_host, method, path, params): + """ + Return HTTP Basic Authentication ("Authorization" and "Date") headers. + method, host, path: strings from request + params: dict of request parameters + skey: secret key + ikey: integration key + """ + # create canonical string + now = email.utils.formatdate() + canon = [now, method.upper(), api_host.lower(), path] + args = [] + for key in sorted(params.keys()): + val = params[key].encode("utf-8") + args.append( + '%s=%s' % (urllib.parse. + quote(key, '~'), urllib.parse.quote(val, '~'))) + canon.append('&'.join(args)) + canon = '\n'.join(canon) + + # sign canonical string + sig = hmac.new(bytes(secret_key, encoding='utf-8'), + bytes(canon, encoding='utf-8'), + hashlib.sha1) + print("sig", sig.hexdigest()) + print("intergration key", itegration_key) + auth = '%s:%s' % (itegration_key, sig.hexdigest()) + + # return headers + print("base",base64.b64encode(bytes(auth, encoding="utf-8")).decode()) + return {'Date': now, 'Authorization': 'Basic %s' % base64.b64encode(bytes(auth, encoding="utf-8")).decode()} + + # Function to verify that Duo is up before trying to call other Auth API endpoints + def Ping(self, secret_key, itegration_key, api_host): + path = "/auth/v2/ping" + request_url = f"{api_host}{path}" + params = {} + headers = self.sign(secret_key, itegration_key, + api_host, "GET", path, params) + request_headers = {'Content-Type': 'application/json', + 'Authorization': f"{headers['Authorization']}", 'Date': f"{headers['Date']}"} + try: + response = requests.get( + request_url, headers=request_headers, verify=False) + print(response) + res = json.loads(response.text) + print(res) + return res + except Exception as e: + return json.dumps({"success": "false", "message": str(e)}) + + # Function to verify that the Auth API integration and secret keys are valid, and that the signature is being generated properly + def Check(self, secret_key, itegration_key, api_host): + path = "/auth/v2/check" + request_url = f"{api_host}{path}" + params = {} + headers = self.sign(secret_key, itegration_key, + api_host, "GET", path,params) + + print(headers['Date']) + print(headers['Authorization']) + request_headers = {"Content-Type": "application/x-www-form-urlencoded","Date": f"{headers['Date']}","Authorization": f"{headers['Authorization']}"} + try: + response = requests.get( + request_url, headers=request_headers, verify=True) + res = json.loads(response.content.decode()) + return res + except Exception as e: + return json.dumps({"success": "false", "message": str(e)}) + + # Function provides a programmatic way to retrieve your stored logo. + def GetLogo(self, secret_key, itegration_key, api_host): + path = "/auth/v2/logo" + params = {} + request_url = f"{api_host}{path}" + headers = self.sign(secret_key, itegration_key, + api_host, "GET", path, params) + request_headers = {'Content-Type': 'application/json', + 'Authorization': f"{headers.get('Authorization')}", 'Date': f"{headers.get('Date')}"} + try: + response = requests.get( + request_url, headers=request_headers, verify=False) + res = json.loads(response.content.decode()) + return res + except Exception as e: + return json.dumps({"success": "false", "message": str(e)}) + + # Function provides a programmatic way to enroll new users with Duo two-factor authentication. It creates the user in Duo and returns a code (as a QR code) that Duo Mobile can scan with its built-in camera. Scanning the QR code adds the user's account to the app so that they receive and respond to Duo Push login requests. + def EnrollNewUser(self, secret_key, itegration_key, api_host, username): + path = "/auth/v2/enroll" + params = {"username": username} + request_url = f"{api_host}{path}" + + headers = self.sign(secret_key, itegration_key,api_host, "POST", path, params) + + request_headers = {"Content-Type": "application/x-www-form-urlencoded", + "Authorization": f"{headers['Authorization']}", 'Date': f"{headers['Date']}"} + + print(headers['Authorization']) + print(headers['Date']) + + payload = json.dumps(params) + try: + response = requests.request( + "POST", request_url, headers=request_headers, data=payload) + res = json.loads(response.content.decode()) + return res + except Exception as e: + return json.dumps({"success": "false", "message": str(e)}) + + # Check whether a user has completed enrollment. + def GetEnrollStatus(self, secret_key, itegration_key, api_host, user_id, activation_code): + path = "/auth/v2/enroll_status" + params = { + "user_id": user_id, + "activation_code": activation_code + } + request_url = f"{api_host}{path}" + + headers = self.sign(secret_key, itegration_key, + api_host, "POST", path, params) + + request_headers = {'Content-Type': 'application/json', + 'Authorization': f"{headers['Authorization']}", 'Date': f"{headers['Date']}"} + + payload = json.dumps(params) + try: + response = requests.request( + "POST", request_url, headers=request_headers, data=payload) + res = json.loads(response.content.decode()) + return res + except Exception as e: + return json.dumps({"success": "false", "message": str(e)}) + + # Function determines whether a user is authorized to log in, and (if so) returns the user's available authentication factors. + def PreAuthCheck(self, secret_key, itegration_key, api_host, user_id, username): + path = "/auth/v2/preauth" + params = { + "user_id": user_id, + "username": username + } + request_url = f"{api_host}{path}" + + headers = self.sign(secret_key, itegration_key, + api_host, "POST", path, params) + + request_headers = {'Content-Type': 'application/json', + 'Authorization': f"{headers['Authorization']}", 'Date': f"{headers['Date']}"} + + payload = json.dumps(params) + try: + response = requests.request( + "POST", request_url, headers=request_headers, data=payload) + res = json.loads(response.content.decode()) + return res + except Exception as e: + return json.dumps({"success": "false", "message": str(e)}) + + # Function performs second-factor authentication for a user by sending a push notification to the user's smartphone app, verifying a passcode, or placing a phone call. It is also used to send the user a new batch of passcodes via SMS. + def Auth(self, secret_key, itegration_key, api_host, user_id, username, factor, device, passcode): + path = "/auth/v2/auth" + params = { + "user_id": user_id, + "username": username, + "factor": factor, + "device": device, + "passcode": passcode + } + request_url = f"{api_host}{path}" + + headers = self.sign(secret_key, itegration_key, + api_host, "POST", path, params) + + request_headers = {'Content-Type': 'application/json', + 'Authorization': f"{headers['Authorization']}", 'Date': f"{headers['Date']}"} + + payload = json.dumps(params) + try: + response = requests.request( + "POST", request_url, headers=request_headers, data=payload) + res = json.loads(response.content.decode()) + return res + except Exception as e: + return json.dumps({"success": "false", "message": str(e)}) + + # Function "long-polls" for the next status update from the authentication process for a given transaction. That is to say, if no status update is available at the time the request is sent, it will wait until there is an update before returning a response. + def GetAuthStatus(self, secret_key, itegration_key, api_host, txid): + path = "/auth/v2/auth_status" + params = { + "txid": txid + } + request_url = f"{api_host}{path}" + headers = self.sign(secret_key, itegration_key, + api_host, "GET", path, params) + request_headers = {'Content-Type': 'application/json', + 'Authorization': f"{headers['Authorization']}", 'Date': f"{headers['Date']}"} + try: + response = requests.get( + request_url, headers=request_headers, verify=False) + res = json.loads(response.content.decode()) + return res + except Exception as e: + return json.dumps({"success": "false", "message": str(e)}) + + +if __name__ == "__main__": + DuoSecurity.run() diff --git a/microsoft-identity-and-access/1.0.0/Dockerfile b/unsupported/ad-ldap/1.0.0/Dockerfile similarity index 100% rename from microsoft-identity-and-access/1.0.0/Dockerfile rename to unsupported/ad-ldap/1.0.0/Dockerfile diff --git a/ad-ldap/1.0.0/README.md b/unsupported/ad-ldap/1.0.0/README.md similarity index 100% rename from ad-ldap/1.0.0/README.md rename to unsupported/ad-ldap/1.0.0/README.md diff --git a/ad-ldap/1.0.0/api.yaml b/unsupported/ad-ldap/1.0.0/api.yaml similarity index 100% rename from ad-ldap/1.0.0/api.yaml rename to unsupported/ad-ldap/1.0.0/api.yaml diff --git a/unsupported/ad-ldap/1.0.0/requirements.txt b/unsupported/ad-ldap/1.0.0/requirements.txt new file mode 100644 index 00000000..53f3e6a1 --- /dev/null +++ b/unsupported/ad-ldap/1.0.0/requirements.txt @@ -0,0 +1,2 @@ +ldap3==2.9.1 +requests==2.32.4 diff --git a/ad-ldap/1.0.0/src/app.py b/unsupported/ad-ldap/1.0.0/src/app.py similarity index 100% rename from ad-ldap/1.0.0/src/app.py rename to unsupported/ad-ldap/1.0.0/src/app.py diff --git a/unsupported/ansible/1.0.0/requirements.txt b/unsupported/ansible/1.0.0/requirements.txt index 7b2bf77e..c67cded2 100644 --- a/unsupported/ansible/1.0.0/requirements.txt +++ b/unsupported/ansible/1.0.0/requirements.txt @@ -1,2 +1,2 @@ -requests==2.25.1 -ansible==4.8.0 +requests==2.32.4 +ansible==8.5.0 diff --git a/unsupported/attack-predictor/1.0.0/requirements.txt b/unsupported/attack-predictor/1.0.0/requirements.txt index 3d75ab52..5687cab1 100644 --- a/unsupported/attack-predictor/1.0.0/requirements.txt +++ b/unsupported/attack-predictor/1.0.0/requirements.txt @@ -1,7 +1,7 @@ -joblib==0.14.1 -numpy==1.17.4 -stix2==1.2.1 -nltk==3.4.5 -colorama +colorama==0.4.4 +joblib==1.2.0 +nltk==3.9.1 +numpy==1.22.0 pandas==0.25.3 #scikit-learn==0.22.2.post1 +stix2==1.2.1 diff --git a/crowdstrike-falcon/1.0.0/Dockerfile b/unsupported/crowdstrike-falcon/1.0.0/Dockerfile similarity index 100% rename from crowdstrike-falcon/1.0.0/Dockerfile rename to unsupported/crowdstrike-falcon/1.0.0/Dockerfile diff --git a/crowdstrike-falcon/1.0.0/api.yaml b/unsupported/crowdstrike-falcon/1.0.0/api.yaml similarity index 100% rename from crowdstrike-falcon/1.0.0/api.yaml rename to unsupported/crowdstrike-falcon/1.0.0/api.yaml diff --git a/crowdstrike-falcon/1.0.0/requirements.txt b/unsupported/crowdstrike-falcon/1.0.0/requirements.txt similarity index 64% rename from crowdstrike-falcon/1.0.0/requirements.txt rename to unsupported/crowdstrike-falcon/1.0.0/requirements.txt index dfad3eb9..f76ae497 100644 --- a/crowdstrike-falcon/1.0.0/requirements.txt +++ b/unsupported/crowdstrike-falcon/1.0.0/requirements.txt @@ -1,3 +1 @@ # No extra requirements needed -requests -urllib3 diff --git a/crowdstrike-falcon/1.0.0/src/app.py b/unsupported/crowdstrike-falcon/1.0.0/src/app.py similarity index 100% rename from crowdstrike-falcon/1.0.0/src/app.py rename to unsupported/crowdstrike-falcon/1.0.0/src/app.py diff --git a/cylance/1.0.0/Dockerfile b/unsupported/cylance/1.0.0/Dockerfile similarity index 100% rename from cylance/1.0.0/Dockerfile rename to unsupported/cylance/1.0.0/Dockerfile diff --git a/cylance/1.0.0/api.yaml b/unsupported/cylance/1.0.0/api.yaml similarity index 100% rename from cylance/1.0.0/api.yaml rename to unsupported/cylance/1.0.0/api.yaml diff --git a/unsupported/cylance/1.0.0/requirements.txt b/unsupported/cylance/1.0.0/requirements.txt new file mode 100644 index 00000000..a76afb96 --- /dev/null +++ b/unsupported/cylance/1.0.0/requirements.txt @@ -0,0 +1,3 @@ +cryptography==44.0.1 +requests==2.32.4 +PyJWT==2.4.0 diff --git a/cylance/1.0.0/src/app.py b/unsupported/cylance/1.0.0/src/app.py similarity index 100% rename from cylance/1.0.0/src/app.py rename to unsupported/cylance/1.0.0/src/app.py diff --git a/unsupported/email-analyzer/1.0.0/requirements.txt b/unsupported/email-analyzer/1.0.0/requirements.txt index 4965a825..f3ecd49c 100644 --- a/unsupported/email-analyzer/1.0.0/requirements.txt +++ b/unsupported/email-analyzer/1.0.0/requirements.txt @@ -1,4 +1,4 @@ -requests==2.25.1 +requests==2.32.4 eml-parser==1.14.7 msg-parser==1.2.0 mail-parser==3.15.0 diff --git a/microsoft-security-and-compliance/1.0.0/Dockerfile b/unsupported/hoxhunt/1.0.0/Dockerfile similarity index 100% rename from microsoft-security-and-compliance/1.0.0/Dockerfile rename to unsupported/hoxhunt/1.0.0/Dockerfile diff --git a/hoxhunt/1.0.0/api.yaml b/unsupported/hoxhunt/1.0.0/api.yaml similarity index 100% rename from hoxhunt/1.0.0/api.yaml rename to unsupported/hoxhunt/1.0.0/api.yaml diff --git a/unsupported/hoxhunt/1.0.0/requirements.txt b/unsupported/hoxhunt/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/hoxhunt/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/hoxhunt/1.0.0/src/app.py b/unsupported/hoxhunt/1.0.0/src/app.py similarity index 100% rename from hoxhunt/1.0.0/src/app.py rename to unsupported/hoxhunt/1.0.0/src/app.py diff --git a/microsoft-teams-system-access/1.0.0/Dockerfile b/unsupported/lastline/1.0.0/Dockerfile similarity index 100% rename from microsoft-teams-system-access/1.0.0/Dockerfile rename to unsupported/lastline/1.0.0/Dockerfile diff --git a/unsupported/lastline/1.0.0/api.yaml b/unsupported/lastline/1.0.0/api.yaml new file mode 100644 index 00000000..69bfd25d --- /dev/null +++ b/unsupported/lastline/1.0.0/api.yaml @@ -0,0 +1,312 @@ +walkoff_version: 1.0.0 +app_version: 1.0.0 +name: lastline +description: Lastline app interface +tags: + - sandbox + - antivirus + - email +categories: + - sandbox + - antivirus + - email +contact_info: + name: "@frikkylikeme" + url: https://github.com/frikky + email: "frikky@shuffler.io" +actions: + - name: get_event + description: Get an event + parameters: + - name: url + description: The url to use for the API + multiline: false + example: "https://user.lastline.com" + required: true + schema: + type: string + - name: user + description: The user to use for the API + multiline: false + example: "Username" + required: true + schema: + type: string + - name: password + description: The password to use for the API + multiline: false + example: "p@ssw0rd" + required: true + schema: + type: string + - name: event_id + description: The event ID to get + multiline: false + example: "" + required: true + schema: + type: string + returns: + schema: + type: string + - name: get_mail_attachments + description: Get unique mail attachments + parameters: + - name: url + description: The url to use for the API + multiline: false + example: "https://user.lastline.com" + required: true + schema: + type: string + - name: user + description: The user to use for the API + multiline: false + example: "Username" + required: true + schema: + type: string + - name: password + description: The password to use for the API + multiline: false + example: "p@ssw0rd" + required: true + schema: + type: string + - name: start_time + description: The starttime to use + multiline: false + example: "2019-06-01" + required: true + schema: + type: string + - name: end_time + description: The endtime to use + multiline: false + example: "2019-06-02" + required: true + schema: + type: string + - name: limit + description: Max events to get + multiline: false + example: "2019-06-02" + required: false + schema: + type: string + returns: + schema: + type: string + - name: get_mail_urls + description: Get unique url seen in mail + parameters: + - name: url + description: The url to use for the API + multiline: false + example: "https://user.lastline.com" + required: true + schema: + type: string + - name: user + description: The user to use for the API + multiline: false + example: "Username" + required: true + schema: + type: string + - name: password + description: The password to use for the API + multiline: false + example: "p@ssw0rd" + required: true + schema: + type: string + - name: start_time + description: The starttime to use + multiline: false + example: "2019-06-01" + required: true + schema: + type: string + - name: end_time + description: The endtime to use + multiline: false + example: "2019-06-02" + required: true + schema: + type: string + - name: limit + description: Max events to get + multiline: false + example: "2019-06-02" + required: false + schema: + type: string + returns: + schema: + type: string + - name: get_network_events + description: Get network events + parameters: + - name: url + description: The url to use for the API + multiline: false + example: "https://user.lastline.com" + required: true + schema: + type: string + - name: user + description: The user to use for the API + multiline: false + example: "Username" + required: true + schema: + type: string + - name: password + description: The password to use for the API + multiline: false + example: "p@ssw0rd" + required: true + schema: + type: string + - name: start_time + description: The starttime to use + multiline: false + example: "2019-06-01" + required: true + schema: + type: string + - name: end_time + description: The endtime to use + multiline: false + example: "2019-06-02" + required: true + schema: + type: string + - name: limit + description: Max events to get + multiline: false + example: "2019-06-02" + required: false + schema: + type: string + returns: + schema: + type: string + - name: get_endpoint_events + description: Gets endpoint events + parameters: + - name: url + description: The url to use for the API + multiline: false + example: "https://user.lastline.com" + required: true + schema: + type: string + - name: user + description: The user to use for the API + multiline: false + example: "Username" + required: true + schema: + type: string + - name: password + description: The password to use for the API + multiline: false + example: "p@ssw0rd" + required: true + schema: + type: string + - name: start_time + description: The starttime to use + multiline: false + example: "2019-06-01" + required: true + schema: + type: string + - name: end_time + description: The endtime to use + multiline: false + example: "2019-06-02" + required: true + schema: + type: string + - name: limit + description: Max events to get + multiline: false + example: "2019-06-02" + required: false + schema: + type: string + returns: + schema: + type: string + - name: get_history + description: Get submission history + parameters: + - name: url + description: The url to use for the API + multiline: false + example: "https://user.lastline.com" + required: true + schema: + type: string + - name: user + description: The user to use for the API + multiline: false + example: "Username" + required: true + schema: + type: string + - name: password + description: The password to use for the API + multiline: false + example: "p@ssw0rd" + required: true + schema: + type: string + - name: limit + description: Max events to get + multiline: false + example: "2" + required: false + schema: + type: string + returns: + schema: + type: string + - name: submit_url + description: Submit an url for analysis + parameters: + - name: url + description: The url to use for the API + multiline: false + example: "https://user.lastline.com" + required: true + schema: + type: string + - name: user + description: The user to use for the API + multiline: false + example: "Username" + required: true + schema: + type: string + - name: password + description: The password to use for the API + multiline: false + example: "p@ssw0rd" + required: true + schema: + type: string + - name: url_to_submit + description: The url to submit + multiline: false + example: "https://malicious.com" + required: false + schema: + type: string + returns: + schema: + type: string +large_image: data:image/png;base64,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 diff --git a/unsupported/lastline/1.0.0/requirements.txt b/unsupported/lastline/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/lastline/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/lastline/1.0.0/src/app.py b/unsupported/lastline/1.0.0/src/app.py similarity index 100% rename from lastline/1.0.0/src/app.py rename to unsupported/lastline/1.0.0/src/app.py diff --git a/unsupported/microsoft-compliance/1.0.0/Dockerfile b/unsupported/microsoft-compliance/1.0.0/Dockerfile new file mode 100644 index 00000000..1830b926 --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/Dockerfile @@ -0,0 +1,108 @@ +# Base our app image off of the WALKOFF App SDK image +FROM frikky/shuffle:app_sdk as base + +# We're going to stage away all of the bloat from the build tools so lets create a builder stage +FROM base as builder + +# Install all alpine build tools needed for our pip installs +RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev + +# Install all of our pip packages in a single directory that we can copy to our base image later +RUN mkdir /install +WORKDIR /install +COPY requirements.txt /requirements.txt +RUN pip install --prefix="/install" -r /requirements.txt + +# Switch back to our base image and copy in all of our built packages and source code +FROM base +COPY --from=builder /install /usr/local +COPY src /app + +# Install any binary dependencies needed in our final image +# RUN apk --no-cache add --update my_binary_dependency +RUN apk add --no-cache \ + ca-certificates \ + less \ + ncurses-terminfo-base \ + krb5-libs \ + libgcc \ + libintl \ + libssl1.1 \ + libstdc++ \ + tzdata \ + userspace-rcu \ + zlib \ + icu-libs \ + curl + +RUN apk -X https://dl-cdn.alpinelinux.org/alpine/edge/main add --no-cache \ + lttng-ust + +# Download the powershell '.tar.gz' archive +RUN curl -L https://github.com/PowerShell/PowerShell/releases/download/v7.2.3/powershell-7.2.3-linux-alpine-x64.tar.gz -o /tmp/powershell.tar.gz + +# Create the target folder where powershell will be placed +RUN mkdir -p /opt/microsoft/powershell/7 + +# Expand powershell to the target folder +RUN tar zxf /tmp/powershell.tar.gz -C /opt/microsoft/powershell/7 + +# Set execute permissions +RUN chmod +x /opt/microsoft/powershell/7/pwsh + +## PS Gallery things for windows when you want -AllowPrerelease +# Install-Module -Name PackageManagement -Repository PSGallery -Force +# Install-Module -Name PowerShellGet -Repository PSGallery -Force + +# Create the symbolic link that points to pwsh +RUN ln -s /opt/microsoft/powershell/7/pwsh /usr/bin/pwsh +#RUN pwsh -Command Install-Module -Name ExchangeOnlineManagement -AllowPrerelease -Force -RequiredVersion 2.0.6-Preview5 +RUN pwsh -Command Install-Module -Name ExchangeOnlineManagement -AllowPrerelease -Force -RequiredVersion 2.0.6-Preview5 +RUN sh -c "yes | pwsh -Command 'Install-Module -Name PSWSMan'" +RUN pwsh -Command 'Install-WSMan' +#RUN pwsh -Command Import-Module 'Microsoft.PowerShell.Security' -Force + + +# Adds a replacement file which will be used to run the powershell script from python +COPY replacementfile.ps1 /app/replacementfile.ps1 +#COPY password.ps1 password.ps1 +#RUN pwsh -file password.ps1 +#RUN pwsh -Command Get-Help Connect-IPPSSession +#RUN pwsh -Command Get-Help Connect-ExchangeOnline +#RUN pwsh -Command Get-Help New-PSSession +#Connect-ExchangeOnline -CertificateFilePath "C:\Users\johndoe\Desktop\automation-cert.pfx" -CertificatePassword (ConvertTo-SecureString -String "" -AsPlainText -Force) -AppID "36ee4c6c-0812-40a2-b820-b22ebd02bce3" -Organization "contosoelectronics.onmicrosoft.com" +#RUN pwsh -Command Get-Help Connect-IPPSSession + +#COPY ./src/example.pfx example.pfx +#RUN cat /root/.local/share/powershell/Modules/ExchangeOnlineManagement/2.0.6/netCore/ExchangeOnlineManagement.psm1 +#RUN grep -Ri "connect-exchangeonline" /root/.local/share/powershell/Modules/ExchangeOnlineManagement/2.0.6/netCore/ +RUN cat /root/.local/share/powershell/Modules/ExchangeOnlineManagement/2.0.6/netCore/ExchangeOnlineManagement.psm1 +#RUN ls /root/.local/share/powershell/Modules/ExchangeOnlineManagement/ +#RUN pwsh -Command '(Get-Module -ListAvailable ExchangeOnlineManagement*).path' +#RUN pwsh -Command Import-Module ExchangeOnlineManagement +#RUN pwsh -Command 'Get-Help Connect-IPPSSession' +#RUN pwsh -Command 'Get-Help Connect-ExchangeOnline' +#RUN pwsh -Command '(Get-Module -ListAvailable Connect-ExchangeOnline*).path' +#RUN pwsh -Command 'Import-Module ExchangeOnlineManagement -SkipeditionCheck' + + +## SSL things +#RUN curl -L http://security.ubuntu.com/ubuntu/pool/main/o/openssl1.0/libssl1.0.0_1.0.2n-1ubuntu5.5_amd64.deb -o libssl1.0.0_1.0.2n-1ubuntu5.5_amd64.deb +#RUN dpkg -i libssl1.0.0_1.0.2n-1ubuntu5.5_amd64.deb + +#RUN pwsh -Command New-exoModule +COPY yh2.psm1 /root/.local/share/powershell/Modules/ExchangeOnlineManagement/2.0.6/netCore/ExchangeOnlineManagement.psm1 +COPY src/example.pfx example.pfx +RUN pwsh -Command 'echo "hi"' +RUN pwsh -Command 'Connect-IPPSSession -CertificateFilePath "./example.pfx" -AppID "70a66541-50e6-47e4-83d9-ccaa55db7da9" -Organization "shufflertest2.onmicrosoft.com" -CertificatePassword (ConvertTo-SecureString -String "" -AsPlainText -Force) -verbose' + +#RUN pwsh -Command 'Get-Help Connect-ExchangeOnline' +#RUN pwsh -Command 'Connect-ExchangeOnline -CertificateFilePath "./example.pfx" -CertificatePassword (ConvertTo-SecureString -String "" -AsPlainText -Force) -AppID "70a66541-50e6-47e4-83d9-ccaa55db7da9" -Organization "shufflertest2.onmicrosoft.com" -ConnectionUri "https://ps.compliance.protection.outlook.com/PowerShell-LiveId" -AzureADAuthorizationEndpointUri "https://login.microsoftonline.com/organizations" -UseRPSSession:$true -ShowBanner:$false -BypassMailboxAnchoring:$false -ShowProgress:$true -verbose -CommandName "Test-ActiveToken"' + + +#RUN pwsh -Command 'Connect-ExchangeOnline -CertificateFilePath "./example.pfx" -CertificatePassword (ConvertTo-SecureString -String "" -AsPlainText -Force) -AppID "70a66541-50e6-47e4-83d9-ccaa55db7da9" -Organization "shufflertest2.onmicrosoft.com" -CommandName Get-QuarantineMessage; Get-QuarantineMessage' +#RUN pwsh -Command 'Connect-ExchangeOnline -CertificateFilePath "./example.pfx" -CertificatePassword (ConvertTo-SecureString -String "" -AsPlainText -Force) -AppID "70a66541-50e6-47e4-83d9-ccaa55db7da9" -Organization "shufflertest2.onmicrosoft.com"; Get-ComplianceSearch' + +# Finally, lets run our app! +WORKDIR /app +CMD python app.py --log-level DEBUG diff --git a/unsupported/microsoft-compliance/1.0.0/README.md b/unsupported/microsoft-compliance/1.0.0/README.md new file mode 100644 index 00000000..42fc813f --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/README.md @@ -0,0 +1 @@ +# Directory to run things related to compliance and test powershell things diff --git a/python3-playground/1.0.0/api.yaml b/unsupported/microsoft-compliance/1.0.0/api.yaml similarity index 85% rename from python3-playground/1.0.0/api.yaml rename to unsupported/microsoft-compliance/1.0.0/api.yaml index 83797dd0..48930c0e 100644 --- a/python3-playground/1.0.0/api.yaml +++ b/unsupported/microsoft-compliance/1.0.0/api.yaml @@ -1,5 +1,5 @@ app_version: 1.0.0 -name: Python3 playground +name: Microsoft Compliance description: A test app made for you to personally change the code contact_info: name: "@frikkylikeme" @@ -10,24 +10,68 @@ tags: categories: - Testing actions: - - name: run_python_script + - name: run_custom description: Runs a python script defined by YOU parameters: - - name: json_data - description: The JSON to handle + - name: certificate + description: The File ID of the certificate to use required: true - multiline: true example: '{"data": "testing"}' schema: type: string - - name: function_to_execute - description: The selected python function to run + - name: password + description: The password for the certificate + required: true + example: '1' + schema: + type: string + - name: app_id + description: The app ID from azure + required: true + example: '1' + schema: + type: string + - name: organization + description: The organization required: true + example: '1' + schema: + type: string + - name: command + description: The organization multiline: true + required: true + example: '1' + schema: + type: string + returns: + schema: + type: string + - name: get_mailbox + description: Runs a python script defined by YOU + parameters: + - name: certificate + description: The File ID of the certificate to use + required: true + example: '{"data": "testing"}' + schema: + type: string + - name: password + description: The password for the certificate + required: true + example: '1' + schema: + type: string + - name: app_id + description: The app ID from azure + required: true + example: '1' + schema: + type: string + - name: organization + description: The organization + required: true example: '1' - options: - - function_1 - - function_2 schema: type: string returns: diff --git a/unsupported/microsoft-compliance/1.0.0/replacementfile.ps1 b/unsupported/microsoft-compliance/1.0.0/replacementfile.ps1 new file mode 100644 index 00000000..194ea36a --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/replacementfile.ps1 @@ -0,0 +1,6 @@ +# This file is used to run powershell-remote commands from within Shuffle from python. +# Fields using { } are to be replaced (username, password, command) +Connect-IPPSSession -CertificateFilePath "./cert.pfx" -AppID "{APP_ID}" -Organization "{ORGANIZATION}" -CertificatePassword (ConvertTo-SecureString -String "{PASSWORD}" -AsPlainText -Force) + +echo "SHFFL_START" +{COMMAND} diff --git a/unsupported/microsoft-compliance/1.0.0/requirements.txt b/unsupported/microsoft-compliance/1.0.0/requirements.txt new file mode 100644 index 00000000..bd6f2345 --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 diff --git a/unsupported/microsoft-compliance/1.0.0/src/app.py b/unsupported/microsoft-compliance/1.0.0/src/app.py new file mode 100644 index 00000000..e80fefc7 --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/src/app.py @@ -0,0 +1,139 @@ +import socket +import asyncio +import time +import random +import json +import subprocess +import base64 + +from walkoff_app_sdk.app_base import AppBase + +class Compliance(AppBase): + __version__ = "1.0.0" + app_name = "compliance" + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + self.filename = "replacementfile.ps1" + super().__init__(redis, logger, console_logger) + + def cleanup(self, item): + newlines = [] + record = False + skipped = 0 + for line in item.split("\n"): + if line.startswith("{") or line.startswith("["): + record = True + + if not record and not line.startswith("{") and not line.startswith("["): + skipped += 1 + + if record: + newlines.append(line) + + #if "SHFFL_START" in line: + # record = True + + self.logger.info(f"SKIPPED {skipped} lines") + if len(newlines) == 0: + return item + + item = "\n".join(newlines) + + return item + + def replace_and_run(self, password, app_id, organization, command): + data = "" + with open(self.filename, "r") as tmp: + data = tmp.read() + + if len(data) == 0: + return "" + + data = data.replace("{PASSWORD}", password) + data = data.replace("{APP_ID}", app_id) + data = data.replace("{ORGANIZATION}", organization) + data = data.replace("{COMMAND}", command) + + with open(self.filename, "w+") as tmp: + tmp.write(data) + + command = f"pwsh -file {self.filename}" + self.logger.info(f"PRE POPEN: {command}") + process = subprocess.Popen( + command, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + shell=True, # nosec + ) + self.logger.info("POST STDOUT") + stdout = process.communicate() + self.logger.info(f"STDOUT: {stdout}") + item = "" + if len(stdout[0]) > 0: + item = stdout[0] + self.logger.info("Succesfully ran bash. Stdout: %s" % item) + else: + item = stdout[1] + self.logger.info("FAILED to run bash. Stdout: %s!" % item) + #return item + + try: + new_cleanup = self.cleanup(item) + if len(new_cleanup) > 0: + item = new_cleanup + except Exception as e: + pass + + try: + return item.decode("utf-8") + except Exception as e: + return item + + return item + + def handle_filewriting(self, certificate): + filedata = self.get_file(certificate) + if filedata["success"] == False: + return filedata + + cert = "cert.pfx" + self.logger.info("Writing cert to file %s" % cert) + with open(cert, "wb+") as tmp: + tmp.write(filedata["data"]) + + return filedata + + def run_custom(self, certificate, password, app_id, organization, command): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = command + #if "convertto-json" not in parsed_command.lower(): + # parsed_command = parsed_command + "| ConvertTo-Json -Depth 9" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + + def get_mailbox(self, certificate, password, app_id, organization): + self.logger.info("Getting: %s %s %s %s" % (certificate, password, app_id, organization)) + filedata = self.handle_filewriting(certificate) + if filedata["success"] == False: + return filedata + + parsed_command = f"Get-Mailbox | ConvertTo-Json -Depth 9" + + ret = self.replace_and_run(password, app_id, organization, parsed_command) + return ret + + +if __name__ == "__main__": + Compliance.run() diff --git a/unsupported/microsoft-compliance/1.0.0/src/certgen.sh b/unsupported/microsoft-compliance/1.0.0/src/certgen.sh new file mode 100644 index 00000000..8043a78b --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/src/certgen.sh @@ -0,0 +1,9 @@ +openssl req -new -x509 -newkey rsa:2048 -sha256 \ + -days 3650 \ + -nodes \ + -out example.crt \ + -keyout example.key \ + -subj "/C=SI/ST=Ljubljana/L=Ljubljana/O=Security/OU=IT Department/CN=www.example.com" + +openssl pkcs12 -inkey example.key -in example.crt -export -out example.pfx -password pass:"" + diff --git a/unsupported/microsoft-compliance/1.0.0/src/example.pfx b/unsupported/microsoft-compliance/1.0.0/src/example.pfx new file mode 100644 index 00000000..6d3a1190 Binary files /dev/null and b/unsupported/microsoft-compliance/1.0.0/src/example.pfx differ diff --git a/unsupported/microsoft-compliance/1.0.0/tmp b/unsupported/microsoft-compliance/1.0.0/tmp new file mode 100644 index 00000000..f0a0f157 --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/tmp @@ -0,0 +1,1138 @@ +# Import the REST module so that the EXO* cmdlets are present before Connect-ExchangeOnline in the powershell instance. +$RestModule = "Microsoft.Exchange.Management.RestApiClient.dll" +$RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestModule) +Import-Module $RestModulePath + +$ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll" +$ExoPowershellModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule) +Import-Module $ExoPowershellModulePath + +############# Helper Functions Begin ############# + + <# + Details to be printed on the console when the Connect-ExchangeOnline function is run + #> + function Print-Details + { + if ($UseRPSSession) + { + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "The module allows access to all existing remote PowerShell (V1) cmdlets in addition to the 9 new, faster, and more reliable cmdlets." + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "| Old Cmdlets | New/Reliable/Faster Cmdlets |" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "| Get-CASMailbox | Get-EXOCASMailbox |" + Write-Host -ForegroundColor Yellow "| Get-Mailbox | Get-EXOMailbox |" + Write-Host -ForegroundColor Yellow "| Get-MailboxFolderPermission | Get-EXOMailboxFolderPermission |" + Write-Host -ForegroundColor Yellow "| Get-MailboxFolderStatistics | Get-EXOMailboxFolderStatistics |" + Write-Host -ForegroundColor Yellow "| Get-MailboxPermission | Get-EXOMailboxPermission |" + Write-Host -ForegroundColor Yellow "| Get-MailboxStatistics | Get-EXOMailboxStatistics |" + Write-Host -ForegroundColor Yellow "| Get-MobileDeviceStatistics | Get-EXOMobileDeviceStatistics |" + Write-Host -ForegroundColor Yellow "| Get-Recipient | Get-EXORecipient |" + Write-Host -ForegroundColor Yellow "| Get-RecipientPermission | Get-EXORecipientPermission |" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "To get additional information, run: Get-Help Connect-ExchangeOnline or check https://aka.ms/exops-docs" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "Send your product improvement suggestions and feedback to exocmdletpreview@service.microsoft.com. For issues related to the module, contact Microsoft support. Don't use the feedback alias for problems or support issues." + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "" + + } + else + { + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "This version of EXO PowerShell V2 module contains new REST API backed cmdlets which doesn't require Windows Remote PowerShell for client-server communication." + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "You can now run those cmdlets after turning off WinRM Basic Auth in your client machine and thus making it more secure. Read more here - https://aka.ms/exov2-securemode" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "You can share your feedback and suggestions to exocmdletpreview@service.microsoft.com" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "" + + } + + } + + <# + Get the ExchangeOnlineManagement module version. + Same function is present in the autogen module. Both the codes should be kept in sync. + #> + function Get-ModuleVersion + { + try + { + # Return the already computed version info if available. + if ($script:ModuleVersion -ne $null -and $script:ModuleVersion -ne '') + { + Write-Verbose "Returning precomputed version info: $script:ModuleVersion" + return $script:ModuleVersion; + } + + $exoModule = Get-Module ExchangeOnlineManagement + # Get the module version from the loaded module info. + $script:ModuleVersion = $exoModule.Version.ToString() + + # Look for prerelease information from the corresponding module manifest. + $exoModuleRoot = (Get-Item $exoModule.Path).Directory.Parent.FullName + + $exoModuleManifestPath = Join-Path -Path $exoModuleRoot -ChildPath ExchangeOnlineManagement.psd1 + $isExoModuleManifestPathValid = Test-Path -Path $exoModuleManifestPath + if ($isExoModuleManifestPathValid -ne $true) + { + # Could be a local debug build import for testing. Skip extracting prerelease info for those. + Write-Verbose "Module manifest path invalid, path: $exoModuleManifestPath, skipping extracting prerelease info" + return $script:ModuleVersion + } + + $exoModuleManifestContent = Get-Content -Path $exoModuleManifestPath + $preReleaseInfo = $exoModuleManifestContent -match "Prerelease = '(.*)'" + if ($preReleaseInfo -ne $null) + { + $script:ModuleVersion = "{0}-{1}" -f $exoModule.Version.ToString(),$preReleaseInfo[0].Split('=')[1].Trim().Trim("'") + } + + Write-Verbose "Computed version info: $script:ModuleVersion" + return $script:ModuleVersion + } + catch + { + return [string]::Empty + } + } + + <# + .Synopsis Validates a given Uri + #> + function Test-Uri + { + [CmdletBinding()] + [OutputType([bool])] + Param + ( + # Uri to be validated + [Parameter(Mandatory=$true, ValueFromPipelineByPropertyName=$true, Position=0)] + [string] + $UriString + ) + + [Uri]$uri = $UriString -as [Uri] + + $uri.AbsoluteUri -ne $null -and $uri.Scheme -eq 'https' + } + + <# + .Synopsis Is Cloud Shell Environment + #> + function global:IsCloudShellEnvironment() + { + return [Microsoft.Exchange.Management.AdminApiProvider.Utility]::IsCloudShellEnvironment(); + } + + <# + .Synopsis Override Get-PSImplicitRemotingSession function for reconnection + #> + function global:UpdateImplicitRemotingHandler() + { + # Remote Powershell Sessions created by the ExchangeOnlineManagement module are given a name that starts with "ExchangeOnlineInternalSession". + # Only modules from such sessions should be modified here, to prevent modfification of RPS tmp_* modules created by running the New-PSSession cmdlet directly, or when connecting to exchange on-prem tenants. + $existingPSSession = Get-PSSession | Where-Object {$_.ConfigurationName -like "Microsoft.Exchange" -and $_.Name -like "ExchangeOnlineInternalSession*"} + + if ($existingPSSession.count -gt 0) + { + foreach ($session in $existingPSSession) + { + $module = Get-Module $session.CurrentModuleName + if ($module -eq $null) + { + continue + } + + [bool]$moduleProcessed = $false + [string] $moduleUrl = $module.Description + [int] $queryStringIndex = $moduleUrl.IndexOf("?") + + if ($queryStringIndex -gt 0) + { + $moduleUrl = $moduleUrl.SubString(0,$queryStringIndex) + } + + if ($moduleUrl.EndsWith("/PowerShell-LiveId", [StringComparison]::OrdinalIgnoreCase) -or $moduleUrl.EndsWith("/PowerShell", [StringComparison]::OrdinalIgnoreCase)) + { + & $module { ${function:Get-PSImplicitRemotingSession} = ` + { + param( + [Parameter(Mandatory = $true, Position = 0)] + [string] + $commandName + ) + + $shouldRemoveCurrentSession = $false; + # Clear any left over PS tmp modules + if (($script:PSSession -ne $null) -and ($script:PSSession.PreviousModuleName -ne $null) -and ($script:PSSession.PreviousModuleName -ne $script:MyModule.Name)) + { + $null = Remove-Module -Name $script:PSSession.PreviousModuleName -ErrorAction SilentlyContinue + $script:PSSession.PreviousModuleName = $null + } + + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened')) + { + Set-PSImplicitRemotingSession ` + (& $script:GetPSSession ` + -InstanceId $script:PSSession.InstanceId.Guid ` + -ErrorAction SilentlyContinue ) + } + if ($script:PSSession -ne $null) + { + if ($script:PSSession.Runspace.RunspaceStateInfo.State -eq 'Disconnected') + { + # If we are handed a disconnected session, try re-connecting it before creating a new session. + Set-PSImplicitRemotingSession ` + (& $script:ConnectPSSession ` + -Session $script:PSSession ` + -ErrorAction SilentlyContinue) + } + else + { + # Import the module once more to ensure that Test-ActiveToken is present + Import-Module $global:_EXO_ModulePath -Cmdlet Test-ActiveToken; + + # If there is no active token run the new session flow + $hasActiveToken = Test-ActiveToken -TokenExpiryTime $script:PSSession.TokenExpiryTime + $sessionIsOpened = $script:PSSession.Runspace.RunspaceStateInfo.State -eq 'Opened' + if (($hasActiveToken -eq $false) -or ($sessionIsOpened -ne $true)) + { + #If there is no active user token or opened session then ensure that we remove the old session + $shouldRemoveCurrentSession = $true; + } + } + } + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened') -or ($shouldRemoveCurrentSession -eq $true)) + { + # Import the module once more to ensure that New-ExoPSSession is present + Import-Module $global:_EXO_ModulePath -Cmdlet New-ExoPSSession; + + Write-PSImplicitRemotingMessage ('Creating a new Remote PowerShell session using Modern Authentication for implicit remoting of "{0}" command ...' -f $commandName) + $session = New-ExoPSSession -PreviousSession $script:PSSession + + if ($session -ne $null) + { + if ($shouldRemoveCurrentSession -eq $true) + { + Remove-PSSession $script:PSSession + } + + # Import the latest session to ensure that the next cmdlet call would occur on the new PSSession instance. + $PSSessionModuleInfo = Import-PSSession $session -AllowClobber -DisableNameChecking -CommandName $script:MyModule.CommandName -FormatTypeName $script:MyModule.FormatTypeName + + # Add the name of the module to clean up in case of removing the broken session + $session | Add-Member -NotePropertyName "CurrentModuleName" -NotePropertyValue $PSSessionModuleInfo.Name + + $CurrentModule = Import-Module $PSSessionModuleInfo.Path -Global -DisableNameChecking -Prefix $script:MyModule.ModulePrefix -PassThru + $CurrentModule | Add-Member -NotePropertyName "ModulePrefix" -NotePropertyValue $script:MyModule.ModulePrefix + $CurrentModule | Add-Member -NotePropertyName "CommandName" -NotePropertyValue $script:MyModule.CommandName + $CurrentModule | Add-Member -NotePropertyName "FormatTypeName" -NotePropertyValue $script:MyModule.FormatTypeName + + $session | Add-Member -NotePropertyName "PreviousModuleName" -NotePropertyValue $script:MyModule.Name + + UpdateImplicitRemotingHandler + $script:PSSession = $session + } + } + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened')) + { + throw 'No session has been associated with this implicit remoting module' + } + + return [Management.Automation.Runspaces.PSSession]$script:PSSession + }} + } + } + } + } + + <# + .SYNOPSIS Extract organization name from UserPrincipalName + #> + function Get-OrgNameFromUPN + { + param([string] $UPN) + $fields = $UPN -split '@' + return $fields[-1] + } + + <# + .SYNOPSIS Get the command from the given module + #> + function global:Get-WrappedCommand + { + param( + [string] $CommandName, + [string] $ModuleName, + [string] $CommandType) + + $cmd = (Get-Module $moduleName).ExportedFunctions[$CommandName] + return $cmd + } + +############# Helper Functions End ############# + +###### Begin Main ###### + +$EOPConnectionInProgress = $false +function Connect-ExchangeOnline +{ + [CmdletBinding()] + param( + + # Connection Uri for the Remote PowerShell endpoint + [string] $ConnectionUri = '', + + # Azure AD Authorization endpoint Uri that can issue the OAuth2 access tokens + [string] $AzureADAuthorizationEndpointUri = '', + + # Exchange Environment name + [Microsoft.Exchange.Management.RestApiClient.ExchangeEnvironment] $ExchangeEnvironmentName = 'O365Default', + + # PowerShell session options to be used when opening the Remote PowerShell session + [System.Management.Automation.Remoting.PSSessionOption] $PSSessionOption = $null, + + # Switch to bypass use of mailbox anchoring hint. + [switch] $BypassMailboxAnchoring = $false, + + # Delegated Organization Name + [string] $DelegatedOrganization = '', + + # Prefix + [string] $Prefix = '', + + # Show Banner of Exchange cmdlets Mapping and recent updates + [switch] $ShowBanner = $true, + + #Cmdlets to Import for rps cmdlets , by default it would bring all + [string[]] $CommandName = @("*"), + + #The way the output objects would be printed on the console + [string[]] $FormatTypeName = @("*"), + + # Use Remote PowerShell Session based connection + [switch] $UseRPSSession = $false + ) + DynamicParam + { + if (($isCloudShell = IsCloudShellEnvironment) -eq $false) + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # User Principal Name or email address of the user + $UserPrincipalName = New-Object System.Management.Automation.RuntimeDefinedParameter('UserPrincipalName', [string], $attributeCollection) + $UserPrincipalName.Value = '' + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + # Certificate + $Certificate = New-Object System.Management.Automation.RuntimeDefinedParameter('Certificate', [System.Security.Cryptography.X509Certificates.X509Certificate2], $attributeCollection) + $Certificate.Value = $null + + # Certificate Path + $CertificateFilePath = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateFilePath', [string], $attributeCollection) + $CertificateFilePath.Value = '' + + # Certificate Password + $CertificatePassword = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificatePassword', [System.Security.SecureString], $attributeCollection) + $CertificatePassword.Value = $null + + # Certificate Thumbprint + $CertificateThumbprint = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateThumbprint', [string], $attributeCollection) + $CertificateThumbprint.Value = '' + + # Application Id + $AppId = New-Object System.Management.Automation.RuntimeDefinedParameter('AppId', [string], $attributeCollection) + $AppId.Value = '' + + # Organization + $Organization = New-Object System.Management.Automation.RuntimeDefinedParameter('Organization', [string], $attributeCollection) + $Organization.Value = '' + + # Switch to collect telemetry on command execution. + $EnableErrorReporting = New-Object System.Management.Automation.RuntimeDefinedParameter('EnableErrorReporting', [switch], $attributeCollection) + $EnableErrorReporting.Value = $false + + # Where to store EXO command telemetry data. By default telemetry is stored in the directory "%TEMP%/EXOTelemetry" in the file : EXOCmdletTelemetry-yyyymmdd-hhmmss.csv. + $LogDirectoryPath = New-Object System.Management.Automation.RuntimeDefinedParameter('LogDirectoryPath', [string], $attributeCollection) + $LogDirectoryPath.Value = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), "EXOCmdletTelemetry") + + # Create a new attribute and valiate set against the LogLevel + $LogLevelAttribute = New-Object System.Management.Automation.ParameterAttribute + $LogLevelAttribute.Mandatory = $false + $LogLevelAttributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $LogLevelAttributeCollection.Add($LogLevelAttribute) + $LogLevelList = @([Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::Default, [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::All) + $ValidateSet = New-Object System.Management.Automation.ValidateSetAttribute($LogLevelList) + $LogLevel = New-Object System.Management.Automation.RuntimeDefinedParameter('LogLevel', [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel], $LogLevelAttributeCollection) + $LogLevel.Attributes.Add($ValidateSet) + +# EXO params start + + # Switch to track perfomance + $TrackPerformance = New-Object System.Management.Automation.RuntimeDefinedParameter('TrackPerformance', [bool], $attributeCollection) + $TrackPerformance.Value = $false + + # Flag to enable or disable showing the number of objects written + $ShowProgress = New-Object System.Management.Automation.RuntimeDefinedParameter('ShowProgress', [bool], $attributeCollection) + $ShowProgress.Value = $false + + # Switch to enable/disable Multi-threading in the EXO cmdlets + $UseMultithreading = New-Object System.Management.Automation.RuntimeDefinedParameter('UseMultithreading', [bool], $attributeCollection) + $UseMultithreading.Value = $true + + # Pagesize Param + $PageSize = New-Object System.Management.Automation.RuntimeDefinedParameter('PageSize', [uint32], $attributeCollection) + $PageSize.Value = 1000 + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + # Switch to CmdInline parameters + $InlineCredential = New-Object System.Management.Automation.RuntimeDefinedParameter('InlineCredential', [switch], $attributeCollection) + $InlineCredential.Value = $false + +# EXO params end + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('UserPrincipalName', $UserPrincipalName) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('Certificate', $Certificate) + $paramDictionary.Add('CertificateFilePath', $CertificateFilePath) + $paramDictionary.Add('CertificatePassword', $CertificatePassword) + $paramDictionary.Add('AppId', $AppId) + $paramDictionary.Add('Organization', $Organization) + $paramDictionary.Add('EnableErrorReporting', $EnableErrorReporting) + $paramDictionary.Add('LogDirectoryPath', $LogDirectoryPath) + $paramDictionary.Add('LogLevel', $LogLevel) + $paramDictionary.Add('TrackPerformance', $TrackPerformance) + $paramDictionary.Add('ShowProgress', $ShowProgress) + $paramDictionary.Add('UseMultithreading', $UseMultithreading) + $paramDictionary.Add('PageSize', $PageSize) + if($PSEdition -eq 'Core') + { + $paramDictionary.Add('Device', $Device) + $paramDictionary.Add('InlineCredential', $InlineCredential); + # We do not want to expose certificate thumprint in Linux as it is not feasible there. + if($IsWindows) + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + } + else + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + + return $paramDictionary + } + else + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + # Switch to collect telemetry on command execution. + $EnableErrorReporting = New-Object System.Management.Automation.RuntimeDefinedParameter('EnableErrorReporting', [switch], $attributeCollection) + $EnableErrorReporting.Value = $false + + # Where to store EXO command telemetry data. By default telemetry is stored in the directory "%TEMP%/EXOTelemetry" in the file : EXOCmdletTelemetry-yyyymmdd-hhmmss.csv. + $LogDirectoryPath = New-Object System.Management.Automation.RuntimeDefinedParameter('LogDirectoryPath', [string], $attributeCollection) + $LogDirectoryPath.Value = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), "EXOCmdletTelemetry") + + # Create a new attribute and valiate set against the LogLevel + $LogLevelAttribute = New-Object System.Management.Automation.ParameterAttribute + $LogLevelAttribute.Mandatory = $false + $LogLevelAttributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $LogLevelAttributeCollection.Add($LogLevelAttribute) + $LogLevelList = @([Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::Default, [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::All) + $ValidateSet = New-Object System.Management.Automation.ValidateSetAttribute($LogLevelList) + $LogLevel = New-Object System.Management.Automation.RuntimeDefinedParameter('LogLevel', [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel], $LogLevelAttributeCollection) + $LogLevel.Attributes.Add($ValidateSet) + + # Switch to CmdInline parameters + $InlineCredential = New-Object System.Management.Automation.RuntimeDefinedParameter('InlineCredential', [switch], $attributeCollection) + $InlineCredential.Value = $false + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('Device', $Device) + $paramDictionary.Add('EnableErrorReporting', $EnableErrorReporting) + $paramDictionary.Add('LogDirectoryPath', $LogDirectoryPath) + $paramDictionary.Add('LogLevel', $LogLevel) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('InlineCredential', $InlineCredential) + return $paramDictionary + } + } + process { + + # Validate parameters + if (($ConnectionUri -ne '') -and (-not (Test-Uri $ConnectionUri))) + { + throw "Invalid ConnectionUri parameter '$ConnectionUri'" + } + if (($AzureADAuthorizationEndpointUri -ne '') -and (-not (Test-Uri $AzureADAuthorizationEndpointUri))) + { + throw "Invalid AzureADAuthorizationEndpointUri parameter '$AzureADAuthorizationEndpointUri'" + } + if (($Prefix -ne '')) + { + if ($Prefix -notmatch '^[a-z0-9]+$') + { + throw "Use of any special characters in the Prefix string is not supported." + } + if ($Prefix -eq 'EXO') + { + throw "Prefix 'EXO' is a reserved Prefix, please use a different prefix." + } + } + + # Keep track of error count at beginning. + $errorCountAtStart = $global:Error.Count; + try + { + $moduleVersion = Get-ModuleVersion + + Write-Verbose "ExchangeEnvironment : $ExchangeEnvironmentName" + Write-Verbose "ConnectionUri : $ConnectionUri" + Write-Verbose "AzureADAuthorizationEndpointUri : $AzureADAuthorizationEndpointUri" + Write-Verbose "DelegatedOrganization : $DelegatedOrganization" + Write-Verbose "Prefix : $Prefix" + Write-Verbose ("FormatTypeName :" + [String]::Join(' ,', $FormatTypeName)) + Write-Verbose ("CommandName :" + [String]::Join(' ,', $CommandName)) + Write-Verbose "ModuleVersion: $moduleVersion" + + if ($isCloudShell -eq $false) + { + $ConnectionContext = Get-ConnectionContext -ExchangeEnvironmentName $ExchangeEnvironmentName -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -UserPrincipalName $UserPrincipalName.Value -PSSessionOption $PSSessionOption -Credential $Credential.Value -BypassMailboxAnchoring:$BypassMailboxAnchoring -DelegatedOrg $DelegatedOrganization -Certificate $Certificate.Value -CertificateFilePath $CertificateFilePath.Value -CertificatePassword $CertificatePassword.Value -CertificateThumbprint $CertificateThumbprint.Value -AppId $AppId.Value -Organization $Organization.Value -Device:$Device.Value -InlineCredential:$InlineCredential.Value -CommandName $CommandName -FormatTypeName $FormatTypeName -Prefix $Prefix -PageSize $PageSize.Value -ExoModuleVersion:$moduleVersion + } + else + { + $ConnectionContext = Get-ConnectionContext -ExchangeEnvironmentName $ExchangeEnvironmentName -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -Credential $Credential.Value -PSSessionOption $PSSessionOption -BypassMailboxAnchoring:$BypassMailboxAnchoring -Device:$Device.Value -InlineCredential:$InlineCredential.Value -DelegatedOrg $DelegatedOrganization -CommandName $CommandName -FormatTypeName $FormatTypeName -Prefix $prefix -ExoModuleVersion:$moduleVersion + } + + if ($isCloudShell -eq $false) + { + $global:_EXO_EnableErrorReporting = $EnableErrorReporting.Value; + } + + if ($ShowBanner -eq $true) + { + try + { + $BannerContent = Get-EXOBanner -ConnectionContext:$ConnectionContext -IsRPSSession:$UseRPSSession.IsPresent + Write-Host -ForegroundColor Yellow $BannerContent + } + catch + { + Write-Verbose "Failed to fetch banner content from server, using the default banner content. Reason: $_" + Print-Details; + } + } + + if (($ConnectionUri -ne '') -and ($AzureADAuthorizationEndpointUri -eq '')) + { + Write-Information "Using ConnectionUri:'$ConnectionUri', in the environment:'$ExchangeEnvironmentName'." + } + if (($AzureADAuthorizationEndpointUri -ne '') -and ($ConnectionUri -eq '')) + { + Write-Information "Using AzureADAuthorizationEndpointUri:'$AzureADAuthorizationEndpointUri', in the environment:'$ExchangeEnvironmentName'." + } + + $ImportedModuleName = ''; + $LogModuleDirectoryPath = [System.IO.Path]::GetTempPath(); + + if ($UseRPSSession -eq $true) + { + $ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll"; + $ModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule); + + Import-Module $ModulePath; + + $global:_EXO_ModulePath = $ModulePath; + + $PSSession = New-ExoPSSession -ConnectionContext $ConnectionContext + + if ($PSSession -ne $null) + { + $PSSessionModuleInfo = Import-PSSession $PSSession -AllowClobber -DisableNameChecking -CommandName $CommandName -FormatTypeName $FormatTypeName + + # Add the name of the module to clean up in case of removing the broken session + $PSSession | Add-Member -NotePropertyName "CurrentModuleName" -NotePropertyValue $PSSessionModuleInfo.Name + + # Import the above module globally. This is needed as with using psm1 files, + # any module which is dynamically loaded in the nested module does not reflect globally. + $CurrentModule = Import-Module $PSSessionModuleInfo.Path -Global -DisableNameChecking -Prefix $Prefix -PassThru + $CurrentModule | Add-Member -NotePropertyName "ModulePrefix" -NotePropertyValue $Prefix + $CurrentModule | Add-Member -NotePropertyName "CommandName" -NotePropertyValue $CommandName + $CurrentModule | Add-Member -NotePropertyName "FormatTypeName" -NotePropertyValue $FormatTypeName + + UpdateImplicitRemotingHandler + + # Import the REST module + $RestPowershellModule = "Microsoft.Exchange.Management.RestApiClient.dll"; + $RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestPowershellModule); + Import-Module $RestModulePath -Cmdlet Set-ExoAppSettings; + + $ImportedModuleName = $PSSessionModuleInfo.Name; + } + } + else + { + # Download the new web based EXOModule + $ImportedModule = New-EXOModule -ConnectionContext $ConnectionContext; + if ($null -ne $ImportedModule) + { + $ImportedModuleName = $ImportedModule.Name; + $LogModuleDirectoryPath = $ImportedModule.ModuleBase + + Write-Verbose "AutoGen EXOModule created at $($ImportedModule.ModuleBase)" + if ($null -ne $HelpFileNames -and $HelpFileNames -is [array] -and $HelpFileNames.Count -gt 0) + { + Get-HelpFiles -HelpFileNames $HelpFileNames -ConnectionContext $ConnectionContext -ImportedModule $ImportedModule -EnableErrorReporting:$EnableErrorReporting.Value + } + else + { + Write-Warning "Get-help cmdlet might not work. Please reconnect if you want to access that functionality." + } + } + else + { + throw "Module could not be correctly formed. Please run Connect-ExchangeOnline again." + } + } + + # If we are configured to collect telemetry, add telemetry wrappers. + if ($EnableErrorReporting.Value -eq $true) + { + $FilePath = Add-EXOClientTelemetryWrapper -Organization (Get-OrgNameFromUPN -UPN $UserPrincipalName.Value) -PSSessionModuleName $ImportedModuleName -LogDirectoryPath $LogDirectoryPath.Value -LogModuleDirectoryPath $LogModuleDirectoryPath + $global:_EXO_TelemetryFilePath = $FilePath[0] + Import-Module $FilePath[1] -DisableNameChecking -Global + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Connect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid + + if ($EOPConnectionInProgress -eq $false) + { + # Set the AppSettings + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -EnableErrorReporting $true -LogDirectoryPath $LogDirectoryPath.Value -LogLevel $LogLevel.Value + } + } + else + { + if ($EOPConnectionInProgress -eq $false) + { + # Set the AppSettings disabling the logging + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -EnableErrorReporting $false + } + } + } + catch + { + # If telemetry is enabled, log errors generated from this cmdlet also. + if ($EnableErrorReporting.Value -eq $true) + { + $errorCountAtProcessEnd = $global:Error.Count + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath -LogDirectoryPath $LogDirectoryPath.Value + + # Import the REST module + $RestPowershellModule = "Microsoft.Exchange.Management.RestApiClient.dll"; + $RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestPowershellModule); + Import-Module $RestModulePath -Cmdlet Set-ExoAppSettings; + + # Set the AppSettings + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -ConnectionUri $ConnectionUri -EnableErrorReporting $true -LogDirectoryPath $LogDirectoryPath.Value -LogLevel $LogLevel.Value + } + + # Log errors which are encountered during Connect-ExchangeOnline execution. + Write-Warning("Writing Connect-ExchangeOnline error log to " + $global:_EXO_TelemetryFilePath) + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Connect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid -ErrorObject $global:Error -ErrorRecordsToConsider ($errorCountAtProcessEnd - $errorCountAtStart) + } + throw $_ + } + } +} + +function Connect-IPPSSession +{ + [CmdletBinding()] + param( + # Connection Uri for the Remote PowerShell endpoint + [string] $ConnectionUri = 'https://ps.compliance.protection.outlook.com/PowerShell-LiveId', + + # Azure AD Authorization endpoint Uri that can issue the OAuth2 access tokens + [string] $AzureADAuthorizationEndpointUri = 'https://login.microsoftonline.com/organizations', + + # Delegated Organization Name + [string] $DelegatedOrganization = '', + + # PowerShell session options to be used when opening the Remote PowerShell session + [System.Management.Automation.Remoting.PSSessionOption] $PSSessionOption = $null, + + # Switch to bypass use of mailbox anchoring hint. + [switch] $BypassMailboxAnchoring = $false, + + # Prefix + [string] $Prefix = '', + + #Cmdlets to Import, by default it would bring all + [string[]] $CommandName = @("*"), + + #The way the output objects would be printed on the console + [string[]] $FormatTypeName = @("*") + ) + DynamicParam + { + if (($isCloudShell = IsCloudShellEnvironment) -eq $false) + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # User Principal Name or email address of the user + $UserPrincipalName = New-Object System.Management.Automation.RuntimeDefinedParameter('UserPrincipalName', [string], $attributeCollection) + $UserPrincipalName.Value = '' + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + # Certificate + $Certificate = New-Object System.Management.Automation.RuntimeDefinedParameter('Certificate', [System.Security.Cryptography.X509Certificates.X509Certificate2], $attributeCollection) + $Certificate.Value = $null + + # Certificate Path + $CertificateFilePath = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateFilePath', [string], $attributeCollection) + $CertificateFilePath.Value = '' + + # Certificate Password + $CertificatePassword = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificatePassword', [System.Security.SecureString], $attributeCollection) + $CertificatePassword.Value = $null + + # Certificate Thumbprint + $CertificateThumbprint = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateThumbprint', [string], $attributeCollection) + $CertificateThumbprint.Value = '' + + # Application Id + $AppId = New-Object System.Management.Automation.RuntimeDefinedParameter('AppId', [string], $attributeCollection) + $AppId.Value = '' + + # Organization + $Organization = New-Object System.Management.Automation.RuntimeDefinedParameter('Organization', [string], $attributeCollection) + $Organization.Value = '' + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('UserPrincipalName', $UserPrincipalName) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('Certificate', $Certificate) + $paramDictionary.Add('CertificateFilePath', $CertificateFilePath) + $paramDictionary.Add('CertificatePassword', $CertificatePassword) + $paramDictionary.Add('AppId', $AppId) + $paramDictionary.Add('Organization', $Organization) + if($PSEdition -eq 'Core') + { + # We do not want to expose certificate thumprint in Linux as it is not feasible there. + if($IsWindows) + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + } + else + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + + return $paramDictionary + } + else + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('Device', $Device) + return $paramDictionary + } + } + process + { + try + { + $EOPConnectionInProgress = $true + if ($isCloudShell -eq $false) + { + Connect-ExchangeOnline -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -UserPrincipalName $UserPrincipalName.Value -PSSessionOption $PSSessionOption -Credential $Credential.Value -BypassMailboxAnchoring:$BypassMailboxAnchoring -ShowBanner:$false -DelegatedOrganization $DelegatedOrganization -Certificate $Certificate.Value -CertificateFilePath $CertificateFilePath.Value -CertificatePassword $CertificatePassword.Value -CertificateThumbprint $CertificateThumbprint.Value -AppId $AppId.Value -Organization $Organization.Value -Prefix $Prefix -CommandName $CommandName -FormatTypeName $FormatTypeName -UseRPSSession:$true + } + else + { + Connect-ExchangeOnline -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -PSSessionOption $PSSessionOption -BypassMailboxAnchoring:$BypassMailboxAnchoring -Device:$Device.Value -ShowBanner:$false -DelegatedOrganization $DelegatedOrganization -Prefix $Prefix -CommandName $CommandName -FormatTypeName $FormatTypeName -UseRPSSession:$true + } + } + finally + { + $EOPConnectionInProgress = $false + } + } +} + +function Disconnect-ExchangeOnline +{ + [CmdletBinding(SupportsShouldProcess, ConfirmImpact='High')] + param() + + process + { + if ($PSCmdlet.ShouldProcess( + "Running this cmdlet clears all active sessions created using Connect-ExchangeOnline or Connect-IPPSSession.", + "Press(Y/y/A/a) if you want to continue.", + "Running this cmdlet clears all active sessions created using Connect-ExchangeOnline or Connect-IPPSSession. ")) + { + + # Keep track of error count at beginning. + $errorCountAtStart = $global:Error.Count; + + try + { + # Import the module once more to ensure that Test-ActiveToken is present + $ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll"; + $ModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule); + Import-Module $ModulePath -Cmdlet Clear-ActiveToken; + + $existingPSSession = Get-PSSession | Where-Object {$_.ConfigurationName -like "Microsoft.Exchange" -and $_.Name -like "ExchangeOnlineInternalSession*"} + + if ($existingPSSession.count -gt 0) + { + for ($index = 0; $index -lt $existingPSSession.count; $index++) + { + $session = $existingPSSession[$index] + Remove-PSSession -session $session + + Write-Information "Removed the PSSession $($session.Name) connected to $($session.ComputerName)" + + # Remove any active access token from the cache + Clear-ActiveToken -TokenProvider $session.TokenProvider + + # Remove any previous modules loaded because of the current PSSession + if ($session.PreviousModuleName -ne $null) + { + if ((Get-Module $session.PreviousModuleName).Count -ne 0) + { + $null = Remove-Module -Name $session.PreviousModuleName -ErrorAction SilentlyContinue + } + + $session.PreviousModuleName = $null + } + + # Remove any leaked module in case of removal of broken session object + if ($session.CurrentModuleName -ne $null) + { + if ((Get-Module $session.CurrentModuleName).Count -ne 0) + { + $null = Remove-Module -Name $session.CurrentModuleName -ErrorAction SilentlyContinue + } + } + } + } + + # Clear all the active tokens in ConnectionContext + [Microsoft.Exchange.Management.ExoPowershellSnapin.ConnectionContextFactory]::RemoveAllTokensFromConnectionContext() + + # Remove all the AutoREST modules from this instance of powershell if created + $existingAutoRESTModules = Get-Module "tmpEXO_*" + foreach ($module in $existingAutoRESTModules) + { + $null = Remove-Module -Name $module -ErrorAction SilentlyContinue + } + + Write-Information "Disconnected successfully !" + + if ($global:_EXO_EnableErrorReporting -eq $true) + { + # Remove all the Wrapped modules from this instance of powershell if created + $existingWrappedModules = Get-Module "EXOCmdletWrapper-*" + foreach ($module in $existingWrappedModules) + { + $null = Remove-Module -Name $module -ErrorAction SilentlyContinue + } + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath + } + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Disconnect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid + } + } + catch + { + # If telemetry is enabled, log errors generated from this cmdlet also. + if ($global:_EXO_EnableErrorReporting -eq $true) + { + $errorCountAtProcessEnd = $global:Error.Count + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath + } + + # Log errors which are encountered during Disconnect-ExchangeOnline execution. + Write-Warning("Writing Disconnect-ExchangeOnline errors to " + $global:_EXO_TelemetryFilePath) + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Disconnect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid -ErrorObject $global:Error -ErrorRecordsToConsider ($errorCountAtProcessEnd - $errorCountAtStart) + } + + throw $_ + } + } + } +} + +# SIG # Begin signature block +# MIInnQYJKoZIhvcNAQcCoIInjjCCJ4oCAQExDzANBglghkgBZQMEAgEFADB5Bgor +# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG +# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCAk8bWd5n6Z+FmL +# OYNO5yQEAw68XUDDa/dIT4+yqen8YKCCDYEwggX/MIID56ADAgECAhMzAAACUosz +# qviV8znbAAAAAAJSMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD +# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy +# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p +# bmcgUENBIDIwMTEwHhcNMjEwOTAyMTgzMjU5WhcNMjIwOTAxMTgzMjU5WjB0MQsw +# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u +# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy +# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +# AQDQ5M+Ps/X7BNuv5B/0I6uoDwj0NJOo1KrVQqO7ggRXccklyTrWL4xMShjIou2I +# sbYnF67wXzVAq5Om4oe+LfzSDOzjcb6ms00gBo0OQaqwQ1BijyJ7NvDf80I1fW9O +# L76Kt0Wpc2zrGhzcHdb7upPrvxvSNNUvxK3sgw7YTt31410vpEp8yfBEl/hd8ZzA +# v47DCgJ5j1zm295s1RVZHNp6MoiQFVOECm4AwK2l28i+YER1JO4IplTH44uvzX9o +# RnJHaMvWzZEpozPy4jNO2DDqbcNs4zh7AWMhE1PWFVA+CHI/En5nASvCvLmuR/t8 +# q4bc8XR8QIZJQSp+2U6m2ldNAgMBAAGjggF+MIIBejAfBgNVHSUEGDAWBgorBgEE +# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQUNZJaEUGL2Guwt7ZOAu4efEYXedEw +# UAYDVR0RBEkwR6RFMEMxKTAnBgNVBAsTIE1pY3Jvc29mdCBPcGVyYXRpb25zIFB1 +# ZXJ0byBSaWNvMRYwFAYDVQQFEw0yMzAwMTIrNDY3NTk3MB8GA1UdIwQYMBaAFEhu +# ZOVQBdOCqhc3NyK1bajKdQKVMFQGA1UdHwRNMEswSaBHoEWGQ2h0dHA6Ly93d3cu +# bWljcm9zb2Z0LmNvbS9wa2lvcHMvY3JsL01pY0NvZFNpZ1BDQTIwMTFfMjAxMS0w +# Ny0wOC5jcmwwYQYIKwYBBQUHAQEEVTBTMFEGCCsGAQUFBzAChkVodHRwOi8vd3d3 +# Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2NlcnRzL01pY0NvZFNpZ1BDQTIwMTFfMjAx +# MS0wNy0wOC5jcnQwDAYDVR0TAQH/BAIwADANBgkqhkiG9w0BAQsFAAOCAgEAFkk3 +# uSxkTEBh1NtAl7BivIEsAWdgX1qZ+EdZMYbQKasY6IhSLXRMxF1B3OKdR9K/kccp +# kvNcGl8D7YyYS4mhCUMBR+VLrg3f8PUj38A9V5aiY2/Jok7WZFOAmjPRNNGnyeg7 +# l0lTiThFqE+2aOs6+heegqAdelGgNJKRHLWRuhGKuLIw5lkgx9Ky+QvZrn/Ddi8u +# TIgWKp+MGG8xY6PBvvjgt9jQShlnPrZ3UY8Bvwy6rynhXBaV0V0TTL0gEx7eh/K1 +# o8Miaru6s/7FyqOLeUS4vTHh9TgBL5DtxCYurXbSBVtL1Fj44+Od/6cmC9mmvrti +# yG709Y3Rd3YdJj2f3GJq7Y7KdWq0QYhatKhBeg4fxjhg0yut2g6aM1mxjNPrE48z +# 6HWCNGu9gMK5ZudldRw4a45Z06Aoktof0CqOyTErvq0YjoE4Xpa0+87T/PVUXNqf +# 7Y+qSU7+9LtLQuMYR4w3cSPjuNusvLf9gBnch5RqM7kaDtYWDgLyB42EfsxeMqwK +# WwA+TVi0HrWRqfSx2olbE56hJcEkMjOSKz3sRuupFCX3UroyYf52L+2iVTrda8XW +# esPG62Mnn3T8AuLfzeJFuAbfOSERx7IFZO92UPoXE1uEjL5skl1yTZB3MubgOA4F +# 8KoRNhviFAEST+nG8c8uIsbZeb08SeYQMqjVEmkwggd6MIIFYqADAgECAgphDpDS +# AAAAAAADMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMK +# V2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0 +# IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0 +# ZSBBdXRob3JpdHkgMjAxMTAeFw0xMTA3MDgyMDU5MDlaFw0yNjA3MDgyMTA5MDla +# MH4xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdS +# ZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMT +# H01pY3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTEwggIiMA0GCSqGSIb3DQEB +# AQUAA4ICDwAwggIKAoICAQCr8PpyEBwurdhuqoIQTTS68rZYIZ9CGypr6VpQqrgG +# OBoESbp/wwwe3TdrxhLYC/A4wpkGsMg51QEUMULTiQ15ZId+lGAkbK+eSZzpaF7S +# 35tTsgosw6/ZqSuuegmv15ZZymAaBelmdugyUiYSL+erCFDPs0S3XdjELgN1q2jz +# y23zOlyhFvRGuuA4ZKxuZDV4pqBjDy3TQJP4494HDdVceaVJKecNvqATd76UPe/7 +# 4ytaEB9NViiienLgEjq3SV7Y7e1DkYPZe7J7hhvZPrGMXeiJT4Qa8qEvWeSQOy2u +# M1jFtz7+MtOzAz2xsq+SOH7SnYAs9U5WkSE1JcM5bmR/U7qcD60ZI4TL9LoDho33 +# X/DQUr+MlIe8wCF0JV8YKLbMJyg4JZg5SjbPfLGSrhwjp6lm7GEfauEoSZ1fiOIl +# XdMhSz5SxLVXPyQD8NF6Wy/VI+NwXQ9RRnez+ADhvKwCgl/bwBWzvRvUVUvnOaEP +# 6SNJvBi4RHxF5MHDcnrgcuck379GmcXvwhxX24ON7E1JMKerjt/sW5+v/N2wZuLB +# l4F77dbtS+dJKacTKKanfWeA5opieF+yL4TXV5xcv3coKPHtbcMojyyPQDdPweGF +# RInECUzF1KVDL3SV9274eCBYLBNdYJWaPk8zhNqwiBfenk70lrC8RqBsmNLg1oiM +# CwIDAQABo4IB7TCCAekwEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFEhuZOVQ +# BdOCqhc3NyK1bajKdQKVMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1Ud +# DwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFHItOgIxkEO5FAVO +# 4eqnxzHRI4k0MFoGA1UdHwRTMFEwT6BNoEuGSWh0dHA6Ly9jcmwubWljcm9zb2Z0 +# LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y +# Mi5jcmwwXgYIKwYBBQUHAQEEUjBQME4GCCsGAQUFBzAChkJodHRwOi8vd3d3Lm1p +# Y3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y +# Mi5jcnQwgZ8GA1UdIASBlzCBlDCBkQYJKwYBBAGCNy4DMIGDMD8GCCsGAQUFBwIB +# FjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2RvY3MvcHJpbWFyeWNw +# cy5odG0wQAYIKwYBBQUHAgIwNB4yIB0ATABlAGcAYQBsAF8AcABvAGwAaQBjAHkA +# XwBzAHQAYQB0AGUAbQBlAG4AdAAuIB0wDQYJKoZIhvcNAQELBQADggIBAGfyhqWY +# 4FR5Gi7T2HRnIpsLlhHhY5KZQpZ90nkMkMFlXy4sPvjDctFtg/6+P+gKyju/R6mj +# 82nbY78iNaWXXWWEkH2LRlBV2AySfNIaSxzzPEKLUtCw/WvjPgcuKZvmPRul1LUd +# d5Q54ulkyUQ9eHoj8xN9ppB0g430yyYCRirCihC7pKkFDJvtaPpoLpWgKj8qa1hJ +# Yx8JaW5amJbkg/TAj/NGK978O9C9Ne9uJa7lryft0N3zDq+ZKJeYTQ49C/IIidYf +# wzIY4vDFLc5bnrRJOQrGCsLGra7lstnbFYhRRVg4MnEnGn+x9Cf43iw6IGmYslmJ +# aG5vp7d0w0AFBqYBKig+gj8TTWYLwLNN9eGPfxxvFX1Fp3blQCplo8NdUmKGwx1j +# NpeG39rz+PIWoZon4c2ll9DuXWNB41sHnIc+BncG0QaxdR8UvmFhtfDcxhsEvt9B +# xw4o7t5lL+yX9qFcltgA1qFGvVnzl6UJS0gQmYAf0AApxbGbpT9Fdx41xtKiop96 +# eiL6SJUfq/tHI4D1nvi/a7dLl+LrdXga7Oo3mXkYS//WsyNodeav+vyL6wuA6mk7 +# r/ww7QRMjt/fdW1jkT3RnVZOT7+AVyKheBEyIXrvQQqxP/uozKRdwaGIm1dxVk5I +# RcBCyZt2WwqASGv9eZ/BvW1taslScxMNelDNMYIZcjCCGW4CAQEwgZUwfjELMAkG +# A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQx +# HjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEoMCYGA1UEAxMfTWljcm9z +# b2Z0IENvZGUgU2lnbmluZyBQQ0EgMjAxMQITMwAAAlKLM6r4lfM52wAAAAACUjAN +# BglghkgBZQMEAgEFAKCBrjAZBgkqhkiG9w0BCQMxDAYKKwYBBAGCNwIBBDAcBgor +# BgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAvBgkqhkiG9w0BCQQxIgQgIhS3qoj1 +# UQcFwoqS3bsiKNlyzzwg84Jm8Gpt7FTE9REwQgYKKwYBBAGCNwIBDDE0MDKgFIAS +# AE0AaQBjAHIAbwBzAG8AZgB0oRqAGGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbTAN +# BgkqhkiG9w0BAQEFAASCAQAU2vbLS+IWCVvqWI8EdVkebP3f5WVbf6e2V2+jyA6R +# 8nmbHgS40FcyymsrI+vf1ru5gjMEfrAwY0VDsbWL//5bUuTKtgYGRTqmeCG33RO+ +# 9z/FoSCupd+n4Amfi/GVAiPAmg/Os4OBE8+V9Xld2B7og6/t/hi2osZrjHhUkKqc +# q2WS7lxnGNBTCmPJkNDTgIl4VXzgIBEfWNArUCb/V9NjGNPJ6qGezi0Q7OkXXMrC +# iGu0DwWnBwfcARE/oeU1T30DUU6La0t9bi1/cURAdVHRYufWWhIECnRuBD7pfjd/ +# Z6xY105pPZmIgi+f42tT7F1xVtUbMCaRxFcFE0Iqw+UOoYIW/DCCFvgGCisGAQQB +# gjcDAwExghboMIIW5AYJKoZIhvcNAQcCoIIW1TCCFtECAQMxDzANBglghkgBZQME +# AgEFADCCAVAGCyqGSIb3DQEJEAEEoIIBPwSCATswggE3AgEBBgorBgEEAYRZCgMB +# MDEwDQYJYIZIAWUDBAIBBQAEIBekHP5CnvvhbhNDrCF6H3oOJBPqZ9HDh40mWOYQ +# b45PAgZiFmzrUPEYEjIwMjIwMzEyMDMyMTUwLjgyWjAEgAIB9KCB0KSBzTCByjEL +# MAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1v +# bmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjElMCMGA1UECxMcTWlj +# cm9zb2Z0IEFtZXJpY2EgT3BlcmF0aW9uczEmMCQGA1UECxMdVGhhbGVzIFRTUyBF +# U046M0U3QS1FMzU5LUEyNUQxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1w +# IFNlcnZpY2WgghFUMIIHDDCCBPSgAwIBAgITMwAAAaDpu4y7DqLRegABAAABoDAN +# BgkqhkiG9w0BAQsFADB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3Rv +# bjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0 +# aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDAeFw0y +# MTEyMDIxOTA1MjNaFw0yMzAyMjgxOTA1MjNaMIHKMQswCQYDVQQGEwJVUzETMBEG +# A1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWlj +# cm9zb2Z0IENvcnBvcmF0aW9uMSUwIwYDVQQLExxNaWNyb3NvZnQgQW1lcmljYSBP +# cGVyYXRpb25zMSYwJAYDVQQLEx1UaGFsZXMgVFNTIEVTTjozRTdBLUUzNTktQTI1 +# RDElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2VydmljZTCCAiIwDQYJ +# KoZIhvcNAQEBBQADggIPADCCAgoCggIBAL/a4g5ocZ0A6PZi+GEjoLyIUCrvCuX/ +# lak+OPR8QcKLoi/H8jTYmyz8dWGR8ZMwa21HmNGGGslfJ1YOc6bNFTcHgbnblPun +# CQU0UFe6Yz/3yXmTRTZeJpn5u6Vcd7njHq6P/q/lUYW/7QeHV3KMZRM9pETBLvH3 +# xN7m0UcSKY9r4CwbaYz6f03B9BGN3UuIQJtwJkWSDBuWJD9qSIyvW1maOQNvG27Z +# pBxeMR8Odrwkf7BmZ927RfuTp0nlYZEXDNmIs4lbhCEASl6HZzWaZu0B8GeFI834 +# TnJQt+l9NPbBfxFsfpd8CDqxnHzz3rGrT6BQP2YfLxm2l0R4TVkDQeAHINbaskJt +# MAkCG3vUHtHPak9CaDlHf69IKuLwF5xIH5nybBgve45LdHpt5QEnuITis9L1YLXD +# V9lHsrjhlKZ7Z0j473+eGBvcwtiCbrPHceG0ugaEZU8v5agOQye33cgag7qQ0EIz +# Zf4KzbaqXa0+OQhHLHDEXpGxeH9AeeEomAHN8757zgjdNhsjSLb3MBMvrIc6/mwS +# zXNo0yKHbsjB9aDhDv7jQvt7ry4LrIPwRQSloPazZPn02FJq5PMIScCnlitKxxz0 +# xBUiLuD7kYB0LykK/7SJFrtAi9qVT72VaCTIAFT+eIUdY+PIagHjHcrOje1cHpoL +# fJn91NFekmdpAgMBAAGjggE2MIIBMjAdBgNVHQ4EFgQUcrkuUNgpTpG4kWwUL0TP +# C2GM0OgwHwYDVR0jBBgwFoAUn6cVXQBeYl2D9OXSZacbUzUZ6XIwXwYDVR0fBFgw +# VjBUoFKgUIZOaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jcmwvTWlj +# cm9zb2Z0JTIwVGltZS1TdGFtcCUyMFBDQSUyMDIwMTAoMSkuY3JsMGwGCCsGAQUF +# BwEBBGAwXjBcBggrBgEFBQcwAoZQaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3Br +# aW9wcy9jZXJ0cy9NaWNyb3NvZnQlMjBUaW1lLVN0YW1wJTIwUENBJTIwMjAxMCgx +# KS5jcnQwDAYDVR0TAQH/BAIwADATBgNVHSUEDDAKBggrBgEFBQcDCDANBgkqhkiG +# 9w0BAQsFAAOCAgEAMX3GAqv436yUCaVtwSpAGWkvk98EypwuRLrJJ4YmMb4spfda +# i/mnKCuEp+1dn3Q1hZR+0hmnN1izh6FHlGVoTd5i5taVw2XCwqRysZIMkprBtsMZ +# +87iH/UvXeyDrqE+JvruYb3oICpFUXRzkwDXCIqOOX/mB+tt00seC1ERDzMKlsrj +# 7rqXUV3S6n2bFw4QSmGEmvxTfCHAXCgr5An+TFaiAa18OJqrpHKgVaE/y4pItUNX +# 4xMRMdlvenY7CcFYTVbrTvVcMp3FGQ3+kARnXkTUsk2/2JijWXU/9F0X4jOkwsYM +# B/8+VW9NTDdWsf25qptiv6tHG2L5szdpvXC/2/fFEtz7A+ieJLFbanr0M3haj3og +# MVkiQtH4dxYKKodXAVeeCQJR90x7fGa84hdhGRMrQ/rA8t8L46zuh5VF4yPZMDVA +# wySBn6uE87TuJbs3nvMAG8yIclB0dEx4rcUGBHh9oS9ONQB0pFCQoVXza4TvDRQy +# ex4l9fsQsNj1PhpbHarASpqb2XsYdfgDZmbSefWhpr9jFzMnuAhURFIZI5YvAQzF +# wWoEY+b1BJDuiAwGflYfCR1NOSZqcFv9nZwOnEHF3W86PIibgE4WUuMHimK8KU7Z +# mSxYofuoFiWhhrTtTU7cLyO1vMZR0fIsJpUYFXwN8PmHx46fKOtoEbs801kwggdx +# MIIFWaADAgECAhMzAAAAFcXna54Cm0mZAAAAAAAVMA0GCSqGSIb3DQEBCwUAMIGI +# MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVk +# bW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTIwMAYDVQQDEylN +# aWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgMjAxMDAeFw0yMTA5 +# MzAxODIyMjVaFw0zMDA5MzAxODMyMjVaMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQI +# EwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3Nv +# ZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBD +# QSAyMDEwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA5OGmTOe0ciEL +# eaLL1yR5vQ7VgtP97pwHB9KpbE51yMo1V/YBf2xK4OK9uT4XYDP/XE/HZveVU3Fa +# 4n5KWv64NmeFRiMMtY0Tz3cywBAY6GB9alKDRLemjkZrBxTzxXb1hlDcwUTIcVxR +# MTegCjhuje3XD9gmU3w5YQJ6xKr9cmmvHaus9ja+NSZk2pg7uhp7M62AW36MEByd +# Uv626GIl3GoPz130/o5Tz9bshVZN7928jaTjkY+yOSxRnOlwaQ3KNi1wjjHINSi9 +# 47SHJMPgyY9+tVSP3PoFVZhtaDuaRr3tpK56KTesy+uDRedGbsoy1cCGMFxPLOJi +# ss254o2I5JasAUq7vnGpF1tnYN74kpEeHT39IM9zfUGaRnXNxF803RKJ1v2lIH1+ +# /NmeRd+2ci/bfV+AutuqfjbsNkz2K26oElHovwUDo9Fzpk03dJQcNIIP8BDyt0cY +# 7afomXw/TNuvXsLz1dhzPUNOwTM5TI4CvEJoLhDqhFFG4tG9ahhaYQFzymeiXtco +# dgLiMxhy16cg8ML6EgrXY28MyTZki1ugpoMhXV8wdJGUlNi5UPkLiWHzNgY1GIRH +# 29wb0f2y1BzFa/ZcUlFdEtsluq9QBXpsxREdcu+N+VLEhReTwDwV2xo3xwgVGD94 +# q0W29R6HXtqPnhZyacaue7e3PmriLq0CAwEAAaOCAd0wggHZMBIGCSsGAQQBgjcV +# AQQFAgMBAAEwIwYJKwYBBAGCNxUCBBYEFCqnUv5kxJq+gpE8RjUpzxD/LwTuMB0G +# A1UdDgQWBBSfpxVdAF5iXYP05dJlpxtTNRnpcjBcBgNVHSAEVTBTMFEGDCsGAQQB +# gjdMg30BATBBMD8GCCsGAQUFBwIBFjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20v +# cGtpb3BzL0RvY3MvUmVwb3NpdG9yeS5odG0wEwYDVR0lBAwwCgYIKwYBBQUHAwgw +# GQYJKwYBBAGCNxQCBAweCgBTAHUAYgBDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB +# /wQFMAMBAf8wHwYDVR0jBBgwFoAU1fZWy4/oolxiaNE9lJBb186aGMQwVgYDVR0f +# BE8wTTBLoEmgR4ZFaHR0cDovL2NybC5taWNyb3NvZnQuY29tL3BraS9jcmwvcHJv +# ZHVjdHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYtMjMuY3JsMFoGCCsGAQUFBwEBBE4w +# TDBKBggrBgEFBQcwAoY+aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0 +# cy9NaWNSb29DZXJBdXRfMjAxMC0wNi0yMy5jcnQwDQYJKoZIhvcNAQELBQADggIB +# AJ1VffwqreEsH2cBMSRb4Z5yS/ypb+pcFLY+TkdkeLEGk5c9MTO1OdfCcTY/2mRs +# fNB1OW27DzHkwo/7bNGhlBgi7ulmZzpTTd2YurYeeNg2LpypglYAA7AFvonoaeC6 +# Ce5732pvvinLbtg/SHUB2RjebYIM9W0jVOR4U3UkV7ndn/OOPcbzaN9l9qRWqveV +# tihVJ9AkvUCgvxm2EhIRXT0n4ECWOKz3+SmJw7wXsFSFQrP8DJ6LGYnn8AtqgcKB +# GUIZUnWKNsIdw2FzLixre24/LAl4FOmRsqlb30mjdAy87JGA0j3mSj5mO0+7hvoy +# GtmW9I/2kQH2zsZ0/fZMcm8Qq3UwxTSwethQ/gpY3UA8x1RtnWN0SCyxTkctwRQE +# cb9k+SS+c23Kjgm9swFXSVRk2XPXfx5bRAGOWhmRaw2fpCjcZxkoJLo4S5pu+yFU +# a2pFEUep8beuyOiJXk+d0tBMdrVXVAmxaQFEfnyhYWxz/gq77EFmPWn9y8FBSX5+ +# k77L+DvktxW/tM4+pTFRhLy/AsGConsXHRWJjXD+57XQKBqJC4822rpM+Zv/Cuk0 +# +CQ1ZyvgDbjmjJnW4SLq8CdCPSWU5nR0W2rRnj7tfqAxM328y+l7vzhwRNGQ8cir +# Ooo6CGJ/2XBjU02N7oJtpQUQwXEGahC0HVUzWLOhcGbyoYICyzCCAjQCAQEwgfih +# gdCkgc0wgcoxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYD +# VQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJTAj +# BgNVBAsTHE1pY3Jvc29mdCBBbWVyaWNhIE9wZXJhdGlvbnMxJjAkBgNVBAsTHVRo +# YWxlcyBUU1MgRVNOOjNFN0EtRTM1OS1BMjVEMSUwIwYDVQQDExxNaWNyb3NvZnQg +# VGltZS1TdGFtcCBTZXJ2aWNloiMKAQEwBwYFKw4DAhoDFQATBriNaNpxs5hT773n +# J0nuFIKLmKCBgzCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5n +# dG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9y +# YXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwMA0G +# CSqGSIb3DQEBBQUAAgUA5dYCvDAiGA8yMDIyMDMxMjAxMTc0OFoYDzIwMjIwMzEz +# MDExNzQ4WjB0MDoGCisGAQQBhFkKBAExLDAqMAoCBQDl1gK8AgEAMAcCAQACAgCw +# MAcCAQACAhGuMAoCBQDl11Q8AgEAMDYGCisGAQQBhFkKBAIxKDAmMAwGCisGAQQB +# hFkKAwKgCjAIAgEAAgMHoSChCjAIAgEAAgMBhqAwDQYJKoZIhvcNAQEFBQADgYEA +# H1WmVFLLRfx8XuVuVC/CzptlQCI5EG0ppvZ1it5m9CxMeTkVJDU84hnn9X1bl28q +# RoLrKIFHEdL8NxTQqs7U3qbouKFyFPFB+O62aKWhtN8w0MAnbN9H6ERv9ymKY/cS +# XMm9XbGlE7mir054levW/KWMtMQz8Vynxi1nNruNGH4xggQNMIIECQIBATCBkzB8 +# MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVk +# bW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1N +# aWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMAITMwAAAaDpu4y7DqLRegABAAAB +# oDANBglghkgBZQMEAgEFAKCCAUowGgYJKoZIhvcNAQkDMQ0GCyqGSIb3DQEJEAEE +# MC8GCSqGSIb3DQEJBDEiBCA6yg5Q9T8Zf3uJpxpGStuZknGB/oQrDzqIf18z6csZ +# JTCB+gYLKoZIhvcNAQkQAi8xgeowgecwgeQwgb0EIC9HijxoZQQiEi3dES+zHT6y +# +czpaJqBrlI9oriDr7TTMIGYMIGApH4wfDELMAkGA1UEBhMCVVMxEzARBgNVBAgT +# Cldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29m +# dCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENB +# IDIwMTACEzMAAAGg6buMuw6i0XoAAQAAAaAwIgQgNtOO732G/6Ao4oRTpGrp3/oo +# gs/bdXoL/1Exes00Z+owDQYJKoZIhvcNAQELBQAEggIAVqfo8sV5o++I1u8kGl2I +# R38dS9Y7FY8Tx7OcnzcWH6lwksT/66VKkH+2VxlgLUYdA983c4oBzYkCQ73cOn+F +# dfqhCj7tsPwinK7yYMlRr64GJdLMmRlpg0BQoigPKFu1tgCMj9EMQv9gw/JuG+CX +# 4iSNXFRy414//W42BF9Oi9pht46EqEth014nUjXQq9ADBqF1SoWWhsqxm8x4XUIz +# 95Bn0zBMiBmoz7dqZ9k1OcQPhRmPBqlFfIa80uxSyWC1+ZAGaFl1jn+lZ/8mNAha +# VeTwz0q99J41idqkzeIMhN7gE7u06N/JqpMzCqAglDaFvQNs9gGQNSwMl07tR86o +# Pu8cSzqOoLzZ2lNKPMD70Il74ucqaOn9RvkfS99UCec3W0IX2Q4UFqFbWL4juVNl +# CSdkDxbhaTmDc+oBimgWBlTh70nqBlsvanu9Q1Q/mh2KzCwUZ20dbgurFAyb5tSO +# XGymwPJ09Ae+9I3Q1P8clWr7ZgCRqhHYpqO46iuyvjG1WL0qCkyFRiWD05Nlqe/7 +# DsXgjkPoqmH4di5I6a8sFE1p3sX73H7esvc8KeQEX3rPwQKinodk72tCPq0OGgfV +# Sp2OZzJSf5klmK0ig+x78AkHu/gWdJFLVeghAekXQ9X2/gGLpxKuSI0c9wR8Qt84 +# gOroSsuAmRkqDbQNW5L4d7o= +# SIG # End signature block diff --git a/unsupported/microsoft-compliance/1.0.0/yh.psm1 b/unsupported/microsoft-compliance/1.0.0/yh.psm1 new file mode 100644 index 00000000..7fc13523 --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/yh.psm1 @@ -0,0 +1,1140 @@ +# Import the REST module so that the EXO* cmdlets are present before Connect-ExchangeOnline in the powershell instance. +$RestModule = "Microsoft.Exchange.Management.RestApiClient.dll" +$RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestModule) +Import-Module $RestModulePath + +$ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll" +$ExoPowershellModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule) +Import-Module $ExoPowershellModulePath + +############# Helper Functions Begin ############# + + <# + Details to be printed on the console when the Connect-ExchangeOnline function is run + #> + function Print-Details + { + if ($UseRPSSession) + { + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "The module allows access to all existing remote PowerShell (V1) cmdlets in addition to the 9 new, faster, and more reliable cmdlets." + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "| Old Cmdlets | New/Reliable/Faster Cmdlets |" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "| Get-CASMailbox | Get-EXOCASMailbox |" + Write-Host -ForegroundColor Yellow "| Get-Mailbox | Get-EXOMailbox |" + Write-Host -ForegroundColor Yellow "| Get-MailboxFolderPermission | Get-EXOMailboxFolderPermission |" + Write-Host -ForegroundColor Yellow "| Get-MailboxFolderStatistics | Get-EXOMailboxFolderStatistics |" + Write-Host -ForegroundColor Yellow "| Get-MailboxPermission | Get-EXOMailboxPermission |" + Write-Host -ForegroundColor Yellow "| Get-MailboxStatistics | Get-EXOMailboxStatistics |" + Write-Host -ForegroundColor Yellow "| Get-MobileDeviceStatistics | Get-EXOMobileDeviceStatistics |" + Write-Host -ForegroundColor Yellow "| Get-Recipient | Get-EXORecipient |" + Write-Host -ForegroundColor Yellow "| Get-RecipientPermission | Get-EXORecipientPermission |" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "To get additional information, run: Get-Help Connect-ExchangeOnline or check https://aka.ms/exops-docs" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "Send your product improvement suggestions and feedback to exocmdletpreview@service.microsoft.com. For issues related to the module, contact Microsoft support. Don't use the feedback alias for problems or support issues." + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "" + + } + else + { + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "This version of EXO PowerShell V2 module contains new REST API backed cmdlets which doesn't require Windows Remote PowerShell for client-server communication." + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "You can now run those cmdlets after turning off WinRM Basic Auth in your client machine and thus making it more secure. Read more here - https://aka.ms/exov2-securemode" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "You can share your feedback and suggestions to exocmdletpreview@service.microsoft.com" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "" + + } + + } + + <# + Get the ExchangeOnlineManagement module version. + Same function is present in the autogen module. Both the codes should be kept in sync. + #> + function Get-ModuleVersion + { + try + { + # Return the already computed version info if available. + if ($script:ModuleVersion -ne $null -and $script:ModuleVersion -ne '') + { + Write-Verbose "Returning precomputed version info: $script:ModuleVersion" + return $script:ModuleVersion; + } + + $exoModule = Get-Module ExchangeOnlineManagement + # Get the module version from the loaded module info. + $script:ModuleVersion = $exoModule.Version.ToString() + + # Look for prerelease information from the corresponding module manifest. + $exoModuleRoot = (Get-Item $exoModule.Path).Directory.Parent.FullName + + $exoModuleManifestPath = Join-Path -Path $exoModuleRoot -ChildPath ExchangeOnlineManagement.psd1 + $isExoModuleManifestPathValid = Test-Path -Path $exoModuleManifestPath + if ($isExoModuleManifestPathValid -ne $true) + { + # Could be a local debug build import for testing. Skip extracting prerelease info for those. + Write-Verbose "Module manifest path invalid, path: $exoModuleManifestPath, skipping extracting prerelease info" + return $script:ModuleVersion + } + + $exoModuleManifestContent = Get-Content -Path $exoModuleManifestPath + $preReleaseInfo = $exoModuleManifestContent -match "Prerelease = '(.*)'" + if ($preReleaseInfo -ne $null) + { + $script:ModuleVersion = "{0}-{1}" -f $exoModule.Version.ToString(),$preReleaseInfo[0].Split('=')[1].Trim().Trim("'") + } + + Write-Verbose "Computed version info: $script:ModuleVersion" + return $script:ModuleVersion + } + catch + { + return [string]::Empty + } + } + + <# + .Synopsis Validates a given Uri + #> + function Test-Uri + { + [CmdletBinding()] + [OutputType([bool])] + Param + ( + # Uri to be validated + [Parameter(Mandatory=$true, ValueFromPipelineByPropertyName=$true, Position=0)] + [string] + $UriString + ) + + [Uri]$uri = $UriString -as [Uri] + + $uri.AbsoluteUri -ne $null -and $uri.Scheme -eq 'https' + } + + <# + .Synopsis Is Cloud Shell Environment + #> + function global:IsCloudShellEnvironment() + { + return [Microsoft.Exchange.Management.AdminApiProvider.Utility]::IsCloudShellEnvironment(); + } + + <# + .Synopsis Override Get-PSImplicitRemotingSession function for reconnection + #> + function global:UpdateImplicitRemotingHandler() + { + # Remote Powershell Sessions created by the ExchangeOnlineManagement module are given a name that starts with "ExchangeOnlineInternalSession". + # Only modules from such sessions should be modified here, to prevent modfification of RPS tmp_* modules created by running the New-PSSession cmdlet directly, or when connecting to exchange on-prem tenants. + $existingPSSession = Get-PSSession | Where-Object {$_.ConfigurationName -like "Microsoft.Exchange" -and $_.Name -like "ExchangeOnlineInternalSession*"} + + if ($existingPSSession.count -gt 0) + { + foreach ($session in $existingPSSession) + { + $module = Get-Module $session.CurrentModuleName + if ($module -eq $null) + { + continue + } + + [bool]$moduleProcessed = $false + [string] $moduleUrl = $module.Description + [int] $queryStringIndex = $moduleUrl.IndexOf("?") + + if ($queryStringIndex -gt 0) + { + $moduleUrl = $moduleUrl.SubString(0,$queryStringIndex) + } + + if ($moduleUrl.EndsWith("/PowerShell-LiveId", [StringComparison]::OrdinalIgnoreCase) -or $moduleUrl.EndsWith("/PowerShell", [StringComparison]::OrdinalIgnoreCase)) + { + & $module { ${function:Get-PSImplicitRemotingSession} = ` + { + param( + [Parameter(Mandatory = $true, Position = 0)] + [string] + $commandName + ) + + $shouldRemoveCurrentSession = $false; + # Clear any left over PS tmp modules + if (($script:PSSession -ne $null) -and ($script:PSSession.PreviousModuleName -ne $null) -and ($script:PSSession.PreviousModuleName -ne $script:MyModule.Name)) + { + $null = Remove-Module -Name $script:PSSession.PreviousModuleName -ErrorAction SilentlyContinue + $script:PSSession.PreviousModuleName = $null + } + + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened')) + { + Set-PSImplicitRemotingSession ` + (& $script:GetPSSession ` + -InstanceId $script:PSSession.InstanceId.Guid ` + -ErrorAction SilentlyContinue ) + } + if ($script:PSSession -ne $null) + { + if ($script:PSSession.Runspace.RunspaceStateInfo.State -eq 'Disconnected') + { + # If we are handed a disconnected session, try re-connecting it before creating a new session. + Set-PSImplicitRemotingSession ` + (& $script:ConnectPSSession ` + -Session $script:PSSession ` + -ErrorAction SilentlyContinue) + } + else + { + # Import the module once more to ensure that Test-ActiveToken is present + Import-Module $global:_EXO_ModulePath -Cmdlet Test-ActiveToken; + + # If there is no active token run the new session flow + $hasActiveToken = Test-ActiveToken -TokenExpiryTime $script:PSSession.TokenExpiryTime + $sessionIsOpened = $script:PSSession.Runspace.RunspaceStateInfo.State -eq 'Opened' + if (($hasActiveToken -eq $false) -or ($sessionIsOpened -ne $true)) + { + #If there is no active user token or opened session then ensure that we remove the old session + $shouldRemoveCurrentSession = $true; + } + } + } + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened') -or ($shouldRemoveCurrentSession -eq $true)) + { + # Import the module once more to ensure that New-ExoPSSession is present + Import-Module $global:_EXO_ModulePath -Cmdlet New-ExoPSSession; + + Write-PSImplicitRemotingMessage ('Creating a new Remote PowerShell session using Modern Authentication for implicit remoting of "{0}" command ...' -f $commandName) + $session = New-ExoPSSession -PreviousSession $script:PSSession + + if ($session -ne $null) + { + if ($shouldRemoveCurrentSession -eq $true) + { + Remove-PSSession $script:PSSession + } + + # Import the latest session to ensure that the next cmdlet call would occur on the new PSSession instance. + $PSSessionModuleInfo = Import-PSSession $session -AllowClobber -DisableNameChecking -CommandName $script:MyModule.CommandName -FormatTypeName $script:MyModule.FormatTypeName + + # Add the name of the module to clean up in case of removing the broken session + $session | Add-Member -NotePropertyName "CurrentModuleName" -NotePropertyValue $PSSessionModuleInfo.Name + + $CurrentModule = Import-Module $PSSessionModuleInfo.Path -Global -DisableNameChecking -Prefix $script:MyModule.ModulePrefix -PassThru + $CurrentModule | Add-Member -NotePropertyName "ModulePrefix" -NotePropertyValue $script:MyModule.ModulePrefix + $CurrentModule | Add-Member -NotePropertyName "CommandName" -NotePropertyValue $script:MyModule.CommandName + $CurrentModule | Add-Member -NotePropertyName "FormatTypeName" -NotePropertyValue $script:MyModule.FormatTypeName + + $session | Add-Member -NotePropertyName "PreviousModuleName" -NotePropertyValue $script:MyModule.Name + + UpdateImplicitRemotingHandler + $script:PSSession = $session + } + } + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened')) + { + throw 'No session has been associated with this implicit remoting module' + } + + return [Management.Automation.Runspaces.PSSession]$script:PSSession + }} + } + } + } + } + + <# + .SYNOPSIS Extract organization name from UserPrincipalName + #> + function Get-OrgNameFromUPN + { + param([string] $UPN) + $fields = $UPN -split '@' + return $fields[-1] + } + + <# + .SYNOPSIS Get the command from the given module + #> + function global:Get-WrappedCommand + { + param( + [string] $CommandName, + [string] $ModuleName, + [string] $CommandType) + + $cmd = (Get-Module $moduleName).ExportedFunctions[$CommandName] + return $cmd + } + +############# Helper Functions End ############# + +###### Begin Main ###### + +$EOPConnectionInProgress = $false +function Connect-ExchangeOnline +{ + [CmdletBinding()] + param( + + # Connection Uri for the Remote PowerShell endpoint + [string] $ConnectionUri = '', + + # Azure AD Authorization endpoint Uri that can issue the OAuth2 access tokens + [string] $AzureADAuthorizationEndpointUri = '', + + # Exchange Environment name + [Microsoft.Exchange.Management.RestApiClient.ExchangeEnvironment] $ExchangeEnvironmentName = 'O365Default', + + # PowerShell session options to be used when opening the Remote PowerShell session + [System.Management.Automation.Remoting.PSSessionOption] $PSSessionOption = $null, + + # Switch to bypass use of mailbox anchoring hint. + [switch] $BypassMailboxAnchoring = $false, + + # Delegated Organization Name + [string] $DelegatedOrganization = '', + + # Prefix + [string] $Prefix = '', + + # Show Banner of Exchange cmdlets Mapping and recent updates + [switch] $ShowBanner = $true, + + #Cmdlets to Import for rps cmdlets , by default it would bring all + [string[]] $CommandName = @("*"), + + #The way the output objects would be printed on the console + [string[]] $FormatTypeName = @("*"), + + # Use Remote PowerShell Session based connection + [switch] $UseRPSSession = $false + ) + DynamicParam + { + if (($isCloudShell = IsCloudShellEnvironment) -eq $false) + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # User Principal Name or email address of the user + $UserPrincipalName = New-Object System.Management.Automation.RuntimeDefinedParameter('UserPrincipalName', [string], $attributeCollection) + $UserPrincipalName.Value = '' + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + # Certificate + $Certificate = New-Object System.Management.Automation.RuntimeDefinedParameter('Certificate', [System.Security.Cryptography.X509Certificates.X509Certificate2], $attributeCollection) + $Certificate.Value = $null + + # Certificate Path + $CertificateFilePath = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateFilePath', [string], $attributeCollection) + $CertificateFilePath.Value = '' + + # Certificate Password + $CertificatePassword = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificatePassword', [System.Security.SecureString], $attributeCollection) + $CertificatePassword.Value = $null + + # Certificate Thumbprint + #$CertificateThumbprint = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateThumbprint', [string], $attributeCollection) + #$CertificateThumbprint.Value = '' + + # Application Id + $AppId = New-Object System.Management.Automation.RuntimeDefinedParameter('AppId', [string], $attributeCollection) + $AppId.Value = '' + + # Organization + $Organization = New-Object System.Management.Automation.RuntimeDefinedParameter('Organization', [string], $attributeCollection) + $Organization.Value = '' + + # Switch to collect telemetry on command execution. + $EnableErrorReporting = New-Object System.Management.Automation.RuntimeDefinedParameter('EnableErrorReporting', [switch], $attributeCollection) + $EnableErrorReporting.Value = $false + + # Where to store EXO command telemetry data. By default telemetry is stored in the directory "%TEMP%/EXOTelemetry" in the file : EXOCmdletTelemetry-yyyymmdd-hhmmss.csv. + $LogDirectoryPath = New-Object System.Management.Automation.RuntimeDefinedParameter('LogDirectoryPath', [string], $attributeCollection) + $LogDirectoryPath.Value = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), "EXOCmdletTelemetry") + + # Create a new attribute and valiate set against the LogLevel + $LogLevelAttribute = New-Object System.Management.Automation.ParameterAttribute + $LogLevelAttribute.Mandatory = $false + $LogLevelAttributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $LogLevelAttributeCollection.Add($LogLevelAttribute) + $LogLevelList = @([Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::Default, [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::All) + $ValidateSet = New-Object System.Management.Automation.ValidateSetAttribute($LogLevelList) + $LogLevel = New-Object System.Management.Automation.RuntimeDefinedParameter('LogLevel', [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel], $LogLevelAttributeCollection) + $LogLevel.Attributes.Add($ValidateSet) + +# EXO params start + + # Switch to track perfomance + $TrackPerformance = New-Object System.Management.Automation.RuntimeDefinedParameter('TrackPerformance', [bool], $attributeCollection) + $TrackPerformance.Value = $false + + # Flag to enable or disable showing the number of objects written + $ShowProgress = New-Object System.Management.Automation.RuntimeDefinedParameter('ShowProgress', [bool], $attributeCollection) + $ShowProgress.Value = $false + + # Switch to enable/disable Multi-threading in the EXO cmdlets + $UseMultithreading = New-Object System.Management.Automation.RuntimeDefinedParameter('UseMultithreading', [bool], $attributeCollection) + $UseMultithreading.Value = $true + + # Pagesize Param + $PageSize = New-Object System.Management.Automation.RuntimeDefinedParameter('PageSize', [uint32], $attributeCollection) + $PageSize.Value = 1000 + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + # Switch to CmdInline parameters + $InlineCredential = New-Object System.Management.Automation.RuntimeDefinedParameter('InlineCredential', [switch], $attributeCollection) + $InlineCredential.Value = $false + +# EXO params end + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('UserPrincipalName', $UserPrincipalName) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('Certificate', $Certificate) + $paramDictionary.Add('CertificateFilePath', $CertificateFilePath) + $paramDictionary.Add('CertificatePassword', $CertificatePassword) + $paramDictionary.Add('AppId', $AppId) + $paramDictionary.Add('Organization', $Organization) + $paramDictionary.Add('EnableErrorReporting', $EnableErrorReporting) + $paramDictionary.Add('LogDirectoryPath', $LogDirectoryPath) + $paramDictionary.Add('LogLevel', $LogLevel) + $paramDictionary.Add('TrackPerformance', $TrackPerformance) + $paramDictionary.Add('ShowProgress', $ShowProgress) + $paramDictionary.Add('UseMultithreading', $UseMultithreading) + $paramDictionary.Add('PageSize', $PageSize) + if($PSEdition -eq 'Core') + { + $paramDictionary.Add('Device', $Device) + $paramDictionary.Add('InlineCredential', $InlineCredential); + # We do not want to expose certificate thumprint in Linux as it is not feasible there. + if($IsWindows) + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + } + else + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + + return $paramDictionary + } + else + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + # Switch to collect telemetry on command execution. + $EnableErrorReporting = New-Object System.Management.Automation.RuntimeDefinedParameter('EnableErrorReporting', [switch], $attributeCollection) + $EnableErrorReporting.Value = $false + + # Where to store EXO command telemetry data. By default telemetry is stored in the directory "%TEMP%/EXOTelemetry" in the file : EXOCmdletTelemetry-yyyymmdd-hhmmss.csv. + $LogDirectoryPath = New-Object System.Management.Automation.RuntimeDefinedParameter('LogDirectoryPath', [string], $attributeCollection) + $LogDirectoryPath.Value = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), "EXOCmdletTelemetry") + + # Create a new attribute and valiate set against the LogLevel + $LogLevelAttribute = New-Object System.Management.Automation.ParameterAttribute + $LogLevelAttribute.Mandatory = $false + $LogLevelAttributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $LogLevelAttributeCollection.Add($LogLevelAttribute) + $LogLevelList = @([Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::Default, [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::All) + $ValidateSet = New-Object System.Management.Automation.ValidateSetAttribute($LogLevelList) + $LogLevel = New-Object System.Management.Automation.RuntimeDefinedParameter('LogLevel', [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel], $LogLevelAttributeCollection) + $LogLevel.Attributes.Add($ValidateSet) + + # Switch to CmdInline parameters + $InlineCredential = New-Object System.Management.Automation.RuntimeDefinedParameter('InlineCredential', [switch], $attributeCollection) + $InlineCredential.Value = $false + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('Device', $Device) + $paramDictionary.Add('EnableErrorReporting', $EnableErrorReporting) + $paramDictionary.Add('LogDirectoryPath', $LogDirectoryPath) + $paramDictionary.Add('LogLevel', $LogLevel) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('InlineCredential', $InlineCredential) + return $paramDictionary + } + } + process { + + # Validate parameters + if (($ConnectionUri -ne '') -and (-not (Test-Uri $ConnectionUri))) + { + throw "Invalid ConnectionUri parameter '$ConnectionUri'" + } + if (($AzureADAuthorizationEndpointUri -ne '') -and (-not (Test-Uri $AzureADAuthorizationEndpointUri))) + { + throw "Invalid AzureADAuthorizationEndpointUri parameter '$AzureADAuthorizationEndpointUri'" + } + if (($Prefix -ne '')) + { + if ($Prefix -notmatch '^[a-z0-9]+$') + { + throw "Use of any special characters in the Prefix string is not supported." + } + if ($Prefix -eq 'EXO') + { + throw "Prefix 'EXO' is a reserved Prefix, please use a different prefix." + } + } + + # Keep track of error count at beginning. + $errorCountAtStart = $global:Error.Count; + try + { + $moduleVersion = Get-ModuleVersion + + Write-Verbose "ExchangeEnvironment : $ExchangeEnvironmentName" + Write-Verbose "ConnectionUri : $ConnectionUri" + Write-Verbose "AzureADAuthorizationEndpointUri : $AzureADAuthorizationEndpointUri" + Write-Verbose "DelegatedOrganization : $DelegatedOrganization" + Write-Verbose "Prefix : $Prefix" + Write-Verbose ("FormatTypeName :" + [String]::Join(' ,', $FormatTypeName)) + Write-Verbose ("CommandName :" + [String]::Join(' ,', $CommandName)) + Write-Verbose "ModuleVersion: $moduleVersion" + + if ($isCloudShell -eq $false) + { + $ConnectionContext = Get-ConnectionContext -ExchangeEnvironmentName $ExchangeEnvironmentName -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -UserPrincipalName $UserPrincipalName.Value -PSSessionOption $PSSessionOption -Credential $Credential.Value -BypassMailboxAnchoring:$BypassMailboxAnchoring -DelegatedOrg $DelegatedOrganization -Certificate $Certificate.Value -CertificateFilePath $CertificateFilePath.Value -CertificatePassword $CertificatePassword.Value -CertificateThumbprint $CertificateThumbprint.Value -AppId $AppId.Value -Organization $Organization.Value -Device:$Device.Value -InlineCredential:$InlineCredential.Value -CommandName $CommandName -FormatTypeName $FormatTypeName -Prefix $Prefix -PageSize $PageSize.Value -ExoModuleVersion:$moduleVersion + } + else + { + $ConnectionContext = Get-ConnectionContext -ExchangeEnvironmentName $ExchangeEnvironmentName -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -Credential $Credential.Value -PSSessionOption $PSSessionOption -BypassMailboxAnchoring:$BypassMailboxAnchoring -Device:$Device.Value -InlineCredential:$InlineCredential.Value -DelegatedOrg $DelegatedOrganization -CommandName $CommandName -FormatTypeName $FormatTypeName -Prefix $prefix -ExoModuleVersion:$moduleVersion + } + + if ($isCloudShell -eq $false) + { + $global:_EXO_EnableErrorReporting = $EnableErrorReporting.Value; + } + + if ($ShowBanner -eq $true) + { + try + { + $BannerContent = Get-EXOBanner -ConnectionContext:$ConnectionContext -IsRPSSession:$UseRPSSession.IsPresent + Write-Host -ForegroundColor Yellow $BannerContent + } + catch + { + Write-Verbose "Failed to fetch banner content from server, using the default banner content. Reason: $_" + Print-Details; + } + } + + if (($ConnectionUri -ne '') -and ($AzureADAuthorizationEndpointUri -eq '')) + { + Write-Information "Using ConnectionUri:'$ConnectionUri', in the environment:'$ExchangeEnvironmentName'." + } + if (($AzureADAuthorizationEndpointUri -ne '') -and ($ConnectionUri -eq '')) + { + Write-Information "Using AzureADAuthorizationEndpointUri:'$AzureADAuthorizationEndpointUri', in the environment:'$ExchangeEnvironmentName'." + } + + $ImportedModuleName = ''; + $LogModuleDirectoryPath = [System.IO.Path]::GetTempPath(); + + if ($UseRPSSession -eq $true) + { + $ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll"; + $ModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule); + + Import-Module $ModulePath; + + $global:_EXO_ModulePath = $ModulePath; + + $PSSession = New-ExoPSSession -ConnectionContext $ConnectionContext + + if ($PSSession -ne $null) + { + $PSSessionModuleInfo = Import-PSSession $PSSession -AllowClobber -DisableNameChecking -CommandName $CommandName -FormatTypeName $FormatTypeName + + # Add the name of the module to clean up in case of removing the broken session + $PSSession | Add-Member -NotePropertyName "CurrentModuleName" -NotePropertyValue $PSSessionModuleInfo.Name + + # Import the above module globally. This is needed as with using psm1 files, + # any module which is dynamically loaded in the nested module does not reflect globally. + $CurrentModule = Import-Module $PSSessionModuleInfo.Path -Global -DisableNameChecking -Prefix $Prefix -PassThru + $CurrentModule | Add-Member -NotePropertyName "ModulePrefix" -NotePropertyValue $Prefix + $CurrentModule | Add-Member -NotePropertyName "CommandName" -NotePropertyValue $CommandName + $CurrentModule | Add-Member -NotePropertyName "FormatTypeName" -NotePropertyValue $FormatTypeName + + UpdateImplicitRemotingHandler + + # Import the REST module + $RestPowershellModule = "Microsoft.Exchange.Management.RestApiClient.dll"; + $RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestPowershellModule); + Import-Module $RestModulePath -Cmdlet Set-ExoAppSettings; + + $ImportedModuleName = $PSSessionModuleInfo.Name; + } + } + else + { + # Download the new web based EXOModule + $ImportedModule = New-EXOModule -ConnectionContext $ConnectionContext; + if ($null -ne $ImportedModule) + { + $ImportedModuleName = $ImportedModule.Name; + $LogModuleDirectoryPath = $ImportedModule.ModuleBase + + Write-Verbose "AutoGen EXOModule created at $($ImportedModule.ModuleBase)" + if ($null -ne $HelpFileNames -and $HelpFileNames -is [array] -and $HelpFileNames.Count -gt 0) + { + Get-HelpFiles -HelpFileNames $HelpFileNames -ConnectionContext $ConnectionContext -ImportedModule $ImportedModule -EnableErrorReporting:$EnableErrorReporting.Value + } + else + { + Write-Warning "Get-help cmdlet might not work. Please reconnect if you want to access that functionality." + } + } + else + { + throw "Module could not be correctly formed. Please run Connect-ExchangeOnline again." + } + } + + # If we are configured to collect telemetry, add telemetry wrappers. + if ($EnableErrorReporting.Value -eq $true) + { + $FilePath = Add-EXOClientTelemetryWrapper -Organization (Get-OrgNameFromUPN -UPN $UserPrincipalName.Value) -PSSessionModuleName $ImportedModuleName -LogDirectoryPath $LogDirectoryPath.Value -LogModuleDirectoryPath $LogModuleDirectoryPath + $global:_EXO_TelemetryFilePath = $FilePath[0] + Import-Module $FilePath[1] -DisableNameChecking -Global + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Connect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid + + if ($EOPConnectionInProgress -eq $false) + { + # Set the AppSettings + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -EnableErrorReporting $true -LogDirectoryPath $LogDirectoryPath.Value -LogLevel $LogLevel.Value + } + } + else + { + if ($EOPConnectionInProgress -eq $false) + { + # Set the AppSettings disabling the logging + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -EnableErrorReporting $false + } + } + } + catch + { + # If telemetry is enabled, log errors generated from this cmdlet also. + if ($EnableErrorReporting.Value -eq $true) + { + $errorCountAtProcessEnd = $global:Error.Count + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath -LogDirectoryPath $LogDirectoryPath.Value + + # Import the REST module + $RestPowershellModule = "Microsoft.Exchange.Management.RestApiClient.dll"; + $RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestPowershellModule); + Import-Module $RestModulePath -Cmdlet Set-ExoAppSettings; + + # Set the AppSettings + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -ConnectionUri $ConnectionUri -EnableErrorReporting $true -LogDirectoryPath $LogDirectoryPath.Value -LogLevel $LogLevel.Value + } + + # Log errors which are encountered during Connect-ExchangeOnline execution. + Write-Warning("Writing Connect-ExchangeOnline error log to " + $global:_EXO_TelemetryFilePath) + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Connect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid -ErrorObject $global:Error -ErrorRecordsToConsider ($errorCountAtProcessEnd - $errorCountAtStart) + } + throw $_ + } + } +} + +function Connect-IPPSSession +{ + [CmdletBinding()] + param( + # Connection Uri for the Remote PowerShell endpoint + [string] $ConnectionUri = 'https://ps.compliance.protection.outlook.com/PowerShell-LiveId', + + # Azure AD Authorization endpoint Uri that can issue the OAuth2 access tokens + [string] $AzureADAuthorizationEndpointUri = 'https://login.microsoftonline.com/organizations', + + # Delegated Organization Name + [string] $DelegatedOrganization = '', + + # PowerShell session options to be used when opening the Remote PowerShell session + [System.Management.Automation.Remoting.PSSessionOption] $PSSessionOption = $null, + + # Switch to bypass use of mailbox anchoring hint. + [switch] $BypassMailboxAnchoring = $false, + + # Prefix + [string] $Prefix = '', + + #Cmdlets to Import, by default it would bring all + [string[]] $CommandName = @("*"), + + #The way the output objects would be printed on the console + [string[]] $FormatTypeName = @("*") + ) + DynamicParam + { + if (($isCloudShell = IsCloudShellEnvironment) -eq $false) + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # User Principal Name or email address of the user + $UserPrincipalName = New-Object System.Management.Automation.RuntimeDefinedParameter('UserPrincipalName', [string], $attributeCollection) + $UserPrincipalName.Value = '' + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + # Certificate + $Certificate = New-Object System.Management.Automation.RuntimeDefinedParameter('Certificate', [System.Security.Cryptography.X509Certificates.X509Certificate2], $attributeCollection) + $Certificate.Value = $null + + # Certificate Path + $CertificateFilePath = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateFilePath', [string], $attributeCollection) + $CertificateFilePath.Value = '' + + # Certificate Password + $CertificatePassword = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificatePassword', [System.Security.SecureString], $attributeCollection) + $CertificatePassword.Value = $null + + # Certificate Thumbprint + $CertificateThumbprint = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateThumbprint', [string], $attributeCollection) + $CertificateThumbprint.Value = '' + + # Application Id + $AppId = New-Object System.Management.Automation.RuntimeDefinedParameter('AppId', [string], $attributeCollection) + $AppId.Value = '' + + # Organization + $Organization = New-Object System.Management.Automation.RuntimeDefinedParameter('Organization', [string], $attributeCollection) + $Organization.Value = '' + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('UserPrincipalName', $UserPrincipalName) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('Certificate', $Certificate) + $paramDictionary.Add('CertificateFilePath', $CertificateFilePath) + $paramDictionary.Add('CertificatePassword', $CertificatePassword) + $paramDictionary.Add('AppId', $AppId) + $paramDictionary.Add('Organization', $Organization) + if($PSEdition -eq 'Core') + { + # We do not want to expose certificate thumprint in Linux as it is not feasible there. + if($IsWindows) + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + } + else + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + + return $paramDictionary + } + else + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('Device', $Device) + return $paramDictionary + } + } + process + { + try + { + $EOPConnectionInProgress = $true + if ($isCloudShell -eq $false) + { + Write-Host $CertificateThumbprint + Connect-ExchangeOnline -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -UserPrincipalName $UserPrincipalName.Value -PSSessionOption $PSSessionOption -Credential $Credential.Value -BypassMailboxAnchoring:$BypassMailboxAnchoring -ShowBanner:$false -DelegatedOrganization $DelegatedOrganization -Certificate $Certificate.Value -CertificateFilePath $CertificateFilePath.Value -CertificatePassword $CertificatePassword.Value -CertificateThumbprint $CertificateThumbprint.Value -AppId $AppId.Value -Organization $Organization.Value -Prefix $Prefix -CommandName $CommandName -FormatTypeName $FormatTypeName -UseRPSSession:$true + } + else + { + Connect-ExchangeOnline -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -PSSessionOption $PSSessionOption -BypassMailboxAnchoring:$BypassMailboxAnchoring -Device:$Device.Value -ShowBanner:$false -DelegatedOrganization $DelegatedOrganization -Prefix $Prefix -CommandName $CommandName -FormatTypeName $FormatTypeName -UseRPSSession:$true + } + } + finally + { + $EOPConnectionInProgress = $false + } + } +} + +function Disconnect-ExchangeOnline +{ + [CmdletBinding(SupportsShouldProcess, ConfirmImpact='High')] + param() + + process + { + if ($PSCmdlet.ShouldProcess( + "Running this cmdlet clears all active sessions created using Connect-ExchangeOnline or Connect-IPPSSession.", + "Press(Y/y/A/a) if you want to continue.", + "Running this cmdlet clears all active sessions created using Connect-ExchangeOnline or Connect-IPPSSession. ")) + { + + # Keep track of error count at beginning. + $errorCountAtStart = $global:Error.Count; + + try + { + # Import the module once more to ensure that Test-ActiveToken is present + $ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll"; + $ModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule); + Import-Module $ModulePath -Cmdlet Clear-ActiveToken; + + $existingPSSession = Get-PSSession | Where-Object {$_.ConfigurationName -like "Microsoft.Exchange" -and $_.Name -like "ExchangeOnlineInternalSession*"} + + if ($existingPSSession.count -gt 0) + { + for ($index = 0; $index -lt $existingPSSession.count; $index++) + { + $session = $existingPSSession[$index] + Remove-PSSession -session $session + + Write-Information "Removed the PSSession $($session.Name) connected to $($session.ComputerName)" + + # Remove any active access token from the cache + Clear-ActiveToken -TokenProvider $session.TokenProvider + + # Remove any previous modules loaded because of the current PSSession + if ($session.PreviousModuleName -ne $null) + { + if ((Get-Module $session.PreviousModuleName).Count -ne 0) + { + $null = Remove-Module -Name $session.PreviousModuleName -ErrorAction SilentlyContinue + } + + $session.PreviousModuleName = $null + } + + # Remove any leaked module in case of removal of broken session object + if ($session.CurrentModuleName -ne $null) + { + if ((Get-Module $session.CurrentModuleName).Count -ne 0) + { + $null = Remove-Module -Name $session.CurrentModuleName -ErrorAction SilentlyContinue + } + } + } + } + + # Clear all the active tokens in ConnectionContext + [Microsoft.Exchange.Management.ExoPowershellSnapin.ConnectionContextFactory]::RemoveAllTokensFromConnectionContext() + + # Remove all the AutoREST modules from this instance of powershell if created + $existingAutoRESTModules = Get-Module "tmpEXO_*" + foreach ($module in $existingAutoRESTModules) + { + $null = Remove-Module -Name $module -ErrorAction SilentlyContinue + } + + Write-Information "Disconnected successfully !" + + if ($global:_EXO_EnableErrorReporting -eq $true) + { + # Remove all the Wrapped modules from this instance of powershell if created + $existingWrappedModules = Get-Module "EXOCmdletWrapper-*" + foreach ($module in $existingWrappedModules) + { + $null = Remove-Module -Name $module -ErrorAction SilentlyContinue + } + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath + } + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Disconnect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid + } + } + catch + { + # If telemetry is enabled, log errors generated from this cmdlet also. + if ($global:_EXO_EnableErrorReporting -eq $true) + { + $errorCountAtProcessEnd = $global:Error.Count + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath + } + + # Log errors which are encountered during Disconnect-ExchangeOnline execution. + Write-Warning("Writing Disconnect-ExchangeOnline errors to " + $global:_EXO_TelemetryFilePath) + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Disconnect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid -ErrorObject $global:Error -ErrorRecordsToConsider ($errorCountAtProcessEnd - $errorCountAtStart) + } + + throw $_ + } + } + } +} + +# SIG # Begin signature block +# MIInnQYJKoZIhvcNAQcCoIInjjCCJ4oCAQExDzANBglghkgBZQMEAgEFADB5Bgor +# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG +# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCAk8bWd5n6Z+FmL +# OYNO5yQEAw68XUDDa/dIT4+yqen8YKCCDYEwggX/MIID56ADAgECAhMzAAACUosz +# qviV8znbAAAAAAJSMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD +# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy +# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p +# bmcgUENBIDIwMTEwHhcNMjEwOTAyMTgzMjU5WhcNMjIwOTAxMTgzMjU5WjB0MQsw +# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u +# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy +# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +# AQDQ5M+Ps/X7BNuv5B/0I6uoDwj0NJOo1KrVQqO7ggRXccklyTrWL4xMShjIou2I +# sbYnF67wXzVAq5Om4oe+LfzSDOzjcb6ms00gBo0OQaqwQ1BijyJ7NvDf80I1fW9O +# L76Kt0Wpc2zrGhzcHdb7upPrvxvSNNUvxK3sgw7YTt31410vpEp8yfBEl/hd8ZzA +# v47DCgJ5j1zm295s1RVZHNp6MoiQFVOECm4AwK2l28i+YER1JO4IplTH44uvzX9o +# RnJHaMvWzZEpozPy4jNO2DDqbcNs4zh7AWMhE1PWFVA+CHI/En5nASvCvLmuR/t8 +# q4bc8XR8QIZJQSp+2U6m2ldNAgMBAAGjggF+MIIBejAfBgNVHSUEGDAWBgorBgEE +# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQUNZJaEUGL2Guwt7ZOAu4efEYXedEw +# UAYDVR0RBEkwR6RFMEMxKTAnBgNVBAsTIE1pY3Jvc29mdCBPcGVyYXRpb25zIFB1 +# ZXJ0byBSaWNvMRYwFAYDVQQFEw0yMzAwMTIrNDY3NTk3MB8GA1UdIwQYMBaAFEhu +# ZOVQBdOCqhc3NyK1bajKdQKVMFQGA1UdHwRNMEswSaBHoEWGQ2h0dHA6Ly93d3cu +# bWljcm9zb2Z0LmNvbS9wa2lvcHMvY3JsL01pY0NvZFNpZ1BDQTIwMTFfMjAxMS0w +# Ny0wOC5jcmwwYQYIKwYBBQUHAQEEVTBTMFEGCCsGAQUFBzAChkVodHRwOi8vd3d3 +# Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2NlcnRzL01pY0NvZFNpZ1BDQTIwMTFfMjAx +# MS0wNy0wOC5jcnQwDAYDVR0TAQH/BAIwADANBgkqhkiG9w0BAQsFAAOCAgEAFkk3 +# uSxkTEBh1NtAl7BivIEsAWdgX1qZ+EdZMYbQKasY6IhSLXRMxF1B3OKdR9K/kccp +# kvNcGl8D7YyYS4mhCUMBR+VLrg3f8PUj38A9V5aiY2/Jok7WZFOAmjPRNNGnyeg7 +# l0lTiThFqE+2aOs6+heegqAdelGgNJKRHLWRuhGKuLIw5lkgx9Ky+QvZrn/Ddi8u +# TIgWKp+MGG8xY6PBvvjgt9jQShlnPrZ3UY8Bvwy6rynhXBaV0V0TTL0gEx7eh/K1 +# o8Miaru6s/7FyqOLeUS4vTHh9TgBL5DtxCYurXbSBVtL1Fj44+Od/6cmC9mmvrti +# yG709Y3Rd3YdJj2f3GJq7Y7KdWq0QYhatKhBeg4fxjhg0yut2g6aM1mxjNPrE48z +# 6HWCNGu9gMK5ZudldRw4a45Z06Aoktof0CqOyTErvq0YjoE4Xpa0+87T/PVUXNqf +# 7Y+qSU7+9LtLQuMYR4w3cSPjuNusvLf9gBnch5RqM7kaDtYWDgLyB42EfsxeMqwK +# WwA+TVi0HrWRqfSx2olbE56hJcEkMjOSKz3sRuupFCX3UroyYf52L+2iVTrda8XW +# esPG62Mnn3T8AuLfzeJFuAbfOSERx7IFZO92UPoXE1uEjL5skl1yTZB3MubgOA4F +# 8KoRNhviFAEST+nG8c8uIsbZeb08SeYQMqjVEmkwggd6MIIFYqADAgECAgphDpDS +# AAAAAAADMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMK +# V2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0 +# IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0 +# ZSBBdXRob3JpdHkgMjAxMTAeFw0xMTA3MDgyMDU5MDlaFw0yNjA3MDgyMTA5MDla +# MH4xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdS +# ZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMT +# H01pY3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTEwggIiMA0GCSqGSIb3DQEB +# AQUAA4ICDwAwggIKAoICAQCr8PpyEBwurdhuqoIQTTS68rZYIZ9CGypr6VpQqrgG +# OBoESbp/wwwe3TdrxhLYC/A4wpkGsMg51QEUMULTiQ15ZId+lGAkbK+eSZzpaF7S +# 35tTsgosw6/ZqSuuegmv15ZZymAaBelmdugyUiYSL+erCFDPs0S3XdjELgN1q2jz +# y23zOlyhFvRGuuA4ZKxuZDV4pqBjDy3TQJP4494HDdVceaVJKecNvqATd76UPe/7 +# 4ytaEB9NViiienLgEjq3SV7Y7e1DkYPZe7J7hhvZPrGMXeiJT4Qa8qEvWeSQOy2u +# M1jFtz7+MtOzAz2xsq+SOH7SnYAs9U5WkSE1JcM5bmR/U7qcD60ZI4TL9LoDho33 +# X/DQUr+MlIe8wCF0JV8YKLbMJyg4JZg5SjbPfLGSrhwjp6lm7GEfauEoSZ1fiOIl +# XdMhSz5SxLVXPyQD8NF6Wy/VI+NwXQ9RRnez+ADhvKwCgl/bwBWzvRvUVUvnOaEP +# 6SNJvBi4RHxF5MHDcnrgcuck379GmcXvwhxX24ON7E1JMKerjt/sW5+v/N2wZuLB +# l4F77dbtS+dJKacTKKanfWeA5opieF+yL4TXV5xcv3coKPHtbcMojyyPQDdPweGF +# RInECUzF1KVDL3SV9274eCBYLBNdYJWaPk8zhNqwiBfenk70lrC8RqBsmNLg1oiM +# CwIDAQABo4IB7TCCAekwEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFEhuZOVQ +# BdOCqhc3NyK1bajKdQKVMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1Ud +# DwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFHItOgIxkEO5FAVO +# 4eqnxzHRI4k0MFoGA1UdHwRTMFEwT6BNoEuGSWh0dHA6Ly9jcmwubWljcm9zb2Z0 +# LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y +# Mi5jcmwwXgYIKwYBBQUHAQEEUjBQME4GCCsGAQUFBzAChkJodHRwOi8vd3d3Lm1p +# Y3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y +# Mi5jcnQwgZ8GA1UdIASBlzCBlDCBkQYJKwYBBAGCNy4DMIGDMD8GCCsGAQUFBwIB +# FjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2RvY3MvcHJpbWFyeWNw +# cy5odG0wQAYIKwYBBQUHAgIwNB4yIB0ATABlAGcAYQBsAF8AcABvAGwAaQBjAHkA +# XwBzAHQAYQB0AGUAbQBlAG4AdAAuIB0wDQYJKoZIhvcNAQELBQADggIBAGfyhqWY +# 4FR5Gi7T2HRnIpsLlhHhY5KZQpZ90nkMkMFlXy4sPvjDctFtg/6+P+gKyju/R6mj +# 82nbY78iNaWXXWWEkH2LRlBV2AySfNIaSxzzPEKLUtCw/WvjPgcuKZvmPRul1LUd +# d5Q54ulkyUQ9eHoj8xN9ppB0g430yyYCRirCihC7pKkFDJvtaPpoLpWgKj8qa1hJ +# Yx8JaW5amJbkg/TAj/NGK978O9C9Ne9uJa7lryft0N3zDq+ZKJeYTQ49C/IIidYf +# wzIY4vDFLc5bnrRJOQrGCsLGra7lstnbFYhRRVg4MnEnGn+x9Cf43iw6IGmYslmJ +# aG5vp7d0w0AFBqYBKig+gj8TTWYLwLNN9eGPfxxvFX1Fp3blQCplo8NdUmKGwx1j +# NpeG39rz+PIWoZon4c2ll9DuXWNB41sHnIc+BncG0QaxdR8UvmFhtfDcxhsEvt9B +# xw4o7t5lL+yX9qFcltgA1qFGvVnzl6UJS0gQmYAf0AApxbGbpT9Fdx41xtKiop96 +# eiL6SJUfq/tHI4D1nvi/a7dLl+LrdXga7Oo3mXkYS//WsyNodeav+vyL6wuA6mk7 +# r/ww7QRMjt/fdW1jkT3RnVZOT7+AVyKheBEyIXrvQQqxP/uozKRdwaGIm1dxVk5I +# RcBCyZt2WwqASGv9eZ/BvW1taslScxMNelDNMYIZcjCCGW4CAQEwgZUwfjELMAkG +# A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQx +# HjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEoMCYGA1UEAxMfTWljcm9z +# b2Z0IENvZGUgU2lnbmluZyBQQ0EgMjAxMQITMwAAAlKLM6r4lfM52wAAAAACUjAN +# BglghkgBZQMEAgEFAKCBrjAZBgkqhkiG9w0BCQMxDAYKKwYBBAGCNwIBBDAcBgor +# BgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAvBgkqhkiG9w0BCQQxIgQgIhS3qoj1 +# UQcFwoqS3bsiKNlyzzwg84Jm8Gpt7FTE9REwQgYKKwYBBAGCNwIBDDE0MDKgFIAS +# AE0AaQBjAHIAbwBzAG8AZgB0oRqAGGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbTAN +# BgkqhkiG9w0BAQEFAASCAQAU2vbLS+IWCVvqWI8EdVkebP3f5WVbf6e2V2+jyA6R +# 8nmbHgS40FcyymsrI+vf1ru5gjMEfrAwY0VDsbWL//5bUuTKtgYGRTqmeCG33RO+ +# 9z/FoSCupd+n4Amfi/GVAiPAmg/Os4OBE8+V9Xld2B7og6/t/hi2osZrjHhUkKqc +# q2WS7lxnGNBTCmPJkNDTgIl4VXzgIBEfWNArUCb/V9NjGNPJ6qGezi0Q7OkXXMrC +# iGu0DwWnBwfcARE/oeU1T30DUU6La0t9bi1/cURAdVHRYufWWhIECnRuBD7pfjd/ +# Z6xY105pPZmIgi+f42tT7F1xVtUbMCaRxFcFE0Iqw+UOoYIW/DCCFvgGCisGAQQB +# gjcDAwExghboMIIW5AYJKoZIhvcNAQcCoIIW1TCCFtECAQMxDzANBglghkgBZQME +# AgEFADCCAVAGCyqGSIb3DQEJEAEEoIIBPwSCATswggE3AgEBBgorBgEEAYRZCgMB +# MDEwDQYJYIZIAWUDBAIBBQAEIBekHP5CnvvhbhNDrCF6H3oOJBPqZ9HDh40mWOYQ +# b45PAgZiFmzrUPEYEjIwMjIwMzEyMDMyMTUwLjgyWjAEgAIB9KCB0KSBzTCByjEL +# MAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1v +# bmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjElMCMGA1UECxMcTWlj +# cm9zb2Z0IEFtZXJpY2EgT3BlcmF0aW9uczEmMCQGA1UECxMdVGhhbGVzIFRTUyBF +# U046M0U3QS1FMzU5LUEyNUQxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1w +# IFNlcnZpY2WgghFUMIIHDDCCBPSgAwIBAgITMwAAAaDpu4y7DqLRegABAAABoDAN +# BgkqhkiG9w0BAQsFADB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3Rv +# bjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0 +# aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDAeFw0y +# MTEyMDIxOTA1MjNaFw0yMzAyMjgxOTA1MjNaMIHKMQswCQYDVQQGEwJVUzETMBEG +# A1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWlj +# cm9zb2Z0IENvcnBvcmF0aW9uMSUwIwYDVQQLExxNaWNyb3NvZnQgQW1lcmljYSBP +# cGVyYXRpb25zMSYwJAYDVQQLEx1UaGFsZXMgVFNTIEVTTjozRTdBLUUzNTktQTI1 +# RDElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2VydmljZTCCAiIwDQYJ +# KoZIhvcNAQEBBQADggIPADCCAgoCggIBAL/a4g5ocZ0A6PZi+GEjoLyIUCrvCuX/ +# lak+OPR8QcKLoi/H8jTYmyz8dWGR8ZMwa21HmNGGGslfJ1YOc6bNFTcHgbnblPun +# CQU0UFe6Yz/3yXmTRTZeJpn5u6Vcd7njHq6P/q/lUYW/7QeHV3KMZRM9pETBLvH3 +# xN7m0UcSKY9r4CwbaYz6f03B9BGN3UuIQJtwJkWSDBuWJD9qSIyvW1maOQNvG27Z +# pBxeMR8Odrwkf7BmZ927RfuTp0nlYZEXDNmIs4lbhCEASl6HZzWaZu0B8GeFI834 +# TnJQt+l9NPbBfxFsfpd8CDqxnHzz3rGrT6BQP2YfLxm2l0R4TVkDQeAHINbaskJt +# MAkCG3vUHtHPak9CaDlHf69IKuLwF5xIH5nybBgve45LdHpt5QEnuITis9L1YLXD +# V9lHsrjhlKZ7Z0j473+eGBvcwtiCbrPHceG0ugaEZU8v5agOQye33cgag7qQ0EIz +# Zf4KzbaqXa0+OQhHLHDEXpGxeH9AeeEomAHN8757zgjdNhsjSLb3MBMvrIc6/mwS +# zXNo0yKHbsjB9aDhDv7jQvt7ry4LrIPwRQSloPazZPn02FJq5PMIScCnlitKxxz0 +# xBUiLuD7kYB0LykK/7SJFrtAi9qVT72VaCTIAFT+eIUdY+PIagHjHcrOje1cHpoL +# fJn91NFekmdpAgMBAAGjggE2MIIBMjAdBgNVHQ4EFgQUcrkuUNgpTpG4kWwUL0TP +# C2GM0OgwHwYDVR0jBBgwFoAUn6cVXQBeYl2D9OXSZacbUzUZ6XIwXwYDVR0fBFgw +# VjBUoFKgUIZOaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jcmwvTWlj +# cm9zb2Z0JTIwVGltZS1TdGFtcCUyMFBDQSUyMDIwMTAoMSkuY3JsMGwGCCsGAQUF +# BwEBBGAwXjBcBggrBgEFBQcwAoZQaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3Br +# aW9wcy9jZXJ0cy9NaWNyb3NvZnQlMjBUaW1lLVN0YW1wJTIwUENBJTIwMjAxMCgx +# KS5jcnQwDAYDVR0TAQH/BAIwADATBgNVHSUEDDAKBggrBgEFBQcDCDANBgkqhkiG +# 9w0BAQsFAAOCAgEAMX3GAqv436yUCaVtwSpAGWkvk98EypwuRLrJJ4YmMb4spfda +# i/mnKCuEp+1dn3Q1hZR+0hmnN1izh6FHlGVoTd5i5taVw2XCwqRysZIMkprBtsMZ +# +87iH/UvXeyDrqE+JvruYb3oICpFUXRzkwDXCIqOOX/mB+tt00seC1ERDzMKlsrj +# 7rqXUV3S6n2bFw4QSmGEmvxTfCHAXCgr5An+TFaiAa18OJqrpHKgVaE/y4pItUNX +# 4xMRMdlvenY7CcFYTVbrTvVcMp3FGQ3+kARnXkTUsk2/2JijWXU/9F0X4jOkwsYM +# B/8+VW9NTDdWsf25qptiv6tHG2L5szdpvXC/2/fFEtz7A+ieJLFbanr0M3haj3og +# MVkiQtH4dxYKKodXAVeeCQJR90x7fGa84hdhGRMrQ/rA8t8L46zuh5VF4yPZMDVA +# wySBn6uE87TuJbs3nvMAG8yIclB0dEx4rcUGBHh9oS9ONQB0pFCQoVXza4TvDRQy +# ex4l9fsQsNj1PhpbHarASpqb2XsYdfgDZmbSefWhpr9jFzMnuAhURFIZI5YvAQzF +# wWoEY+b1BJDuiAwGflYfCR1NOSZqcFv9nZwOnEHF3W86PIibgE4WUuMHimK8KU7Z +# mSxYofuoFiWhhrTtTU7cLyO1vMZR0fIsJpUYFXwN8PmHx46fKOtoEbs801kwggdx +# MIIFWaADAgECAhMzAAAAFcXna54Cm0mZAAAAAAAVMA0GCSqGSIb3DQEBCwUAMIGI +# MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVk +# bW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTIwMAYDVQQDEylN +# aWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgMjAxMDAeFw0yMTA5 +# MzAxODIyMjVaFw0zMDA5MzAxODMyMjVaMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQI +# EwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3Nv +# ZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBD +# QSAyMDEwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA5OGmTOe0ciEL +# eaLL1yR5vQ7VgtP97pwHB9KpbE51yMo1V/YBf2xK4OK9uT4XYDP/XE/HZveVU3Fa +# 4n5KWv64NmeFRiMMtY0Tz3cywBAY6GB9alKDRLemjkZrBxTzxXb1hlDcwUTIcVxR +# MTegCjhuje3XD9gmU3w5YQJ6xKr9cmmvHaus9ja+NSZk2pg7uhp7M62AW36MEByd +# Uv626GIl3GoPz130/o5Tz9bshVZN7928jaTjkY+yOSxRnOlwaQ3KNi1wjjHINSi9 +# 47SHJMPgyY9+tVSP3PoFVZhtaDuaRr3tpK56KTesy+uDRedGbsoy1cCGMFxPLOJi +# ss254o2I5JasAUq7vnGpF1tnYN74kpEeHT39IM9zfUGaRnXNxF803RKJ1v2lIH1+ +# /NmeRd+2ci/bfV+AutuqfjbsNkz2K26oElHovwUDo9Fzpk03dJQcNIIP8BDyt0cY +# 7afomXw/TNuvXsLz1dhzPUNOwTM5TI4CvEJoLhDqhFFG4tG9ahhaYQFzymeiXtco +# dgLiMxhy16cg8ML6EgrXY28MyTZki1ugpoMhXV8wdJGUlNi5UPkLiWHzNgY1GIRH +# 29wb0f2y1BzFa/ZcUlFdEtsluq9QBXpsxREdcu+N+VLEhReTwDwV2xo3xwgVGD94 +# q0W29R6HXtqPnhZyacaue7e3PmriLq0CAwEAAaOCAd0wggHZMBIGCSsGAQQBgjcV +# AQQFAgMBAAEwIwYJKwYBBAGCNxUCBBYEFCqnUv5kxJq+gpE8RjUpzxD/LwTuMB0G +# A1UdDgQWBBSfpxVdAF5iXYP05dJlpxtTNRnpcjBcBgNVHSAEVTBTMFEGDCsGAQQB +# gjdMg30BATBBMD8GCCsGAQUFBwIBFjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20v +# cGtpb3BzL0RvY3MvUmVwb3NpdG9yeS5odG0wEwYDVR0lBAwwCgYIKwYBBQUHAwgw +# GQYJKwYBBAGCNxQCBAweCgBTAHUAYgBDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB +# /wQFMAMBAf8wHwYDVR0jBBgwFoAU1fZWy4/oolxiaNE9lJBb186aGMQwVgYDVR0f +# BE8wTTBLoEmgR4ZFaHR0cDovL2NybC5taWNyb3NvZnQuY29tL3BraS9jcmwvcHJv +# ZHVjdHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYtMjMuY3JsMFoGCCsGAQUFBwEBBE4w +# TDBKBggrBgEFBQcwAoY+aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0 +# cy9NaWNSb29DZXJBdXRfMjAxMC0wNi0yMy5jcnQwDQYJKoZIhvcNAQELBQADggIB +# AJ1VffwqreEsH2cBMSRb4Z5yS/ypb+pcFLY+TkdkeLEGk5c9MTO1OdfCcTY/2mRs +# fNB1OW27DzHkwo/7bNGhlBgi7ulmZzpTTd2YurYeeNg2LpypglYAA7AFvonoaeC6 +# Ce5732pvvinLbtg/SHUB2RjebYIM9W0jVOR4U3UkV7ndn/OOPcbzaN9l9qRWqveV +# tihVJ9AkvUCgvxm2EhIRXT0n4ECWOKz3+SmJw7wXsFSFQrP8DJ6LGYnn8AtqgcKB +# GUIZUnWKNsIdw2FzLixre24/LAl4FOmRsqlb30mjdAy87JGA0j3mSj5mO0+7hvoy +# GtmW9I/2kQH2zsZ0/fZMcm8Qq3UwxTSwethQ/gpY3UA8x1RtnWN0SCyxTkctwRQE +# cb9k+SS+c23Kjgm9swFXSVRk2XPXfx5bRAGOWhmRaw2fpCjcZxkoJLo4S5pu+yFU +# a2pFEUep8beuyOiJXk+d0tBMdrVXVAmxaQFEfnyhYWxz/gq77EFmPWn9y8FBSX5+ +# k77L+DvktxW/tM4+pTFRhLy/AsGConsXHRWJjXD+57XQKBqJC4822rpM+Zv/Cuk0 +# +CQ1ZyvgDbjmjJnW4SLq8CdCPSWU5nR0W2rRnj7tfqAxM328y+l7vzhwRNGQ8cir +# Ooo6CGJ/2XBjU02N7oJtpQUQwXEGahC0HVUzWLOhcGbyoYICyzCCAjQCAQEwgfih +# gdCkgc0wgcoxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYD +# VQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJTAj +# BgNVBAsTHE1pY3Jvc29mdCBBbWVyaWNhIE9wZXJhdGlvbnMxJjAkBgNVBAsTHVRo +# YWxlcyBUU1MgRVNOOjNFN0EtRTM1OS1BMjVEMSUwIwYDVQQDExxNaWNyb3NvZnQg +# VGltZS1TdGFtcCBTZXJ2aWNloiMKAQEwBwYFKw4DAhoDFQATBriNaNpxs5hT773n +# J0nuFIKLmKCBgzCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5n +# dG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9y +# YXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwMA0G +# CSqGSIb3DQEBBQUAAgUA5dYCvDAiGA8yMDIyMDMxMjAxMTc0OFoYDzIwMjIwMzEz +# MDExNzQ4WjB0MDoGCisGAQQBhFkKBAExLDAqMAoCBQDl1gK8AgEAMAcCAQACAgCw +# MAcCAQACAhGuMAoCBQDl11Q8AgEAMDYGCisGAQQBhFkKBAIxKDAmMAwGCisGAQQB +# hFkKAwKgCjAIAgEAAgMHoSChCjAIAgEAAgMBhqAwDQYJKoZIhvcNAQEFBQADgYEA +# H1WmVFLLRfx8XuVuVC/CzptlQCI5EG0ppvZ1it5m9CxMeTkVJDU84hnn9X1bl28q +# RoLrKIFHEdL8NxTQqs7U3qbouKFyFPFB+O62aKWhtN8w0MAnbN9H6ERv9ymKY/cS +# XMm9XbGlE7mir054levW/KWMtMQz8Vynxi1nNruNGH4xggQNMIIECQIBATCBkzB8 +# MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVk +# bW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1N +# aWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMAITMwAAAaDpu4y7DqLRegABAAAB +# oDANBglghkgBZQMEAgEFAKCCAUowGgYJKoZIhvcNAQkDMQ0GCyqGSIb3DQEJEAEE +# MC8GCSqGSIb3DQEJBDEiBCA6yg5Q9T8Zf3uJpxpGStuZknGB/oQrDzqIf18z6csZ +# JTCB+gYLKoZIhvcNAQkQAi8xgeowgecwgeQwgb0EIC9HijxoZQQiEi3dES+zHT6y +# +czpaJqBrlI9oriDr7TTMIGYMIGApH4wfDELMAkGA1UEBhMCVVMxEzARBgNVBAgT +# Cldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29m +# dCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENB +# IDIwMTACEzMAAAGg6buMuw6i0XoAAQAAAaAwIgQgNtOO732G/6Ao4oRTpGrp3/oo +# gs/bdXoL/1Exes00Z+owDQYJKoZIhvcNAQELBQAEggIAVqfo8sV5o++I1u8kGl2I +# R38dS9Y7FY8Tx7OcnzcWH6lwksT/66VKkH+2VxlgLUYdA983c4oBzYkCQ73cOn+F +# dfqhCj7tsPwinK7yYMlRr64GJdLMmRlpg0BQoigPKFu1tgCMj9EMQv9gw/JuG+CX +# 4iSNXFRy414//W42BF9Oi9pht46EqEth014nUjXQq9ADBqF1SoWWhsqxm8x4XUIz +# 95Bn0zBMiBmoz7dqZ9k1OcQPhRmPBqlFfIa80uxSyWC1+ZAGaFl1jn+lZ/8mNAha +# VeTwz0q99J41idqkzeIMhN7gE7u06N/JqpMzCqAglDaFvQNs9gGQNSwMl07tR86o +# Pu8cSzqOoLzZ2lNKPMD70Il74ucqaOn9RvkfS99UCec3W0IX2Q4UFqFbWL4juVNl +# CSdkDxbhaTmDc+oBimgWBlTh70nqBlsvanu9Q1Q/mh2KzCwUZ20dbgurFAyb5tSO +# XGymwPJ09Ae+9I3Q1P8clWr7ZgCRqhHYpqO46iuyvjG1WL0qCkyFRiWD05Nlqe/7 +# DsXgjkPoqmH4di5I6a8sFE1p3sX73H7esvc8KeQEX3rPwQKinodk72tCPq0OGgfV +# Sp2OZzJSf5klmK0ig+x78AkHu/gWdJFLVeghAekXQ9X2/gGLpxKuSI0c9wR8Qt84 +# gOroSsuAmRkqDbQNW5L4d7o= +# SIG # End signature block + diff --git a/unsupported/microsoft-compliance/1.0.0/yh2.psm1 b/unsupported/microsoft-compliance/1.0.0/yh2.psm1 new file mode 100644 index 00000000..fd1852d8 --- /dev/null +++ b/unsupported/microsoft-compliance/1.0.0/yh2.psm1 @@ -0,0 +1,1169 @@ +# Import the REST module so that the EXO* cmdlets are present before Connect-ExchangeOnline in the powershell instance. +Write-Host "Windows: $IsWindows" + +$RestModule = "Microsoft.Exchange.Management.RestApiClient.dll" +$RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestModule) +Import-Module $RestModulePath + +$ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll" +$ExoPowershellModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule) +Import-Module $ExoPowershellModulePath + + +Write-Host "PSEdition: $PSEdition" + +############# Helper Functions Begin ############# + + <# + Details to be printed on the console when the Connect-ExchangeOnline function is run + #> + function Print-Details + { + if ($UseRPSSession) + { + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "The module allows access to all existing remote PowerShell (V1) cmdlets in addition to the 9 new, faster, and more reliable cmdlets." + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "| Old Cmdlets | New/Reliable/Faster Cmdlets |" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "| Get-CASMailbox | Get-EXOCASMailbox |" + Write-Host -ForegroundColor Yellow "| Get-Mailbox | Get-EXOMailbox |" + Write-Host -ForegroundColor Yellow "| Get-MailboxFolderPermission | Get-EXOMailboxFolderPermission |" + Write-Host -ForegroundColor Yellow "| Get-MailboxFolderStatistics | Get-EXOMailboxFolderStatistics |" + Write-Host -ForegroundColor Yellow "| Get-MailboxPermission | Get-EXOMailboxPermission |" + Write-Host -ForegroundColor Yellow "| Get-MailboxStatistics | Get-EXOMailboxStatistics |" + Write-Host -ForegroundColor Yellow "| Get-MobileDeviceStatistics | Get-EXOMobileDeviceStatistics |" + Write-Host -ForegroundColor Yellow "| Get-Recipient | Get-EXORecipient |" + Write-Host -ForegroundColor Yellow "| Get-RecipientPermission | Get-EXORecipientPermission |" + Write-Host -ForegroundColor Yellow "|--------------------------------------------------------------------------|" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "To get additional information, run: Get-Help Connect-ExchangeOnline or check https://aka.ms/exops-docs" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "Send your product improvement suggestions and feedback to exocmdletpreview@service.microsoft.com. For issues related to the module, contact Microsoft support. Don't use the feedback alias for problems or support issues." + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "" + + } + else + { + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "This version of EXO PowerShell V2 module contains new REST API backed cmdlets which doesn't require Windows Remote PowerShell for client-server communication." + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "You can now run those cmdlets after turning off WinRM Basic Auth in your client machine and thus making it more secure. Read more here - https://aka.ms/exov2-securemode" + Write-Host -ForegroundColor Yellow "" + Write-Host -ForegroundColor Yellow "You can share your feedback and suggestions to exocmdletpreview@service.microsoft.com" + Write-Host -ForegroundColor Yellow "----------------------------------------------------------------------------------------" + Write-Host -ForegroundColor Yellow "" + + } + + } + + <# + Get the ExchangeOnlineManagement module version. + Same function is present in the autogen module. Both the codes should be kept in sync. + #> + function Get-ModuleVersion + { + try + { + # Return the already computed version info if available. + if ($script:ModuleVersion -ne $null -and $script:ModuleVersion -ne '') + { + Write-Verbose "Returning precomputed version info: $script:ModuleVersion" + return $script:ModuleVersion; + } + + $exoModule = Get-Module ExchangeOnlineManagement + # Get the module version from the loaded module info. + $script:ModuleVersion = $exoModule.Version.ToString() + + # Look for prerelease information from the corresponding module manifest. + $exoModuleRoot = (Get-Item $exoModule.Path).Directory.Parent.FullName + + $exoModuleManifestPath = Join-Path -Path $exoModuleRoot -ChildPath ExchangeOnlineManagement.psd1 + $isExoModuleManifestPathValid = Test-Path -Path $exoModuleManifestPath + if ($isExoModuleManifestPathValid -ne $true) + { + # Could be a local debug build import for testing. Skip extracting prerelease info for those. + Write-Verbose "Module manifest path invalid, path: $exoModuleManifestPath, skipping extracting prerelease info" + return $script:ModuleVersion + } + + $exoModuleManifestContent = Get-Content -Path $exoModuleManifestPath + $preReleaseInfo = $exoModuleManifestContent -match "Prerelease = '(.*)'" + if ($preReleaseInfo -ne $null) + { + $script:ModuleVersion = "{0}-{1}" -f $exoModule.Version.ToString(),$preReleaseInfo[0].Split('=')[1].Trim().Trim("'") + } + + Write-Verbose "Computed version info: $script:ModuleVersion" + return $script:ModuleVersion + } + catch + { + return [string]::Empty + } + } + + <# + .Synopsis Validates a given Uri + #> + function Test-Uri + { + [CmdletBinding()] + [OutputType([bool])] + Param + ( + # Uri to be validated + [Parameter(Mandatory=$true, ValueFromPipelineByPropertyName=$true, Position=0)] + [string] + $UriString + ) + + [Uri]$uri = $UriString -as [Uri] + + $uri.AbsoluteUri -ne $null -and $uri.Scheme -eq 'https' + } + + <# + .Synopsis Is Cloud Shell Environment + #> + function global:IsCloudShellEnvironment() + { + return [Microsoft.Exchange.Management.AdminApiProvider.Utility]::IsCloudShellEnvironment(); + } + + <# + .Synopsis Override Get-PSImplicitRemotingSession function for reconnection + #> + function global:UpdateImplicitRemotingHandler() + { + # Remote Powershell Sessions created by the ExchangeOnlineManagement module are given a name that starts with "ExchangeOnlineInternalSession". + # Only modules from such sessions should be modified here, to prevent modfification of RPS tmp_* modules created by running the New-PSSession cmdlet directly, or when connecting to exchange on-prem tenants. + $existingPSSession = Get-PSSession | Where-Object {$_.ConfigurationName -like "Microsoft.Exchange" -and $_.Name -like "ExchangeOnlineInternalSession*"} + + if ($existingPSSession.count -gt 0) + { + foreach ($session in $existingPSSession) + { + $module = Get-Module $session.CurrentModuleName + if ($module -eq $null) + { + continue + } + + [bool]$moduleProcessed = $false + [string] $moduleUrl = $module.Description + [int] $queryStringIndex = $moduleUrl.IndexOf("?") + + if ($queryStringIndex -gt 0) + { + $moduleUrl = $moduleUrl.SubString(0,$queryStringIndex) + } + + if ($moduleUrl.EndsWith("/PowerShell-LiveId", [StringComparison]::OrdinalIgnoreCase) -or $moduleUrl.EndsWith("/PowerShell", [StringComparison]::OrdinalIgnoreCase)) + { + & $module { ${function:Get-PSImplicitRemotingSession} = ` + { + param( + [Parameter(Mandatory = $true, Position = 0)] + [string] + $commandName + ) + + $shouldRemoveCurrentSession = $false; + # Clear any left over PS tmp modules + if (($script:PSSession -ne $null) -and ($script:PSSession.PreviousModuleName -ne $null) -and ($script:PSSession.PreviousModuleName -ne $script:MyModule.Name)) + { + $null = Remove-Module -Name $script:PSSession.PreviousModuleName -ErrorAction SilentlyContinue + $script:PSSession.PreviousModuleName = $null + } + + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened')) + { + Set-PSImplicitRemotingSession ` + (& $script:GetPSSession ` + -InstanceId $script:PSSession.InstanceId.Guid ` + -ErrorAction SilentlyContinue ) + } + if ($script:PSSession -ne $null) + { + if ($script:PSSession.Runspace.RunspaceStateInfo.State -eq 'Disconnected') + { + # If we are handed a disconnected session, try re-connecting it before creating a new session. + Set-PSImplicitRemotingSession ` + (& $script:ConnectPSSession ` + -Session $script:PSSession ` + -ErrorAction SilentlyContinue) + } + else + { + # Import the module once more to ensure that Test-ActiveToken is present + Import-Module $global:_EXO_ModulePath -Cmdlet Test-ActiveToken; + + # If there is no active token run the new session flow + $hasActiveToken = Test-ActiveToken -TokenExpiryTime $script:PSSession.TokenExpiryTime + $sessionIsOpened = $script:PSSession.Runspace.RunspaceStateInfo.State -eq 'Opened' + if (($hasActiveToken -eq $false) -or ($sessionIsOpened -ne $true)) + { + #If there is no active user token or opened session then ensure that we remove the old session + $shouldRemoveCurrentSession = $true; + } + } + } + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened') -or ($shouldRemoveCurrentSession -eq $true)) + { + # Import the module once more to ensure that New-ExoPSSession is present + Import-Module $global:_EXO_ModulePath -Cmdlet New-ExoPSSession; + + Write-PSImplicitRemotingMessage ('Creating a new Remote PowerShell session using Modern Authentication for implicit remoting of "{0}" command ...' -f $commandName) + $session = New-ExoPSSession -PreviousSession $script:PSSession + + if ($session -ne $null) + { + if ($shouldRemoveCurrentSession -eq $true) + { + Remove-PSSession $script:PSSession + } + + # Import the latest session to ensure that the next cmdlet call would occur on the new PSSession instance. + $PSSessionModuleInfo = Import-PSSession $session -AllowClobber -DisableNameChecking -CommandName $script:MyModule.CommandName -FormatTypeName $script:MyModule.FormatTypeName + + # Add the name of the module to clean up in case of removing the broken session + $session | Add-Member -NotePropertyName "CurrentModuleName" -NotePropertyValue $PSSessionModuleInfo.Name + + $CurrentModule = Import-Module $PSSessionModuleInfo.Path -Global -DisableNameChecking -Prefix $script:MyModule.ModulePrefix -PassThru + $CurrentModule | Add-Member -NotePropertyName "ModulePrefix" -NotePropertyValue $script:MyModule.ModulePrefix + $CurrentModule | Add-Member -NotePropertyName "CommandName" -NotePropertyValue $script:MyModule.CommandName + $CurrentModule | Add-Member -NotePropertyName "FormatTypeName" -NotePropertyValue $script:MyModule.FormatTypeName + + $session | Add-Member -NotePropertyName "PreviousModuleName" -NotePropertyValue $script:MyModule.Name + + UpdateImplicitRemotingHandler + $script:PSSession = $session + } + } + if (($script:PSSession -eq $null) -or ($script:PSSession.Runspace.RunspaceStateInfo.State -ne 'Opened')) + { + throw 'No session has been associated with this implicit remoting module' + } + + return [Management.Automation.Runspaces.PSSession]$script:PSSession + }} + } + } + } + } + + <# + .SYNOPSIS Extract organization name from UserPrincipalName + #> + function Get-OrgNameFromUPN + { + param([string] $UPN) + $fields = $UPN -split '@' + return $fields[-1] + } + + <# + .SYNOPSIS Get the command from the given module + #> + function global:Get-WrappedCommand + { + param( + [string] $CommandName, + [string] $ModuleName, + [string] $CommandType) + + $cmd = (Get-Module $moduleName).ExportedFunctions[$CommandName] + return $cmd + } + +############# Helper Functions End ############# + +###### Begin Main ###### + +$EOPConnectionInProgress = $false +function Connect-ExchangeOnline +{ + [CmdletBinding()] + param( + + # Connection Uri for the Remote PowerShell endpoint + [string] $ConnectionUri = '', + + # Azure AD Authorization endpoint Uri that can issue the OAuth2 access tokens + [string] $AzureADAuthorizationEndpointUri = '', + + # Exchange Environment name + [Microsoft.Exchange.Management.RestApiClient.ExchangeEnvironment] $ExchangeEnvironmentName = 'O365Default', + + # PowerShell session options to be used when opening the Remote PowerShell session + [System.Management.Automation.Remoting.PSSessionOption] $PSSessionOption = $null, + + # Switch to bypass use of mailbox anchoring hint. + [switch] $BypassMailboxAnchoring = $false, + + # Delegated Organization Name + [string] $DelegatedOrganization = '', + + # Prefix + [string] $Prefix = '', + + # Show Banner of Exchange cmdlets Mapping and recent updates + [switch] $ShowBanner = $true, + + #Cmdlets to Import for rps cmdlets , by default it would bring all + [string[]] $CommandName = @("*"), + + #The way the output objects would be printed on the console + [string[]] $FormatTypeName = @("*"), + + # Use Remote PowerShell Session based connection + [switch] $UseRPSSession = $false + ) + DynamicParam + { + if (($isCloudShell = IsCloudShellEnvironment) -eq $false) + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # User Principal Name or email address of the user + $UserPrincipalName = New-Object System.Management.Automation.RuntimeDefinedParameter('UserPrincipalName', [string], $attributeCollection) + $UserPrincipalName.Value = '' + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + # Certificate + $Certificate = New-Object System.Management.Automation.RuntimeDefinedParameter('Certificate', [System.Security.Cryptography.X509Certificates.X509Certificate2], $attributeCollection) + $Certificate.Value = $null + + # Certificate Path + $CertificateFilePath = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateFilePath', [string], $attributeCollection) + $CertificateFilePath.Value = '' + + # Certificate Password + $CertificatePassword = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificatePassword', [System.Security.SecureString], $attributeCollection) + $CertificatePassword.Value = $null + + # Certificate Thumbprint + #$CertificateThumbprint = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateThumbprint', [string], $attributeCollection) + #$CertificateThumbprint.Value = '' + + # Application Id + $AppId = New-Object System.Management.Automation.RuntimeDefinedParameter('AppId', [string], $attributeCollection) + $AppId.Value = '' + + # Organization + $Organization = New-Object System.Management.Automation.RuntimeDefinedParameter('Organization', [string], $attributeCollection) + $Organization.Value = '' + + # Switch to collect telemetry on command execution. + $EnableErrorReporting = New-Object System.Management.Automation.RuntimeDefinedParameter('EnableErrorReporting', [switch], $attributeCollection) + $EnableErrorReporting.Value = $false + + # Where to store EXO command telemetry data. By default telemetry is stored in the directory "%TEMP%/EXOTelemetry" in the file : EXOCmdletTelemetry-yyyymmdd-hhmmss.csv. + $LogDirectoryPath = New-Object System.Management.Automation.RuntimeDefinedParameter('LogDirectoryPath', [string], $attributeCollection) + $LogDirectoryPath.Value = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), "EXOCmdletTelemetry") + + # Create a new attribute and valiate set against the LogLevel + $LogLevelAttribute = New-Object System.Management.Automation.ParameterAttribute + $LogLevelAttribute.Mandatory = $false + $LogLevelAttributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $LogLevelAttributeCollection.Add($LogLevelAttribute) + $LogLevelList = @([Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::Default, [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::All) + $ValidateSet = New-Object System.Management.Automation.ValidateSetAttribute($LogLevelList) + $LogLevel = New-Object System.Management.Automation.RuntimeDefinedParameter('LogLevel', [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel], $LogLevelAttributeCollection) + $LogLevel.Attributes.Add($ValidateSet) + +# EXO params start + + # Switch to track perfomance + $TrackPerformance = New-Object System.Management.Automation.RuntimeDefinedParameter('TrackPerformance', [bool], $attributeCollection) + $TrackPerformance.Value = $false + + # Flag to enable or disable showing the number of objects written + $ShowProgress = New-Object System.Management.Automation.RuntimeDefinedParameter('ShowProgress', [bool], $attributeCollection) + $ShowProgress.Value = $false + + # Switch to enable/disable Multi-threading in the EXO cmdlets + $UseMultithreading = New-Object System.Management.Automation.RuntimeDefinedParameter('UseMultithreading', [bool], $attributeCollection) + $UseMultithreading.Value = $true + + # Pagesize Param + $PageSize = New-Object System.Management.Automation.RuntimeDefinedParameter('PageSize', [uint32], $attributeCollection) + $PageSize.Value = 1000 + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + # Switch to CmdInline parameters + $InlineCredential = New-Object System.Management.Automation.RuntimeDefinedParameter('InlineCredential', [switch], $attributeCollection) + $InlineCredential.Value = $false + +# EXO params end + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('UserPrincipalName', $UserPrincipalName) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('Certificate', $Certificate) + $paramDictionary.Add('CertificateFilePath', $CertificateFilePath) + $paramDictionary.Add('CertificatePassword', $CertificatePassword) + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + #$paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint) + $paramDictionary.Add('AppId', $AppId) + $paramDictionary.Add('Organization', $Organization) + $paramDictionary.Add('EnableErrorReporting', $EnableErrorReporting) + $paramDictionary.Add('LogDirectoryPath', $LogDirectoryPath) + $paramDictionary.Add('LogLevel', $LogLevel) + $paramDictionary.Add('TrackPerformance', $TrackPerformance) + $paramDictionary.Add('ShowProgress', $ShowProgress) + $paramDictionary.Add('UseMultithreading', $UseMultithreading) + $paramDictionary.Add('PageSize', $PageSize) + + Write-Host "PSEdition: $PSEdition" + Write-Host "Windows: $IsWindows" + if($PSEdition -eq 'Core') + { + $paramDictionary.Add('Device', $Device) + $paramDictionary.Add('InlineCredential', $InlineCredential); + # We do not want to expose certificate thumprint in Linux as it is not feasible there. + if($IsWindows) + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + } + else + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + + return $paramDictionary + } + else + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + # Switch to collect telemetry on command execution. + $EnableErrorReporting = New-Object System.Management.Automation.RuntimeDefinedParameter('EnableErrorReporting', [switch], $attributeCollection) + $EnableErrorReporting.Value = $false + + # Where to store EXO command telemetry data. By default telemetry is stored in the directory "%TEMP%/EXOTelemetry" in the file : EXOCmdletTelemetry-yyyymmdd-hhmmss.csv. + $LogDirectoryPath = New-Object System.Management.Automation.RuntimeDefinedParameter('LogDirectoryPath', [string], $attributeCollection) + $LogDirectoryPath.Value = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), "EXOCmdletTelemetry") + + # Create a new attribute and valiate set against the LogLevel + $LogLevelAttribute = New-Object System.Management.Automation.ParameterAttribute + $LogLevelAttribute.Mandatory = $false + $LogLevelAttributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $LogLevelAttributeCollection.Add($LogLevelAttribute) + $LogLevelList = @([Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::Default, [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel]::All) + $ValidateSet = New-Object System.Management.Automation.ValidateSetAttribute($LogLevelList) + $LogLevel = New-Object System.Management.Automation.RuntimeDefinedParameter('LogLevel', [Microsoft.Online.CSE.RestApiPowerShellModule.Instrumentation.LogLevel], $LogLevelAttributeCollection) + $LogLevel.Attributes.Add($ValidateSet) + + # Switch to CmdInline parameters + $InlineCredential = New-Object System.Management.Automation.RuntimeDefinedParameter('InlineCredential', [switch], $attributeCollection) + $InlineCredential.Value = $false + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('Device', $Device) + $paramDictionary.Add('EnableErrorReporting', $EnableErrorReporting) + $paramDictionary.Add('LogDirectoryPath', $LogDirectoryPath) + $paramDictionary.Add('LogLevel', $LogLevel) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('InlineCredential', $InlineCredential) + return $paramDictionary + } + } + process { + + # Validate parameters + if (($ConnectionUri -ne '') -and (-not (Test-Uri $ConnectionUri))) + { + throw "Invalid ConnectionUri parameter '$ConnectionUri'" + } + if (($AzureADAuthorizationEndpointUri -ne '') -and (-not (Test-Uri $AzureADAuthorizationEndpointUri))) + { + throw "Invalid AzureADAuthorizationEndpointUri parameter '$AzureADAuthorizationEndpointUri'" + } + if (($Prefix -ne '')) + { + if ($Prefix -notmatch '^[a-z0-9]+$') + { + throw "Use of any special characters in the Prefix string is not supported." + } + if ($Prefix -eq 'EXO') + { + throw "Prefix 'EXO' is a reserved Prefix, please use a different prefix." + } + } + + # Keep track of error count at beginning. + $errorCountAtStart = $global:Error.Count; + try + { + $moduleVersion = Get-ModuleVersion + + Write-Verbose "ExchangeEnvironment : $ExchangeEnvironmentName" + Write-Verbose "ConnectionUri : $ConnectionUri" + Write-Verbose "AzureADAuthorizationEndpointUri : $AzureADAuthorizationEndpointUri" + Write-Verbose "DelegatedOrganization : $DelegatedOrganization" + Write-Verbose "Prefix : $Prefix" + Write-Verbose ("FormatTypeName :" + [String]::Join(' ,', $FormatTypeName)) + Write-Verbose ("CommandName :" + [String]::Join(' ,', $CommandName)) + Write-Verbose ("UPN: " + $UserPrincipalName.Value) + Write-Verbose "ModuleVersion: $moduleVersion" + + $ConnectionContext = Get-ConnectionContext -ExchangeEnvironmentName $ExchangeEnvironmentName -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -UserPrincipalName $UserPrincipalName.Value -PSSessionOption $PSSessionOption -Credential $Credential.Value -BypassMailboxAnchoring:$BypassMailboxAnchoring -DelegatedOrg $DelegatedOrganization -Certificate $Certificate.Value -CertificateFilePath $CertificateFilePath.Value -CertificatePassword $CertificatePassword.Value -CertificateThumbprint $CertificateThumbprint.Value -AppId $AppId.Value -Organization $Organization.Value -Device:$Device.Value -InlineCredential:$InlineCredential.Value -CommandName $CommandName -FormatTypeName $FormatTypeName -Prefix $Prefix -PageSize $PageSize.Value -ExoModuleVersion:$moduleVersion + Write-Verbose("Got connectioncontext " + $ConnectionContext) + + Write-Verbose "Context done" + + if ($isCloudShell -eq $false) + { + $global:_EXO_EnableErrorReporting = $EnableErrorReporting.Value; + } + + if ($ShowBanner -eq $true) + { + try + { + $BannerContent = Get-EXOBanner -ConnectionContext:$ConnectionContext -IsRPSSession:$UseRPSSession.IsPresent + Write-Host -ForegroundColor Yellow $BannerContent + } + catch + { + Write-Verbose "Failed to fetch banner content from server, using the default banner content. Reason: $_" + Print-Details; + } + } + + if (($ConnectionUri -ne '') -and ($AzureADAuthorizationEndpointUri -eq '')) + { + Write-Information "Using ConnectionUri:'$ConnectionUri', in the environment:'$ExchangeEnvironmentName'." + } + if (($AzureADAuthorizationEndpointUri -ne '') -and ($ConnectionUri -eq '')) + { + Write-Information "Using AzureADAuthorizationEndpointUri:'$AzureADAuthorizationEndpointUri', in the environment:'$ExchangeEnvironmentName'." + } + + $ImportedModuleName = ''; + $LogModuleDirectoryPath = [System.IO.Path]::GetTempPath(); + + Write-Verbose "Pre UseRPS" + + if ($UseRPSSession -eq $true) + { + $ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll"; + $ModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule); + + Write-Verbose("Starting import of " + $ModulePath) + Import-Module $ModulePath; + Write-Verbose "Imported all" + #cat $ModulePath + + $global:_EXO_ModulePath = $ModulePath; + + $PSSession = New-ExoPSSession -ConnectionContext $ConnectionContext + #$PSSession = New-PSSession -ConnectionContext $ConnectionContext + Write-Verbose("Finished PSSession setup before catch") + if ($PSSession -ne $null) + { + $PSSessionModuleInfo = Import-PSSession $PSSession -AllowClobber -DisableNameChecking -CommandName $CommandName -FormatTypeName $FormatTypeName + + # Add the name of the module to clean up in case of removing the broken session + $PSSession | Add-Member -NotePropertyName "CurrentModuleName" -NotePropertyValue $PSSessionModuleInfo.Name + + # Import the above module globally. This is needed as with using psm1 files, + # any module which is dynamically loaded in the nested module does not reflect globally. + $CurrentModule = Import-Module $PSSessionModuleInfo.Path -Global -DisableNameChecking -Prefix $Prefix -PassThru + $CurrentModule | Add-Member -NotePropertyName "ModulePrefix" -NotePropertyValue $Prefix + $CurrentModule | Add-Member -NotePropertyName "CommandName" -NotePropertyValue $CommandName + $CurrentModule | Add-Member -NotePropertyName "FormatTypeName" -NotePropertyValue $FormatTypeName + + UpdateImplicitRemotingHandler + + # Import the REST module + $RestPowershellModule = "Microsoft.Exchange.Management.RestApiClient.dll"; + $RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestPowershellModule); + Import-Module $RestModulePath -Cmdlet Set-ExoAppSettings; + + $ImportedModuleName = $PSSessionModuleInfo.Name; + } + } + else + { + # Download the new web based EXOModule + Write-Verbose("Pre exomodule: " + $ConnectionContext) + #Get-Help New-EXOModule + #Get-Item New-EXOModule + + #$ImportedModule = New-EXOModule -ConnectionContext $ConnectionContext + (Get-Module -ListAvailable New-exomodule*).path + Write-Verbose "DOne with exomod" + $ImportedModule = New-exomodule -ConnectionContext $ConnectionContext + if ($null -ne $ImportedModule) + { + Write-Verbose "Got imported module - null" + + $ImportedModuleName = $ImportedModule.Name; + $LogModuleDirectoryPath = $ImportedModule.ModuleBase + + Write-Verbose "AutoGen EXOModule created at $($ImportedModule.ModuleBase)" + if ($null -ne $HelpFileNames -and $HelpFileNames -is [array] -and $HelpFileNames.Count -gt 0) + { + Get-HelpFiles -HelpFileNames $HelpFileNames -ConnectionContext $ConnectionContext -ImportedModule $ImportedModule -EnableErrorReporting:$EnableErrorReporting.Value + } + else + { + Write-Warning "Get-help cmdlet might not work. Please reconnect if you want to access that functionality." + } + } + else + { + Write-Verbose "Got imported module error - run again?" + throw "Module could not be correctly formed. Please run Connect-ExchangeOnline again." + } + } + + Write-Verbose "Pre error reporting" + + # If we are configured to collect telemetry, add telemetry wrappers. + if ($EnableErrorReporting.Value -eq $true) + { + $FilePath = Add-EXOClientTelemetryWrapper -Organization (Get-OrgNameFromUPN -UPN $UserPrincipalName.Value) -PSSessionModuleName $ImportedModuleName -LogDirectoryPath $LogDirectoryPath.Value -LogModuleDirectoryPath $LogModuleDirectoryPath + $global:_EXO_TelemetryFilePath = $FilePath[0] + Import-Module $FilePath[1] -DisableNameChecking -Global + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Connect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid + + if ($EOPConnectionInProgress -eq $false) + { + # Set the AppSettings + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -EnableErrorReporting $true -LogDirectoryPath $LogDirectoryPath.Value -LogLevel $LogLevel.Value + } + } + else + { + if ($EOPConnectionInProgress -eq $false) + { + # Set the AppSettings disabling the logging + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -EnableErrorReporting $false + } + } + } + catch + { + Write-Verbose "In catch" + # If telemetry is enabled, log errors generated from this cmdlet also. + if ($EnableErrorReporting.Value -eq $true) + { + $errorCountAtProcessEnd = $global:Error.Count + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath -LogDirectoryPath $LogDirectoryPath.Value + + # Import the REST module + $RestPowershellModule = "Microsoft.Exchange.Management.RestApiClient.dll"; + $RestModulePath = [System.IO.Path]::Combine($PSScriptRoot, $RestPowershellModule); + Import-Module $RestModulePath -Cmdlet Set-ExoAppSettings; + + # Set the AppSettings + Set-ExoAppSettings -ShowProgress $ShowProgress.Value -PageSize $PageSize.Value -UseMultithreading $UseMultithreading.Value -TrackPerformance $TrackPerformance.Value -ConnectionUri $ConnectionUri -EnableErrorReporting $true -LogDirectoryPath $LogDirectoryPath.Value -LogLevel $LogLevel.Value + } + + # Log errors which are encountered during Connect-ExchangeOnline execution. + Write-Warning("Writing Connect-ExchangeOnline error log to " + $global:_EXO_TelemetryFilePath) + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Connect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid -ErrorObject $global:Error -ErrorRecordsToConsider ($errorCountAtProcessEnd - $errorCountAtStart) + } + throw $_ + } + } +} + +function Connect-IPPSSession +{ + [CmdletBinding()] + param( + # Connection Uri for the Remote PowerShell endpoint + [string] $ConnectionUri = 'https://ps.compliance.protection.outlook.com/PowerShell-LiveId', + + # Azure AD Authorization endpoint Uri that can issue the OAuth2 access tokens + [string] $AzureADAuthorizationEndpointUri = 'https://login.microsoftonline.com/organizations', + + # Delegated Organization Name + [string] $DelegatedOrganization = '', + + # PowerShell session options to be used when opening the Remote PowerShell session + [System.Management.Automation.Remoting.PSSessionOption] $PSSessionOption = $null, + + # Switch to bypass use of mailbox anchoring hint. + [switch] $BypassMailboxAnchoring = $false, + + # Prefix + [string] $Prefix = '', + + #Cmdlets to Import, by default it would bring all + [string[]] $CommandName = @("*"), + + #The way the output objects would be printed on the console + [string[]] $FormatTypeName = @("*") + ) + DynamicParam + { + if (($isCloudShell = IsCloudShellEnvironment) -eq $false) + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # User Principal Name or email address of the user + $UserPrincipalName = New-Object System.Management.Automation.RuntimeDefinedParameter('UserPrincipalName', [string], $attributeCollection) + $UserPrincipalName.Value = '' + + # User Credential to Logon + $Credential = New-Object System.Management.Automation.RuntimeDefinedParameter('Credential', [System.Management.Automation.PSCredential], $attributeCollection) + $Credential.Value = $null + + # Certificate + $Certificate = New-Object System.Management.Automation.RuntimeDefinedParameter('Certificate', [System.Security.Cryptography.X509Certificates.X509Certificate2], $attributeCollection) + $Certificate.Value = $null + + # Certificate Path + $CertificateFilePath = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateFilePath', [string], $attributeCollection) + $CertificateFilePath.Value = '' + + # Certificate Password + $CertificatePassword = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificatePassword', [System.Security.SecureString], $attributeCollection) + $CertificatePassword.Value = $null + + # Certificate Thumbprint + #$CertificateThumbprint = New-Object System.Management.Automation.RuntimeDefinedParameter('CertificateThumbprint', [string], $attributeCollection) + #$CertificateThumbprint.Value = '' + + # Application Id + $AppId = New-Object System.Management.Automation.RuntimeDefinedParameter('AppId', [string], $attributeCollection) + $AppId.Value = '' + + # Organization + $Organization = New-Object System.Management.Automation.RuntimeDefinedParameter('Organization', [string], $attributeCollection) + $Organization.Value = '' + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('UserPrincipalName', $UserPrincipalName) + $paramDictionary.Add('Credential', $Credential) + $paramDictionary.Add('Certificate', $Certificate) + $paramDictionary.Add('CertificateFilePath', $CertificateFilePath) + $paramDictionary.Add('CertificatePassword', $CertificatePassword) + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + $paramDictionary.Add('AppId', $AppId) + $paramDictionary.Add('Organization', $Organization) + + Write-Host "PSEdition: $PSEdition" + Write-Host "Windows: $IsWindows" + + if($PSEdition -eq 'Core') + { + # We do not want to expose certificate thumprint in Linux as it is not feasible there. + if($IsWindows) + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + } + else + { + $paramDictionary.Add('CertificateThumbprint', $CertificateThumbprint); + } + + return $paramDictionary + } + else + { + $attributes = New-Object System.Management.Automation.ParameterAttribute + $attributes.Mandatory = $false + + $attributeCollection = New-Object System.Collections.ObjectModel.Collection[System.Attribute] + $attributeCollection.Add($attributes) + + # Switch to MSI auth + $Device = New-Object System.Management.Automation.RuntimeDefinedParameter('Device', [switch], $attributeCollection) + $Device.Value = $false + + $paramDictionary = New-object System.Management.Automation.RuntimeDefinedParameterDictionary + $paramDictionary.Add('Device', $Device) + return $paramDictionary + } + } + process + { + try + { + $EOPConnectionInProgress = $true + if ($isCloudShell -eq $false) + { + Connect-ExchangeOnline -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -UserPrincipalName $UserPrincipalName.Value -PSSessionOption $PSSessionOption -Credential $Credential.Value -BypassMailboxAnchoring:$BypassMailboxAnchoring -ShowBanner:$false -DelegatedOrganization $DelegatedOrganization -Certificate $Certificate.Value -CertificateFilePath $CertificateFilePath.Value -CertificatePassword $CertificatePassword.Value -CertificateThumbprint $CertificateThumbprint.Value -AppId $AppId.Value -Organization $Organization.Value -Prefix $Prefix -CommandName $CommandName -FormatTypeName $FormatTypeName -UseRPSSession:$true + } + else + { + Connect-ExchangeOnline -ConnectionUri $ConnectionUri -AzureADAuthorizationEndpointUri $AzureADAuthorizationEndpointUri -PSSessionOption $PSSessionOption -BypassMailboxAnchoring:$BypassMailboxAnchoring -Device:$Device.Value -ShowBanner:$false -DelegatedOrganization $DelegatedOrganization -Prefix $Prefix -CommandName $CommandName -FormatTypeName $FormatTypeName -UseRPSSession:$true + } + } + finally + { + $EOPConnectionInProgress = $false + } + } +} + +function Disconnect-ExchangeOnline +{ + [CmdletBinding(SupportsShouldProcess, ConfirmImpact='High')] + param() + + process + { + if ($PSCmdlet.ShouldProcess( + "Running this cmdlet clears all active sessions created using Connect-ExchangeOnline or Connect-IPPSSession.", + "Press(Y/y/A/a) if you want to continue.", + "Running this cmdlet clears all active sessions created using Connect-ExchangeOnline or Connect-IPPSSession. ")) + { + + # Keep track of error count at beginning. + $errorCountAtStart = $global:Error.Count; + + try + { + # Import the module once more to ensure that Test-ActiveToken is present + $ExoPowershellModule = "Microsoft.Exchange.Management.ExoPowershellGalleryModule.dll"; + $ModulePath = [System.IO.Path]::Combine($PSScriptRoot, $ExoPowershellModule); + Import-Module $ModulePath -Cmdlet Clear-ActiveToken; + + $existingPSSession = Get-PSSession | Where-Object {$_.ConfigurationName -like "Microsoft.Exchange" -and $_.Name -like "ExchangeOnlineInternalSession*"} + + if ($existingPSSession.count -gt 0) + { + for ($index = 0; $index -lt $existingPSSession.count; $index++) + { + $session = $existingPSSession[$index] + Remove-PSSession -session $session + + Write-Information "Removed the PSSession $($session.Name) connected to $($session.ComputerName)" + + # Remove any active access token from the cache + Clear-ActiveToken -TokenProvider $session.TokenProvider + + # Remove any previous modules loaded because of the current PSSession + if ($session.PreviousModuleName -ne $null) + { + if ((Get-Module $session.PreviousModuleName).Count -ne 0) + { + $null = Remove-Module -Name $session.PreviousModuleName -ErrorAction SilentlyContinue + } + + $session.PreviousModuleName = $null + } + + # Remove any leaked module in case of removal of broken session object + if ($session.CurrentModuleName -ne $null) + { + if ((Get-Module $session.CurrentModuleName).Count -ne 0) + { + $null = Remove-Module -Name $session.CurrentModuleName -ErrorAction SilentlyContinue + } + } + } + } + + # Clear all the active tokens in ConnectionContext + [Microsoft.Exchange.Management.ExoPowershellSnapin.ConnectionContextFactory]::RemoveAllTokensFromConnectionContext() + + # Remove all the AutoREST modules from this instance of powershell if created + $existingAutoRESTModules = Get-Module "tmpEXO_*" + foreach ($module in $existingAutoRESTModules) + { + $null = Remove-Module -Name $module -ErrorAction SilentlyContinue + } + + Write-Information "Disconnected successfully !" + + if ($global:_EXO_EnableErrorReporting -eq $true) + { + # Remove all the Wrapped modules from this instance of powershell if created + $existingWrappedModules = Get-Module "EXOCmdletWrapper-*" + foreach ($module in $existingWrappedModules) + { + $null = Remove-Module -Name $module -ErrorAction SilentlyContinue + } + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath + } + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Disconnect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid + } + } + catch + { + # If telemetry is enabled, log errors generated from this cmdlet also. + if ($global:_EXO_EnableErrorReporting -eq $true) + { + $errorCountAtProcessEnd = $global:Error.Count + + if ($global:_EXO_TelemetryFilePath -eq $null) + { + $global:_EXO_TelemetryFilePath = New-EXOClientTelemetryFilePath + } + + # Log errors which are encountered during Disconnect-ExchangeOnline execution. + Write-Warning("Writing Disconnect-ExchangeOnline errors to " + $global:_EXO_TelemetryFilePath) + + Push-EXOTelemetryRecord -TelemetryFilePath $global:_EXO_TelemetryFilePath -CommandName Disconnect-ExchangeOnline -CommandParams $PSCmdlet.MyInvocation.BoundParameters -OrganizationName $global:_EXO_ExPSTelemetryOrganization -ScriptName $global:_EXO_ExPSTelemetryScriptName -ScriptExecutionGuid $global:_EXO_ExPSTelemetryScriptExecutionGuid -ErrorObject $global:Error -ErrorRecordsToConsider ($errorCountAtProcessEnd - $errorCountAtStart) + } + + throw $_ + } + } + } +} + +# SIG # Begin signature block +# MIInnQYJKoZIhvcNAQcCoIInjjCCJ4oCAQExDzANBglghkgBZQMEAgEFADB5Bgor +# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG +# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCAk8bWd5n6Z+FmL +# OYNO5yQEAw68XUDDa/dIT4+yqen8YKCCDYEwggX/MIID56ADAgECAhMzAAACUosz +# qviV8znbAAAAAAJSMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD +# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy +# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p +# bmcgUENBIDIwMTEwHhcNMjEwOTAyMTgzMjU5WhcNMjIwOTAxMTgzMjU5WjB0MQsw +# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u +# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy +# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +# AQDQ5M+Ps/X7BNuv5B/0I6uoDwj0NJOo1KrVQqO7ggRXccklyTrWL4xMShjIou2I +# sbYnF67wXzVAq5Om4oe+LfzSDOzjcb6ms00gBo0OQaqwQ1BijyJ7NvDf80I1fW9O +# L76Kt0Wpc2zrGhzcHdb7upPrvxvSNNUvxK3sgw7YTt31410vpEp8yfBEl/hd8ZzA +# v47DCgJ5j1zm295s1RVZHNp6MoiQFVOECm4AwK2l28i+YER1JO4IplTH44uvzX9o +# RnJHaMvWzZEpozPy4jNO2DDqbcNs4zh7AWMhE1PWFVA+CHI/En5nASvCvLmuR/t8 +# q4bc8XR8QIZJQSp+2U6m2ldNAgMBAAGjggF+MIIBejAfBgNVHSUEGDAWBgorBgEE +# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQUNZJaEUGL2Guwt7ZOAu4efEYXedEw +# UAYDVR0RBEkwR6RFMEMxKTAnBgNVBAsTIE1pY3Jvc29mdCBPcGVyYXRpb25zIFB1 +# ZXJ0byBSaWNvMRYwFAYDVQQFEw0yMzAwMTIrNDY3NTk3MB8GA1UdIwQYMBaAFEhu +# ZOVQBdOCqhc3NyK1bajKdQKVMFQGA1UdHwRNMEswSaBHoEWGQ2h0dHA6Ly93d3cu +# bWljcm9zb2Z0LmNvbS9wa2lvcHMvY3JsL01pY0NvZFNpZ1BDQTIwMTFfMjAxMS0w +# Ny0wOC5jcmwwYQYIKwYBBQUHAQEEVTBTMFEGCCsGAQUFBzAChkVodHRwOi8vd3d3 +# Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2NlcnRzL01pY0NvZFNpZ1BDQTIwMTFfMjAx +# MS0wNy0wOC5jcnQwDAYDVR0TAQH/BAIwADANBgkqhkiG9w0BAQsFAAOCAgEAFkk3 +# uSxkTEBh1NtAl7BivIEsAWdgX1qZ+EdZMYbQKasY6IhSLXRMxF1B3OKdR9K/kccp +# kvNcGl8D7YyYS4mhCUMBR+VLrg3f8PUj38A9V5aiY2/Jok7WZFOAmjPRNNGnyeg7 +# l0lTiThFqE+2aOs6+heegqAdelGgNJKRHLWRuhGKuLIw5lkgx9Ky+QvZrn/Ddi8u +# TIgWKp+MGG8xY6PBvvjgt9jQShlnPrZ3UY8Bvwy6rynhXBaV0V0TTL0gEx7eh/K1 +# o8Miaru6s/7FyqOLeUS4vTHh9TgBL5DtxCYurXbSBVtL1Fj44+Od/6cmC9mmvrti +# yG709Y3Rd3YdJj2f3GJq7Y7KdWq0QYhatKhBeg4fxjhg0yut2g6aM1mxjNPrE48z +# 6HWCNGu9gMK5ZudldRw4a45Z06Aoktof0CqOyTErvq0YjoE4Xpa0+87T/PVUXNqf +# 7Y+qSU7+9LtLQuMYR4w3cSPjuNusvLf9gBnch5RqM7kaDtYWDgLyB42EfsxeMqwK +# WwA+TVi0HrWRqfSx2olbE56hJcEkMjOSKz3sRuupFCX3UroyYf52L+2iVTrda8XW +# esPG62Mnn3T8AuLfzeJFuAbfOSERx7IFZO92UPoXE1uEjL5skl1yTZB3MubgOA4F +# 8KoRNhviFAEST+nG8c8uIsbZeb08SeYQMqjVEmkwggd6MIIFYqADAgECAgphDpDS +# AAAAAAADMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMK +# V2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0 +# IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0 +# ZSBBdXRob3JpdHkgMjAxMTAeFw0xMTA3MDgyMDU5MDlaFw0yNjA3MDgyMTA5MDla +# MH4xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdS +# ZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMT +# H01pY3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTEwggIiMA0GCSqGSIb3DQEB +# AQUAA4ICDwAwggIKAoICAQCr8PpyEBwurdhuqoIQTTS68rZYIZ9CGypr6VpQqrgG +# OBoESbp/wwwe3TdrxhLYC/A4wpkGsMg51QEUMULTiQ15ZId+lGAkbK+eSZzpaF7S +# 35tTsgosw6/ZqSuuegmv15ZZymAaBelmdugyUiYSL+erCFDPs0S3XdjELgN1q2jz +# y23zOlyhFvRGuuA4ZKxuZDV4pqBjDy3TQJP4494HDdVceaVJKecNvqATd76UPe/7 +# 4ytaEB9NViiienLgEjq3SV7Y7e1DkYPZe7J7hhvZPrGMXeiJT4Qa8qEvWeSQOy2u +# M1jFtz7+MtOzAz2xsq+SOH7SnYAs9U5WkSE1JcM5bmR/U7qcD60ZI4TL9LoDho33 +# X/DQUr+MlIe8wCF0JV8YKLbMJyg4JZg5SjbPfLGSrhwjp6lm7GEfauEoSZ1fiOIl +# XdMhSz5SxLVXPyQD8NF6Wy/VI+NwXQ9RRnez+ADhvKwCgl/bwBWzvRvUVUvnOaEP +# 6SNJvBi4RHxF5MHDcnrgcuck379GmcXvwhxX24ON7E1JMKerjt/sW5+v/N2wZuLB +# l4F77dbtS+dJKacTKKanfWeA5opieF+yL4TXV5xcv3coKPHtbcMojyyPQDdPweGF +# RInECUzF1KVDL3SV9274eCBYLBNdYJWaPk8zhNqwiBfenk70lrC8RqBsmNLg1oiM +# CwIDAQABo4IB7TCCAekwEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFEhuZOVQ +# BdOCqhc3NyK1bajKdQKVMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1Ud +# DwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFHItOgIxkEO5FAVO +# 4eqnxzHRI4k0MFoGA1UdHwRTMFEwT6BNoEuGSWh0dHA6Ly9jcmwubWljcm9zb2Z0 +# LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y +# Mi5jcmwwXgYIKwYBBQUHAQEEUjBQME4GCCsGAQUFBzAChkJodHRwOi8vd3d3Lm1p +# Y3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y +# Mi5jcnQwgZ8GA1UdIASBlzCBlDCBkQYJKwYBBAGCNy4DMIGDMD8GCCsGAQUFBwIB +# FjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2RvY3MvcHJpbWFyeWNw +# cy5odG0wQAYIKwYBBQUHAgIwNB4yIB0ATABlAGcAYQBsAF8AcABvAGwAaQBjAHkA +# XwBzAHQAYQB0AGUAbQBlAG4AdAAuIB0wDQYJKoZIhvcNAQELBQADggIBAGfyhqWY +# 4FR5Gi7T2HRnIpsLlhHhY5KZQpZ90nkMkMFlXy4sPvjDctFtg/6+P+gKyju/R6mj +# 82nbY78iNaWXXWWEkH2LRlBV2AySfNIaSxzzPEKLUtCw/WvjPgcuKZvmPRul1LUd +# d5Q54ulkyUQ9eHoj8xN9ppB0g430yyYCRirCihC7pKkFDJvtaPpoLpWgKj8qa1hJ +# Yx8JaW5amJbkg/TAj/NGK978O9C9Ne9uJa7lryft0N3zDq+ZKJeYTQ49C/IIidYf +# wzIY4vDFLc5bnrRJOQrGCsLGra7lstnbFYhRRVg4MnEnGn+x9Cf43iw6IGmYslmJ +# aG5vp7d0w0AFBqYBKig+gj8TTWYLwLNN9eGPfxxvFX1Fp3blQCplo8NdUmKGwx1j +# NpeG39rz+PIWoZon4c2ll9DuXWNB41sHnIc+BncG0QaxdR8UvmFhtfDcxhsEvt9B +# xw4o7t5lL+yX9qFcltgA1qFGvVnzl6UJS0gQmYAf0AApxbGbpT9Fdx41xtKiop96 +# eiL6SJUfq/tHI4D1nvi/a7dLl+LrdXga7Oo3mXkYS//WsyNodeav+vyL6wuA6mk7 +# r/ww7QRMjt/fdW1jkT3RnVZOT7+AVyKheBEyIXrvQQqxP/uozKRdwaGIm1dxVk5I +# RcBCyZt2WwqASGv9eZ/BvW1taslScxMNelDNMYIZcjCCGW4CAQEwgZUwfjELMAkG +# A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQx +# HjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEoMCYGA1UEAxMfTWljcm9z +# b2Z0IENvZGUgU2lnbmluZyBQQ0EgMjAxMQITMwAAAlKLM6r4lfM52wAAAAACUjAN +# BglghkgBZQMEAgEFAKCBrjAZBgkqhkiG9w0BCQMxDAYKKwYBBAGCNwIBBDAcBgor +# BgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAvBgkqhkiG9w0BCQQxIgQgIhS3qoj1 +# UQcFwoqS3bsiKNlyzzwg84Jm8Gpt7FTE9REwQgYKKwYBBAGCNwIBDDE0MDKgFIAS +# AE0AaQBjAHIAbwBzAG8AZgB0oRqAGGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbTAN +# BgkqhkiG9w0BAQEFAASCAQAU2vbLS+IWCVvqWI8EdVkebP3f5WVbf6e2V2+jyA6R +# 8nmbHgS40FcyymsrI+vf1ru5gjMEfrAwY0VDsbWL//5bUuTKtgYGRTqmeCG33RO+ +# 9z/FoSCupd+n4Amfi/GVAiPAmg/Os4OBE8+V9Xld2B7og6/t/hi2osZrjHhUkKqc +# q2WS7lxnGNBTCmPJkNDTgIl4VXzgIBEfWNArUCb/V9NjGNPJ6qGezi0Q7OkXXMrC +# iGu0DwWnBwfcARE/oeU1T30DUU6La0t9bi1/cURAdVHRYufWWhIECnRuBD7pfjd/ +# Z6xY105pPZmIgi+f42tT7F1xVtUbMCaRxFcFE0Iqw+UOoYIW/DCCFvgGCisGAQQB +# gjcDAwExghboMIIW5AYJKoZIhvcNAQcCoIIW1TCCFtECAQMxDzANBglghkgBZQME +# AgEFADCCAVAGCyqGSIb3DQEJEAEEoIIBPwSCATswggE3AgEBBgorBgEEAYRZCgMB +# MDEwDQYJYIZIAWUDBAIBBQAEIBekHP5CnvvhbhNDrCF6H3oOJBPqZ9HDh40mWOYQ +# b45PAgZiFmzrUPEYEjIwMjIwMzEyMDMyMTUwLjgyWjAEgAIB9KCB0KSBzTCByjEL +# MAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1v +# bmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjElMCMGA1UECxMcTWlj +# cm9zb2Z0IEFtZXJpY2EgT3BlcmF0aW9uczEmMCQGA1UECxMdVGhhbGVzIFRTUyBF +# U046M0U3QS1FMzU5LUEyNUQxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1w +# IFNlcnZpY2WgghFUMIIHDDCCBPSgAwIBAgITMwAAAaDpu4y7DqLRegABAAABoDAN +# BgkqhkiG9w0BAQsFADB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3Rv +# bjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0 +# aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDAeFw0y +# MTEyMDIxOTA1MjNaFw0yMzAyMjgxOTA1MjNaMIHKMQswCQYDVQQGEwJVUzETMBEG +# A1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWlj +# cm9zb2Z0IENvcnBvcmF0aW9uMSUwIwYDVQQLExxNaWNyb3NvZnQgQW1lcmljYSBP +# cGVyYXRpb25zMSYwJAYDVQQLEx1UaGFsZXMgVFNTIEVTTjozRTdBLUUzNTktQTI1 +# RDElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2VydmljZTCCAiIwDQYJ +# KoZIhvcNAQEBBQADggIPADCCAgoCggIBAL/a4g5ocZ0A6PZi+GEjoLyIUCrvCuX/ +# lak+OPR8QcKLoi/H8jTYmyz8dWGR8ZMwa21HmNGGGslfJ1YOc6bNFTcHgbnblPun +# CQU0UFe6Yz/3yXmTRTZeJpn5u6Vcd7njHq6P/q/lUYW/7QeHV3KMZRM9pETBLvH3 +# xN7m0UcSKY9r4CwbaYz6f03B9BGN3UuIQJtwJkWSDBuWJD9qSIyvW1maOQNvG27Z +# pBxeMR8Odrwkf7BmZ927RfuTp0nlYZEXDNmIs4lbhCEASl6HZzWaZu0B8GeFI834 +# TnJQt+l9NPbBfxFsfpd8CDqxnHzz3rGrT6BQP2YfLxm2l0R4TVkDQeAHINbaskJt +# MAkCG3vUHtHPak9CaDlHf69IKuLwF5xIH5nybBgve45LdHpt5QEnuITis9L1YLXD +# V9lHsrjhlKZ7Z0j473+eGBvcwtiCbrPHceG0ugaEZU8v5agOQye33cgag7qQ0EIz +# Zf4KzbaqXa0+OQhHLHDEXpGxeH9AeeEomAHN8757zgjdNhsjSLb3MBMvrIc6/mwS +# zXNo0yKHbsjB9aDhDv7jQvt7ry4LrIPwRQSloPazZPn02FJq5PMIScCnlitKxxz0 +# xBUiLuD7kYB0LykK/7SJFrtAi9qVT72VaCTIAFT+eIUdY+PIagHjHcrOje1cHpoL +# fJn91NFekmdpAgMBAAGjggE2MIIBMjAdBgNVHQ4EFgQUcrkuUNgpTpG4kWwUL0TP +# C2GM0OgwHwYDVR0jBBgwFoAUn6cVXQBeYl2D9OXSZacbUzUZ6XIwXwYDVR0fBFgw +# VjBUoFKgUIZOaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jcmwvTWlj +# cm9zb2Z0JTIwVGltZS1TdGFtcCUyMFBDQSUyMDIwMTAoMSkuY3JsMGwGCCsGAQUF +# BwEBBGAwXjBcBggrBgEFBQcwAoZQaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3Br +# aW9wcy9jZXJ0cy9NaWNyb3NvZnQlMjBUaW1lLVN0YW1wJTIwUENBJTIwMjAxMCgx +# KS5jcnQwDAYDVR0TAQH/BAIwADATBgNVHSUEDDAKBggrBgEFBQcDCDANBgkqhkiG +# 9w0BAQsFAAOCAgEAMX3GAqv436yUCaVtwSpAGWkvk98EypwuRLrJJ4YmMb4spfda +# i/mnKCuEp+1dn3Q1hZR+0hmnN1izh6FHlGVoTd5i5taVw2XCwqRysZIMkprBtsMZ +# +87iH/UvXeyDrqE+JvruYb3oICpFUXRzkwDXCIqOOX/mB+tt00seC1ERDzMKlsrj +# 7rqXUV3S6n2bFw4QSmGEmvxTfCHAXCgr5An+TFaiAa18OJqrpHKgVaE/y4pItUNX +# 4xMRMdlvenY7CcFYTVbrTvVcMp3FGQ3+kARnXkTUsk2/2JijWXU/9F0X4jOkwsYM +# B/8+VW9NTDdWsf25qptiv6tHG2L5szdpvXC/2/fFEtz7A+ieJLFbanr0M3haj3og +# MVkiQtH4dxYKKodXAVeeCQJR90x7fGa84hdhGRMrQ/rA8t8L46zuh5VF4yPZMDVA +# wySBn6uE87TuJbs3nvMAG8yIclB0dEx4rcUGBHh9oS9ONQB0pFCQoVXza4TvDRQy +# ex4l9fsQsNj1PhpbHarASpqb2XsYdfgDZmbSefWhpr9jFzMnuAhURFIZI5YvAQzF +# wWoEY+b1BJDuiAwGflYfCR1NOSZqcFv9nZwOnEHF3W86PIibgE4WUuMHimK8KU7Z +# mSxYofuoFiWhhrTtTU7cLyO1vMZR0fIsJpUYFXwN8PmHx46fKOtoEbs801kwggdx +# MIIFWaADAgECAhMzAAAAFcXna54Cm0mZAAAAAAAVMA0GCSqGSIb3DQEBCwUAMIGI +# MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVk +# bW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTIwMAYDVQQDEylN +# aWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgMjAxMDAeFw0yMTA5 +# MzAxODIyMjVaFw0zMDA5MzAxODMyMjVaMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQI +# EwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3Nv +# ZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBD +# QSAyMDEwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA5OGmTOe0ciEL +# eaLL1yR5vQ7VgtP97pwHB9KpbE51yMo1V/YBf2xK4OK9uT4XYDP/XE/HZveVU3Fa +# 4n5KWv64NmeFRiMMtY0Tz3cywBAY6GB9alKDRLemjkZrBxTzxXb1hlDcwUTIcVxR +# MTegCjhuje3XD9gmU3w5YQJ6xKr9cmmvHaus9ja+NSZk2pg7uhp7M62AW36MEByd +# Uv626GIl3GoPz130/o5Tz9bshVZN7928jaTjkY+yOSxRnOlwaQ3KNi1wjjHINSi9 +# 47SHJMPgyY9+tVSP3PoFVZhtaDuaRr3tpK56KTesy+uDRedGbsoy1cCGMFxPLOJi +# ss254o2I5JasAUq7vnGpF1tnYN74kpEeHT39IM9zfUGaRnXNxF803RKJ1v2lIH1+ +# /NmeRd+2ci/bfV+AutuqfjbsNkz2K26oElHovwUDo9Fzpk03dJQcNIIP8BDyt0cY +# 7afomXw/TNuvXsLz1dhzPUNOwTM5TI4CvEJoLhDqhFFG4tG9ahhaYQFzymeiXtco +# dgLiMxhy16cg8ML6EgrXY28MyTZki1ugpoMhXV8wdJGUlNi5UPkLiWHzNgY1GIRH +# 29wb0f2y1BzFa/ZcUlFdEtsluq9QBXpsxREdcu+N+VLEhReTwDwV2xo3xwgVGD94 +# q0W29R6HXtqPnhZyacaue7e3PmriLq0CAwEAAaOCAd0wggHZMBIGCSsGAQQBgjcV +# AQQFAgMBAAEwIwYJKwYBBAGCNxUCBBYEFCqnUv5kxJq+gpE8RjUpzxD/LwTuMB0G +# A1UdDgQWBBSfpxVdAF5iXYP05dJlpxtTNRnpcjBcBgNVHSAEVTBTMFEGDCsGAQQB +# gjdMg30BATBBMD8GCCsGAQUFBwIBFjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20v +# cGtpb3BzL0RvY3MvUmVwb3NpdG9yeS5odG0wEwYDVR0lBAwwCgYIKwYBBQUHAwgw +# GQYJKwYBBAGCNxQCBAweCgBTAHUAYgBDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB +# /wQFMAMBAf8wHwYDVR0jBBgwFoAU1fZWy4/oolxiaNE9lJBb186aGMQwVgYDVR0f +# BE8wTTBLoEmgR4ZFaHR0cDovL2NybC5taWNyb3NvZnQuY29tL3BraS9jcmwvcHJv +# ZHVjdHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYtMjMuY3JsMFoGCCsGAQUFBwEBBE4w +# TDBKBggrBgEFBQcwAoY+aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0 +# cy9NaWNSb29DZXJBdXRfMjAxMC0wNi0yMy5jcnQwDQYJKoZIhvcNAQELBQADggIB +# AJ1VffwqreEsH2cBMSRb4Z5yS/ypb+pcFLY+TkdkeLEGk5c9MTO1OdfCcTY/2mRs +# fNB1OW27DzHkwo/7bNGhlBgi7ulmZzpTTd2YurYeeNg2LpypglYAA7AFvonoaeC6 +# Ce5732pvvinLbtg/SHUB2RjebYIM9W0jVOR4U3UkV7ndn/OOPcbzaN9l9qRWqveV +# tihVJ9AkvUCgvxm2EhIRXT0n4ECWOKz3+SmJw7wXsFSFQrP8DJ6LGYnn8AtqgcKB +# GUIZUnWKNsIdw2FzLixre24/LAl4FOmRsqlb30mjdAy87JGA0j3mSj5mO0+7hvoy +# GtmW9I/2kQH2zsZ0/fZMcm8Qq3UwxTSwethQ/gpY3UA8x1RtnWN0SCyxTkctwRQE +# cb9k+SS+c23Kjgm9swFXSVRk2XPXfx5bRAGOWhmRaw2fpCjcZxkoJLo4S5pu+yFU +# a2pFEUep8beuyOiJXk+d0tBMdrVXVAmxaQFEfnyhYWxz/gq77EFmPWn9y8FBSX5+ +# k77L+DvktxW/tM4+pTFRhLy/AsGConsXHRWJjXD+57XQKBqJC4822rpM+Zv/Cuk0 +# +CQ1ZyvgDbjmjJnW4SLq8CdCPSWU5nR0W2rRnj7tfqAxM328y+l7vzhwRNGQ8cir +# Ooo6CGJ/2XBjU02N7oJtpQUQwXEGahC0HVUzWLOhcGbyoYICyzCCAjQCAQEwgfih +# gdCkgc0wgcoxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYD +# VQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJTAj +# BgNVBAsTHE1pY3Jvc29mdCBBbWVyaWNhIE9wZXJhdGlvbnMxJjAkBgNVBAsTHVRo +# YWxlcyBUU1MgRVNOOjNFN0EtRTM1OS1BMjVEMSUwIwYDVQQDExxNaWNyb3NvZnQg +# VGltZS1TdGFtcCBTZXJ2aWNloiMKAQEwBwYFKw4DAhoDFQATBriNaNpxs5hT773n +# J0nuFIKLmKCBgzCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5n +# dG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9y +# YXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwMA0G +# CSqGSIb3DQEBBQUAAgUA5dYCvDAiGA8yMDIyMDMxMjAxMTc0OFoYDzIwMjIwMzEz +# MDExNzQ4WjB0MDoGCisGAQQBhFkKBAExLDAqMAoCBQDl1gK8AgEAMAcCAQACAgCw +# MAcCAQACAhGuMAoCBQDl11Q8AgEAMDYGCisGAQQBhFkKBAIxKDAmMAwGCisGAQQB +# hFkKAwKgCjAIAgEAAgMHoSChCjAIAgEAAgMBhqAwDQYJKoZIhvcNAQEFBQADgYEA +# H1WmVFLLRfx8XuVuVC/CzptlQCI5EG0ppvZ1it5m9CxMeTkVJDU84hnn9X1bl28q +# RoLrKIFHEdL8NxTQqs7U3qbouKFyFPFB+O62aKWhtN8w0MAnbN9H6ERv9ymKY/cS +# XMm9XbGlE7mir054levW/KWMtMQz8Vynxi1nNruNGH4xggQNMIIECQIBATCBkzB8 +# MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVk +# bW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1N +# aWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMAITMwAAAaDpu4y7DqLRegABAAAB +# oDANBglghkgBZQMEAgEFAKCCAUowGgYJKoZIhvcNAQkDMQ0GCyqGSIb3DQEJEAEE +# MC8GCSqGSIb3DQEJBDEiBCA6yg5Q9T8Zf3uJpxpGStuZknGB/oQrDzqIf18z6csZ +# JTCB+gYLKoZIhvcNAQkQAi8xgeowgecwgeQwgb0EIC9HijxoZQQiEi3dES+zHT6y +# +czpaJqBrlI9oriDr7TTMIGYMIGApH4wfDELMAkGA1UEBhMCVVMxEzARBgNVBAgT +# Cldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29m +# dCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENB +# IDIwMTACEzMAAAGg6buMuw6i0XoAAQAAAaAwIgQgNtOO732G/6Ao4oRTpGrp3/oo +# gs/bdXoL/1Exes00Z+owDQYJKoZIhvcNAQELBQAEggIAVqfo8sV5o++I1u8kGl2I +# R38dS9Y7FY8Tx7OcnzcWH6lwksT/66VKkH+2VxlgLUYdA983c4oBzYkCQ73cOn+F +# dfqhCj7tsPwinK7yYMlRr64GJdLMmRlpg0BQoigPKFu1tgCMj9EMQv9gw/JuG+CX +# 4iSNXFRy414//W42BF9Oi9pht46EqEth014nUjXQq9ADBqF1SoWWhsqxm8x4XUIz +# 95Bn0zBMiBmoz7dqZ9k1OcQPhRmPBqlFfIa80uxSyWC1+ZAGaFl1jn+lZ/8mNAha +# VeTwz0q99J41idqkzeIMhN7gE7u06N/JqpMzCqAglDaFvQNs9gGQNSwMl07tR86o +# Pu8cSzqOoLzZ2lNKPMD70Il74ucqaOn9RvkfS99UCec3W0IX2Q4UFqFbWL4juVNl +# CSdkDxbhaTmDc+oBimgWBlTh70nqBlsvanu9Q1Q/mh2KzCwUZ20dbgurFAyb5tSO +# XGymwPJ09Ae+9I3Q1P8clWr7ZgCRqhHYpqO46iuyvjG1WL0qCkyFRiWD05Nlqe/7 +# DsXgjkPoqmH4di5I6a8sFE1p3sX73H7esvc8KeQEX3rPwQKinodk72tCPq0OGgfV +# Sp2OZzJSf5klmK0ig+x78AkHu/gWdJFLVeghAekXQ9X2/gGLpxKuSI0c9wR8Qt84 +# gOroSsuAmRkqDbQNW5L4d7o= +# SIG # End signature block diff --git a/microsoft-teams/1.0.0/Dockerfile b/unsupported/microsoft-identity-and-access/1.0.0/Dockerfile similarity index 100% rename from microsoft-teams/1.0.0/Dockerfile rename to unsupported/microsoft-identity-and-access/1.0.0/Dockerfile diff --git a/microsoft-identity-and-access/1.0.0/README.md b/unsupported/microsoft-identity-and-access/1.0.0/README.md similarity index 88% rename from microsoft-identity-and-access/1.0.0/README.md rename to unsupported/microsoft-identity-and-access/1.0.0/README.md index 38fa5d83..ab2a3c8f 100644 --- a/microsoft-identity-and-access/1.0.0/README.md +++ b/unsupported/microsoft-identity-and-access/1.0.0/README.md @@ -1,7 +1,9 @@ ## Microsoft Identity and Access - An app to interact with Active Directory in Azure. -## How to register app in Active Directory on Azure portal ? +**PS: If you want to Reset a password in Azure AD, please use the "Azure AD Delegated" app, and use ONLY delegated permissions for this.** + +## How to register app in Active Directory on Azure portal? ### Step 1: Go to the Azure portal diff --git a/microsoft-identity-and-access/1.0.0/api.yaml b/unsupported/microsoft-identity-and-access/1.0.0/api.yaml similarity index 77% rename from microsoft-identity-and-access/1.0.0/api.yaml rename to unsupported/microsoft-identity-and-access/1.0.0/api.yaml index a370a39b..b891edc1 100644 --- a/microsoft-identity-and-access/1.0.0/api.yaml +++ b/unsupported/microsoft-identity-and-access/1.0.0/api.yaml @@ -10,7 +10,7 @@ tags: - Access Management - Azure Active Directory categories: - - Testing + - IAM authentication: required: true parameters: @@ -35,6 +35,87 @@ authentication: schema: type: string actions: + - name: list_users + description: Retrieve a list users in the organization + - name: list_groups + description: Retrieve a list of groups in the organization + #- name: disable_user + # description: Disables a user by setting a random password for them and stopping their current sessions. + # parameters: + # - name: user_email_or_id + # description: id + # multiline: false + # example: "User email address or id" + # required: true + # schema: + # type: string + - name: get_user + description: Deletes a user. Can be restored again within 30 days. Well used in conjunction after the logout user action + parameters: + - name: user_id + description: The user ID to get + multiline: false + example: "User email address or id" + required: true + schema: + type: string + - name: selected_fields + description: Selected fields + multiline: false + example: "Selected fields to get" + required: false + schema: + type: string + - name: delete_user + description: Deletes a user. Can be restored again within 30 days. Well used in conjunction after the logout user action + parameters: + - name: user_email_or_id + description: id + multiline: false + example: "User email address or id" + required: true + schema: + type: string + - name: restore_deleted_user + description: Deletes a user. Can be restored again within 30 days. Well used in conjunction after the logout user action + parameters: + - name: user_email_or_id + description: id + multiline: false + example: "User email address or id" + required: true + schema: + type: string + - name: list_deleted_users + description: Lists deleted information in the tenant + parameters: + - name: user_email_or_id + description: id + multiline: false + example: "User email address or id" + required: true + schema: + type: string + - name: logout_user + description: Logs out the selected user from all session. + parameters: + - name: user_email_or_id + description: id + multiline: false + example: "User email address or id" + required: true + schema: + type: string + - name: list_group_members + description: Retrieve a list of users in a group + parameters: + - name: group_id + description: id + multiline: false + example: "1" + required: true + schema: + type: string - name: list_administrative_units description: Retrieve a list of administrativeUnit objects - name: get_administrative_unit @@ -120,6 +201,21 @@ actions: type: string - name: list_risky_users description: Lists risky users + parameters: + - name: amount + description: 20 + multiline: false + example: "20" + required: true + schema: + type: string + - name: skip + description: 0 + multiline: false + example: "0" + required: true + schema: + type: string - name: get_risky_user description: Get risky user by id parameters: @@ -230,5 +326,111 @@ actions: required: true schema: type: string + - name: disable_user_account + description: Disable user account + parameters: + - name: user_email_or_id + description: User Email or Object ID + multiline: false + example: "Test.User@example.com" + required: true + schema: + type: string + - name: update_user_job_title + description: Updates user Job Title field + parameters: + - name: user_email_or_id + description: User Email or Object ID + multiline: false + example: "Test.user@example.com" + required: true + schema: + type: string + - name: user_job_title + description: Job Title to update for user + multiline: false + example: "DevOps Engineer" + required: true + schema: + type: string + - name: update_user_department + description: Updates user Department field + parameters: + - name: user_email_or_id + description: User Email or Object ID + multiline: false + example: "Test.user@example.com" + required: true + schema: + type: string + - name: user_department + description: Department to update for user + multiline: false + example: "Finance Department" + required: true + schema: + type: string + - name: update_user_employee_type + description: Updates user Employee Type field + parameters: + - name: user_email_or_id + description: User Email or Object ID + multiline: false + example: "Test.user@example.com" + required: true + schema: + type: string + - name: user_employee_type + description: Employee Type to update for user + multiline: false + example: "Contractor" + required: true + schema: + type: string + - name: update_user_leave_date + description: Updates user Leave Date field + parameters: + - name: user_email_or_id + description: User Email or Object ID + multiline: false + example: "Test.user@example.com" + required: true + schema: + type: string + - name: user_leave_date + description: User Leave Date + multiline: false + example: "2022-09-30T23:59:59Z" + required: true + schema: + type: string + - name: get_user_direct_groups + description: Retrieves Static Groups User is Member Of + parameters: + - name: user_email_or_id + description: User Email or Object ID + multiline: false + example: "Test.user@example.com" + required: true + schema: + type: string + - name: remove_user_from_group + description: Removes User from Specified Group + parameters: + - name: user_id + description: Object ID of User + multiline: false + example: eb6fa72b-f4f0-4ce0-94d2-dd16b4a22686 + required: true + schema: + type: string + - name: group_id + description: Object ID of Group + multiline: false + example: 2a712b67-91af-429f-9603-a5bfhgu7b151 + required: true + schema: + type: string + large_image: data:image/png;base64,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 diff --git a/unsupported/microsoft-identity-and-access/1.0.0/requirements.txt b/unsupported/microsoft-identity-and-access/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/microsoft-identity-and-access/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/unsupported/microsoft-identity-and-access/1.0.0/src/app.py b/unsupported/microsoft-identity-and-access/1.0.0/src/app.py new file mode 100644 index 00000000..19f7729f --- /dev/null +++ b/unsupported/microsoft-identity-and-access/1.0.0/src/app.py @@ -0,0 +1,646 @@ +import socket +import asyncio +import time +import random +import json +import uuid +import time +import requests + +from walkoff_app_sdk.app_base import AppBase + +class MsIdentityAccess(AppBase): + __version__ = "1.0.0" + app_name = "Microsoft Identity and Access" + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def authenticate(self, tenant_id, client_id, client_secret, graph_url): + s = requests.Session() + auth_url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token" + auth_data = { + "grant_type": "client_credentials", + "client_id": client_id, + "client_secret": client_secret, + "scope": f"{graph_url}/.default", + } + auth_headers = { + "Content-Type": "application/x-www-form-urlencoded", + "cache-control": "no-cache", + } + + print(f"Making request to: {auth_url}") + res = s.post(auth_url, data=auth_data, headers=auth_headers) + + # Auth failed, raise exception with the response + if res.status_code != 200: + raise ConnectionError(res.text) + + access_token = res.json().get("access_token") + s.headers = {"Authorization": f"Bearer {access_token}", "cache-control": "no-cache"} + return s + + # Disable = reset password & sessions + def list_deleted_users(self, tenant_id, client_id, client_secret, user_email_or_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + + graph_url = f"https://graph.microsoft.com/v1.0/directory/deletedItems/microsoft.graph.user" + headers = { + "Content-type": "application/json" + } + ret = session.get(graph_url, headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + # Disable = reset password & sessions + def restore_deleted_user(self, tenant_id, client_id, client_secret, user_email_or_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directory/deletedItems/{user_email_or_id}/restore" + headers = { + "Content-type": "application/json" + } + ret = session.post(graph_url, headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + # Disable = reset password & sessions + def logout_user(self, tenant_id, client_id, client_secret, user_email_or_id): + + new_password = str(uuid.uuid4()) + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/users/{user_email_or_id}/revokeSignInSessions" + headers = { + "Content-type": "application/json" + } + ret = session.post(graph_url, headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + # Disable = reset password & sessions + def disable_user(self, tenant_id, client_id, client_secret, user_email_or_id): + + new_password = str(uuid.uuid4()) + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/users/{user_email_or_id}/revokeSignInSessions" + headers = { + "Content-type": "application/json" + } + ret = session.get(graph_url, headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code >= 300: + data = ret.json() + return data + + graph_url = f"https://graph.microsoft.com/v1.0/users/{user_email_or_id}/authentication/passwordMethods" + + ret = session.get(graph_url) + retdata = ret.json() + #return retdata + try: + if len(retdata["value"]) == 0: + return {"success": False, "reason": "Couldn't find any password methods to reset password, but DID revoke their sessions"} + except: + return {"success": False, "reason": "Couldn't find any password methods to reset password, but DID revoke their sessions (2)"} + + registered_password_id = retdata["value"][0]["id"] + graph_url = f"https://graph.microsoft.com/v1.0/users/{user_email_or_id}/authentication/passwordMethods/{registered_password_id}/resetPassword" + headers = { + "Content-type": "application/json" + } + + request_body = { + "newPassword": str(new_password) + } + + + ret = session.post(graph_url, json=request_body,headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code >= 300: + data = ret.json() + return data + + return {"success": True, "reason": "Stopped all active sessions and reset their password."} + + def get_user(self, tenant_id, client_id, client_secret, user_id, selected_fields=""): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = "https://graph.microsoft.com/v1.0/users?$filter=id eq '%s'" % user_id + if len(selected_fields) > 0: + graph_url += "&$select=%s" % selected_fields + + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + def list_users(self, tenant_id, client_id, client_secret): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = "https://graph.microsoft.com/v1.0/users" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + def list_groups(self, tenant_id, client_id, client_secret): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = "https://graph.microsoft.com/v1.0/groups" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + def list_group_members(self, tenant_id, client_id, client_secret, group_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = "https://graph.microsoft.com/v1.0/groups/%s/members" % group_id + + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + def list_administrative_units(self, tenant_id, client_id, client_secret): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = "https://graph.microsoft.com/v1.0/directory/administrativeUnits" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + + def get_administrative_units(self, tenant_id, client_id, client_secret,id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits/{id}" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def create_administrative_unit(self, tenant_id, client_id, client_secret, display_name, description, visibility): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits" + + request_body = { + "displayName": display_name, + "description": description, + "visibility": visibility + } + + ret = session.post(graph_url, json= request_body) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text, "error_response":ret.text} + + def list_administrative_unit_members(self, tenant_id, client_id, client_secret,administrative_unit_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits/{administrative_unit_id}/members" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + def get_administrative_unit_member(self, tenant_id, client_id, client_secret, administrative_unit_id, member_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits/{administrative_unit_id}/members/{member_id}" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + ## add member + def remove_administrative_unit_member(self, tenant_id, client_id, client_secret, administrative_unit_id, user_or_group_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directory/administrativeUnits/{administrative_unit_id}/members/{user_or_group_id}/$ref" + ret = session.delete(graph_url) + print(ret.status_code) + print(ret.text) + return ret.json() + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code,"error_response":ret.text} + + def list_risky_users(self, tenant_id, client_id, client_secret, amount=50, skip=0): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + if amount == 0 or amount == "": + amount = 50 + + if skip == 0 or skip == "": + skip = 0 + + #graph_url = f"https://graph.microsoft.com/v1.0/identityProtection/riskyUsers?$top=%d&$skip=%d" % (int(amount), int(skip)) + graph_url = f"https://graph.microsoft.com/v1.0/identityProtection/riskyUsers?$top=%d" % (int(amount)) + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} + + def get_risky_user(self, tenant_id, client_id, client_secret, risky_user_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/identityProtection/riskyUsers/{risky_user_id}" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def confirm_compromised_users(self, tenant_id, client_id, client_secret, risky_user_ids): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = "https://graph.microsoft.com/v1.0/identityProtection/riskyUsers/confirmCompromised" + + user_list = [str(user) for user in risky_user_ids.split(',')] + + request_body = { + "userIds": user_list + } + + ret = session.post(graph_url, json= request_body) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def dismiss_compromised_users(self, tenant_id, client_id, client_secret, risky_user_ids): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = "https://graph.microsoft.com/v1.0/identityProtection/riskyUsers/dismiss" + + user_list = [str(user) for user in risky_user_ids.split(',')] + + request_body = { + "userIds": user_list + } + + ret = session.post(graph_url, json= request_body) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def list_directory_role(self, tenant_id, client_id, client_secret): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = "https://graph.microsoft.com/v1.0/directoryRoles" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def list_directory_role_members(self, tenant_id, client_id, client_secret, directory_role_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directoryRoles/{directory_role_id}/members" + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def add_directory_role_members(self, tenant_id, client_id, client_secret, directory_role_id, user_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directoryRoles/{directory_role_id}/members/$ref" + + request_body = { + "@odata.id": f"https://graph.microsoft.com/v1.0/directoryObjects/{user_id}" + } + + ret = session.post(graph_url, json=request_body) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def remove_directory_role_members(self, tenant_id, client_id, client_secret, directory_role_id, user_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/directoryRoles/{directory_role_id}/members/$ref" + + request_body = { + "@odata.id": f"https://graph.microsoft.com/v1.0/directoryObjects/{user_id}" + } + + ret = session.delete(graph_url, json=request_body) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def delete_user(self, tenant_id, client_id, client_secret, user_email_or_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/v1.0/users/{user_email_or_id}" + + ret = session.delete(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def list_password_methods(self, tenant_id, client_id, client_secret, user_email_or_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}/authentication/passwordMethods" + + ret = session.get(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def reset_user_password(self, tenant_id, client_id, client_secret, user_email_or_id , registered_password_id, new_password): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}/authentication/passwordMethods/{registered_password_id}/resetPassword" + + headers = { + "Content-type": "application/json" + } + request_body = { + "newPassword": str(new_password) + } + + ret = session.post(graph_url, json=request_body,headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def disable_user_account(self, tenant_id, client_id, client_secret, user_email_or_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}" + + headers = { + "Content-type": "application/json" + } + request_body = { + "accountEnabled": "False" + } + + ret = session.patch(graph_url, json=request_body,headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def update_user_job_title(self, tenant_id, client_id, client_secret, user_email_or_id, user_job_title): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}" + + headers = { + "Content-type": "application/json" + } + request_body = { + "jobTitle": user_job_title + } + + ret = session.patch(graph_url, json=request_body,headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def update_user_department(self, tenant_id, client_id, client_secret, user_email_or_id, user_department): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}" + + headers = { + "Content-type": "application/json" + } + request_body = { + "department": user_department + } + + ret = session.patch(graph_url, json=request_body,headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def update_user_employee_type(self, tenant_id, client_id, client_secret, user_email_or_id, user_employee_type): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}" + + headers = { + "Content-type": "application/json" + } + request_body = { + "employeeType": user_employee_type + } + + ret = session.patch(graph_url, json=request_body,headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def update_user_leave_date(self, tenant_id, client_id, client_secret, user_email_or_id, user_leave_date): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}" + + headers = { + "Content-type": "application/json" + } + request_body = { + "employeeLeaveDateTime": user_leave_date + } + + ret = session.patch(graph_url, json=request_body,headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def get_user_direct_groups(self, tenant_id, client_id, client_secret, user_email_or_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/users/{user_email_or_id}/memberOf?$filter=NOT(groupTypes/any(c:c eq 'DynamicMembership'))&$count=true" + + headers = { + "ConsistencyType": "eventual" + } + + ret = session.get(graph_url,headers=headers) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + + def remove_user_from_group(self, tenant_id, client_id, client_secret, user_id, group_id): + graph_url = "https://graph.microsoft.com" + session = self.authenticate(tenant_id, client_id, client_secret, graph_url) + + graph_url = f"https://graph.microsoft.com/beta/groups/{group_id}/members/{user_id}/$ref" + + ret = session.delete(graph_url) + print(ret.status_code) + print(ret.text) + if ret.status_code < 300: + data = ret.json() + return data + + return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code, "error_response":ret.text} + +if __name__ == "__main__": + MsIdentityAccess.run() diff --git a/microsoft-intune/1.0.0/Dockerfile b/unsupported/microsoft-intune/1.0.0/Dockerfile similarity index 100% rename from microsoft-intune/1.0.0/Dockerfile rename to unsupported/microsoft-intune/1.0.0/Dockerfile diff --git a/microsoft-intune/1.0.0/README.md b/unsupported/microsoft-intune/1.0.0/README.md similarity index 100% rename from microsoft-intune/1.0.0/README.md rename to unsupported/microsoft-intune/1.0.0/README.md diff --git a/microsoft-intune/1.0.0/api.yaml b/unsupported/microsoft-intune/1.0.0/api.yaml similarity index 100% rename from microsoft-intune/1.0.0/api.yaml rename to unsupported/microsoft-intune/1.0.0/api.yaml diff --git a/unsupported/microsoft-intune/1.0.0/requirements.txt b/unsupported/microsoft-intune/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/microsoft-intune/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/microsoft-intune/1.0.0/src/app.py b/unsupported/microsoft-intune/1.0.0/src/app.py similarity index 100% rename from microsoft-intune/1.0.0/src/app.py rename to unsupported/microsoft-intune/1.0.0/src/app.py diff --git a/passivetotal/1.0.0/Dockerfile b/unsupported/microsoft-security-and-compliance/1.0.0/Dockerfile similarity index 100% rename from passivetotal/1.0.0/Dockerfile rename to unsupported/microsoft-security-and-compliance/1.0.0/Dockerfile diff --git a/microsoft-security-and-compliance/1.0.0/README.md b/unsupported/microsoft-security-and-compliance/1.0.0/README.md similarity index 100% rename from microsoft-security-and-compliance/1.0.0/README.md rename to unsupported/microsoft-security-and-compliance/1.0.0/README.md diff --git a/microsoft-security-and-compliance/1.0.0/api.yaml b/unsupported/microsoft-security-and-compliance/1.0.0/api.yaml similarity index 99% rename from microsoft-security-and-compliance/1.0.0/api.yaml rename to unsupported/microsoft-security-and-compliance/1.0.0/api.yaml index d7f0b2fc..b534f60a 100644 --- a/microsoft-security-and-compliance/1.0.0/api.yaml +++ b/unsupported/microsoft-security-and-compliance/1.0.0/api.yaml @@ -92,7 +92,7 @@ actions: - name: get_alert_by_id description: Returns an alert by id parameters: - - name: id + - name: alert_id description: Alert id multiline: false example: "1" diff --git a/unsupported/microsoft-security-and-compliance/1.0.0/requirements.txt b/unsupported/microsoft-security-and-compliance/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/microsoft-security-and-compliance/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/microsoft-security-and-compliance/1.0.0/src/app.py b/unsupported/microsoft-security-and-compliance/1.0.0/src/app.py similarity index 99% rename from microsoft-security-and-compliance/1.0.0/src/app.py rename to unsupported/microsoft-security-and-compliance/1.0.0/src/app.py index 2e0a0c90..77b45cb8 100644 --- a/microsoft-security-and-compliance/1.0.0/src/app.py +++ b/unsupported/microsoft-security-and-compliance/1.0.0/src/app.py @@ -141,7 +141,7 @@ def get_alerts_by_vendors(self, tenant_id, client_id, client_secret, vendor, top return {"success": False, "reason": "Bad status code %d - expecting 200." % ret.status_code} - def get_alert_by_id(self, tenant_id, client_id, client_secret,alert_id): + def get_alert_by_id(self, tenant_id, client_id, client_secret, alert_id): graph_url = "https://graph.microsoft.com" session = self.authenticate(tenant_id, client_id, client_secret, graph_url) diff --git a/microsoft-security-oauth2/1.0.0/Dockerfile b/unsupported/microsoft-security-oauth2/1.0.0/Dockerfile similarity index 100% rename from microsoft-security-oauth2/1.0.0/Dockerfile rename to unsupported/microsoft-security-oauth2/1.0.0/Dockerfile diff --git a/microsoft-security-oauth2/1.0.0/api.yaml b/unsupported/microsoft-security-oauth2/1.0.0/api.yaml similarity index 100% rename from microsoft-security-oauth2/1.0.0/api.yaml rename to unsupported/microsoft-security-oauth2/1.0.0/api.yaml diff --git a/unsupported/microsoft-security-oauth2/1.0.0/requirements.txt b/unsupported/microsoft-security-oauth2/1.0.0/requirements.txt new file mode 100644 index 00000000..bd6f2345 --- /dev/null +++ b/unsupported/microsoft-security-oauth2/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 diff --git a/microsoft-security-oauth2/1.0.0/src/app.py b/unsupported/microsoft-security-oauth2/1.0.0/src/app.py similarity index 93% rename from microsoft-security-oauth2/1.0.0/src/app.py rename to unsupported/microsoft-security-oauth2/1.0.0/src/app.py index a282d0da..77d425d2 100644 --- a/microsoft-security-oauth2/1.0.0/src/app.py +++ b/unsupported/microsoft-security-oauth2/1.0.0/src/app.py @@ -2,16 +2,11 @@ # -*- coding: utf-8 -*- import asyncio -import time -import random import json -import requests -import thehive4py - -from thehive4py.api import TheHiveApi -from thehive4py.query import * -import thehive4py.models +import random +import time +import requests from walkoff_app_sdk.app_base import AppBase class MicrosoftSecurity(AppBase): diff --git a/python3-playground/1.0.0/Dockerfile b/unsupported/microsoft-teams-system-access/1.0.0/Dockerfile similarity index 100% rename from python3-playground/1.0.0/Dockerfile rename to unsupported/microsoft-teams-system-access/1.0.0/Dockerfile diff --git a/microsoft-teams-system-access/1.0.0/README.md b/unsupported/microsoft-teams-system-access/1.0.0/README.md similarity index 100% rename from microsoft-teams-system-access/1.0.0/README.md rename to unsupported/microsoft-teams-system-access/1.0.0/README.md diff --git a/microsoft-teams-system-access/1.0.0/api.yaml b/unsupported/microsoft-teams-system-access/1.0.0/api.yaml similarity index 100% rename from microsoft-teams-system-access/1.0.0/api.yaml rename to unsupported/microsoft-teams-system-access/1.0.0/api.yaml diff --git a/unsupported/microsoft-teams-system-access/1.0.0/requirements.txt b/unsupported/microsoft-teams-system-access/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/microsoft-teams-system-access/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/microsoft-teams-system-access/1.0.0/src/app.py b/unsupported/microsoft-teams-system-access/1.0.0/src/app.py similarity index 100% rename from microsoft-teams-system-access/1.0.0/src/app.py rename to unsupported/microsoft-teams-system-access/1.0.0/src/app.py diff --git a/recordedfuture/1.0.0/Dockerfile b/unsupported/microsoft-teams/1.0.0/Dockerfile similarity index 100% rename from recordedfuture/1.0.0/Dockerfile rename to unsupported/microsoft-teams/1.0.0/Dockerfile diff --git a/microsoft-teams/1.0.0/MicrosoftTeams-image.png b/unsupported/microsoft-teams/1.0.0/MicrosoftTeams-image.png similarity index 100% rename from microsoft-teams/1.0.0/MicrosoftTeams-image.png rename to unsupported/microsoft-teams/1.0.0/MicrosoftTeams-image.png diff --git a/microsoft-teams/1.0.0/README.md b/unsupported/microsoft-teams/1.0.0/README.md similarity index 100% rename from microsoft-teams/1.0.0/README.md rename to unsupported/microsoft-teams/1.0.0/README.md diff --git a/microsoft-teams/1.0.0/api.yaml b/unsupported/microsoft-teams/1.0.0/api.yaml similarity index 100% rename from microsoft-teams/1.0.0/api.yaml rename to unsupported/microsoft-teams/1.0.0/api.yaml diff --git a/unsupported/microsoft-teams/1.0.0/requirements.txt b/unsupported/microsoft-teams/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/microsoft-teams/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/microsoft-teams/1.0.0/src/app.py b/unsupported/microsoft-teams/1.0.0/src/app.py similarity index 100% rename from microsoft-teams/1.0.0/src/app.py rename to unsupported/microsoft-teams/1.0.0/src/app.py diff --git a/microsoft-teams/1.0.0/src/teams.py b/unsupported/microsoft-teams/1.0.0/src/teams.py similarity index 100% rename from microsoft-teams/1.0.0/src/teams.py rename to unsupported/microsoft-teams/1.0.0/src/teams.py diff --git a/unsupported/misp/1.0.0/requirements.txt b/unsupported/misp/1.0.0/requirements.txt index fd7d3e06..480d0c4b 100644 --- a/unsupported/misp/1.0.0/requirements.txt +++ b/unsupported/misp/1.0.0/requirements.txt @@ -1 +1 @@ -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/unsupported/nlp/1.0.0/requirements.txt b/unsupported/nlp/1.0.0/requirements.txt index ade97173..43e5970b 100644 --- a/unsupported/nlp/1.0.0/requirements.txt +++ b/unsupported/nlp/1.0.0/requirements.txt @@ -1,4 +1,4 @@ cyberspacy==1.1.1 tika==1.24 -requests==2.25.1 +requests==2.32.4 spacy==2.3.5 diff --git a/unsupported/office365mgmt/1.0.0/requirements.txt b/unsupported/office365mgmt/1.0.0/requirements.txt index 2f1d3e7f..73f08b38 100644 --- a/unsupported/office365mgmt/1.0.0/requirements.txt +++ b/unsupported/office365mgmt/1.0.0/requirements.txt @@ -1,2 +1,2 @@ # No extra requirements needed -request +requests==2.32.4 diff --git a/servicenow/1.0.0/Dockerfile b/unsupported/passivetotal/1.0.0/Dockerfile similarity index 100% rename from servicenow/1.0.0/Dockerfile rename to unsupported/passivetotal/1.0.0/Dockerfile diff --git a/passivetotal/1.0.0/api.yaml b/unsupported/passivetotal/1.0.0/api.yaml similarity index 100% rename from passivetotal/1.0.0/api.yaml rename to unsupported/passivetotal/1.0.0/api.yaml diff --git a/unsupported/passivetotal/1.0.0/requirements.txt b/unsupported/passivetotal/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/passivetotal/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/passivetotal/1.0.0/src/app.py b/unsupported/passivetotal/1.0.0/src/app.py similarity index 100% rename from passivetotal/1.0.0/src/app.py rename to unsupported/passivetotal/1.0.0/src/app.py diff --git a/testing/1.0.0/Dockerfile b/unsupported/recordedfuture/1.0.0/Dockerfile similarity index 100% rename from testing/1.0.0/Dockerfile rename to unsupported/recordedfuture/1.0.0/Dockerfile diff --git a/recordedfuture/1.0.0/api.yaml b/unsupported/recordedfuture/1.0.0/api.yaml similarity index 100% rename from recordedfuture/1.0.0/api.yaml rename to unsupported/recordedfuture/1.0.0/api.yaml diff --git a/unsupported/recordedfuture/1.0.0/requirements.txt b/unsupported/recordedfuture/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/recordedfuture/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/recordedfuture/1.0.0/src/app.py b/unsupported/recordedfuture/1.0.0/src/app.py similarity index 100% rename from recordedfuture/1.0.0/src/app.py rename to unsupported/recordedfuture/1.0.0/src/app.py diff --git a/twitter/1.0.0/Dockerfile b/unsupported/servicenow/1.0.0/Dockerfile similarity index 100% rename from twitter/1.0.0/Dockerfile rename to unsupported/servicenow/1.0.0/Dockerfile diff --git a/servicenow/1.0.0/api.yaml b/unsupported/servicenow/1.0.0/api.yaml similarity index 100% rename from servicenow/1.0.0/api.yaml rename to unsupported/servicenow/1.0.0/api.yaml diff --git a/unsupported/servicenow/1.0.0/requirements.txt b/unsupported/servicenow/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/servicenow/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/servicenow/1.0.0/src/app.py b/unsupported/servicenow/1.0.0/src/app.py similarity index 100% rename from servicenow/1.0.0/src/app.py rename to unsupported/servicenow/1.0.0/src/app.py diff --git a/unsupported/shuffle-subflow/1.0.0/requirements.txt b/unsupported/shuffle-subflow/1.0.0/requirements.txt index fd7d3e06..480d0c4b 100644 --- a/unsupported/shuffle-subflow/1.0.0/requirements.txt +++ b/unsupported/shuffle-subflow/1.0.0/requirements.txt @@ -1 +1 @@ -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/shuffle-tools/1.0.0/Dockerfile b/unsupported/sophosxgfirewall/1.0.0/Dockerfile similarity index 100% rename from shuffle-tools/1.0.0/Dockerfile rename to unsupported/sophosxgfirewall/1.0.0/Dockerfile diff --git a/unsupported/sophosxgfirewall/1.0.0/README.md b/unsupported/sophosxgfirewall/1.0.0/README.md new file mode 100644 index 00000000..e69de29b diff --git a/unsupported/sophosxgfirewall/1.0.0/api.yaml b/unsupported/sophosxgfirewall/1.0.0/api.yaml new file mode 100644 index 00000000..96768cf5 --- /dev/null +++ b/unsupported/sophosxgfirewall/1.0.0/api.yaml @@ -0,0 +1,2472 @@ +actions: +- description: 'Lists all firewall rules. IMPORTANT: The list starts at 0 (not 1)!' + name: sophos_firewall_rule_list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single firewall rule by name. + name: sophos-firewall-rule-get + parameters: + - description: Name of the rule to get. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Adds a new firewall rule. + name: sophos_firewall_rule_add + parameters: + - description: Name of the new rule. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the new rule. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the new rule. Possible values: "Enable" and "Disable". + Default is "Enable".' + example: Enable + name: status + required: false + schema: + type: string + value: Enable + - description: 'The IP family. Possible values: "IPv4" and "IPv6". Default is "IPv4".' + example: IPv4 + name: ip_family + required: false + schema: + type: string + value: IPv4 + - description: 'The position of the new rule in the list. Possible values: "top", + "bottom", "before", and "after". If "before" or "after" is selected, you must + provide a value for the position_policy_name argument.' + example: '' + name: position + required: true + schema: + type: string + value: '' + - description: The name of the policy that the rule should be created before or + after. This argument is required when the value of the position argument is + "before" or "after". + example: '' + name: position_policy_name + required: false + schema: + type: string + value: '' + - description: 'Policy type of the new rule. Possible values: "User" and "Network".' + example: '' + name: policy_type + required: true + schema: + type: string + value: '' + - description: 'Source zones to add to the rule. Possible values: "Any", "LAN". + "WAN", "VPN", "DMZ", and "WiFi".' + example: '' + name: source_zones + required: false + schema: + type: string + value: '' + - description: Source networks to add to the rule. + example: '' + name: source_networks + required: false + schema: + type: string + value: '' + - description: 'Destination zones to add to the rule. Possible values: "Any", "LAN". + "WAN", "VPN", "DMZ", and "WiFi".' + example: '' + name: destination_zones + required: false + schema: + type: string + value: '' + - description: Destination networks to add to the rule. + example: '' + name: destination_networks + required: false + schema: + type: string + value: '' + - description: Destination services to add to the rule. + example: '' + name: services + required: false + schema: + type: string + value: '' + - description: 'The schedule for the rule. Possible values: "All the time", "Work + hours (5 Day week)", "Work hours (6 Day week)", "All Time on Weekdays", "All + Time on Weekends", "All Time on Sunday", "All Days 10:00 to 19:00". IMPORTANT: + Creating a new schedule is available from the web console.' + example: '' + name: schedule + required: false + schema: + type: string + value: '' + - description: 'Whether to enable traffic logging for the policy. Possible values: + "Enable" and "Disable". Default is "Disable".' + example: Disable + name: log_traffic + required: false + schema: + type: string + value: Disable + - description: 'Whether to check if the specified user/user group from the\ \ selected + zone is allowed to access the selected service. Possible values: "Enable" and + "Disable". Default is "Disable". When enabling match_identity, the members argument + is required.' + example: Disable + name: match_identity + required: false + schema: + type: string + value: Disable + - description: 'Whether to accept traffic from unknown users. The captive portal + page\ \ is displayed to the user where the user can log in to access the Internet.\ + \ Possible values: "Enable" and "Disable". Default is "Disable". To enable this + argument, the match_identity argument must be enabled and the value of the policy_type + is "User".' + example: Disable + name: show_captive_portal + required: false + schema: + type: string + value: Disable + - description: An existing user(s) or group(s) to add to the rule. This argument + is required when match_identity is enabled. + example: '' + name: members + required: false + schema: + type: string + value: '' + - description: 'Action for the rule traffic. Possible values: "Accept", "Reject", + and "Drop". Default is "Drop".' + example: Drop + name: action + required: false + schema: + type: string + value: Drop + - description: The DSCP marking level to classify the flow of packets based on the + Traffic Shaping policy. + example: '' + name: dscp_marking + required: false + schema: + type: string + value: '' + - description: The primary gateway. Applicable only in case of multiple gateways. + example: '' + name: primary_gateway + required: false + schema: + type: string + value: '' + - description: The backup gateway. Applicable only in case of multiple gateways. + example: '' + name: backup_gateway + required: false + schema: + type: string + value: '' + - description: The Application Filter policy for the rule. Default is "Allow All". + example: Allow All + name: application_control + required: false + schema: + type: string + value: Allow All + - description: 'Whether to limit the bandwidth for the applications categorized\ + \ under the Application category. This tag is only applicable when\ \ an application_control + is selected. Possible values: "Apply" and "Revoke". Default is "Revoke".' + example: Revoke + name: application_based_qos_policy + required: false + schema: + type: string + value: Revoke + - description: The Web Filter policy for the rule. Default is "Allow All". + example: Allow All + name: web_filter + required: false + schema: + type: string + value: Allow All + - description: 'Whether to limit the bandwidth for the URLs categorized under the + Web\ \ category. This tag is only applicable when a web_filter is defined." + Possible values: "Apply" and "Revoke". Default is "Revoke".' + example: Revoke + name: web_category_base_qos_policy + required: false + schema: + type: string + value: Revoke + - description: The Traffic Shaping policy for the rule. Default is "None". + example: None + name: traffic_shaping_policy + required: false + schema: + type: string + value: None + - description: 'Whether to enable virus and spam scanning for the HTTP protocol. + Possible values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: scan_http + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable virus and spam scanning for the HTTPS protocol. + Possible values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: scan_https + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable sandstorm analysis. Possible values: "Enable" + and "Disable". Default is "Disable".' + example: Disable + name: sandstorm + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable Google websites to use HTTP/s instead of QUICK + QUIC. Possible values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: block_quick_quic + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable scanning of FTP traffic. Possible values: "Enable" + and "Disable". Default is "Disable".' + example: Disable + name: scan_ftp + required: false + schema: + type: string + value: Disable + - description: 'Whether to exclude a user''s network traffic from data accounting. + This option is available only if the match_identity argument is enabled. Possible + values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: data_accounting + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable the NAT policy. Possible values: "Enable" and + "Disable". Default is "Enable".' + example: Enable + name: rewrite_source_address + required: false + schema: + type: string + value: Enable + - description: 'Whether to enable the Internet scheme to apply the user-based Web + Filter policy for the rule. Possible values: "Enable" and "Disable". Default + is "Disable".' + example: Disable + name: web_filter_internet_scheme + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable the Internet scheme to apply user-based Application + Filter policy for the rule. Possible values: "Enable" and "Disable". Default + is "Disable".' + example: Disable + name: application_control_internet_scheme + required: false + schema: + type: string + value: Disable + - description: 'Whether to override the gateway of the default NAT policy. Possible + values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: override_gateway_default_nat_policy + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable the source security heartbeat. Possible values: + "Enable" and "Disable". Default is "Disable".' + example: Disable + name: source_security_heartbeat + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable the destination security heartbeat. Possible values: + "Enable" and "Disable". Default is "Disable".' + example: Disable + name: destination_security_heartbeat + required: false + schema: + type: string + value: Disable + - description: The NAT policy to apply. Default is "MASQ". + example: MASQ + name: outbound_address + required: false + schema: + type: string + value: MASQ + - description: The minimum source health status permitted. Default is "No Restriction". + example: No Restriction + name: minimum_source_hb_permitted + required: false + schema: + type: string + value: No Restriction + - description: The minimum destination health status permitted. Default is "No Restriction". + example: No Restriction + name: minimum_destination_hb_permitted + required: false + schema: + type: string + value: No Restriction + - description: The IPS policy for the rule. Default is "generalpolicy". + example: generalpolicy + name: intrusion_prevention + required: false + schema: + type: string + value: generalpolicy + returns: + example: '' +- description: Updates an existing firewall rule. + name: sophos-firewall-rule-update + parameters: + - description: Name of the new rule. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the new rule. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'Whether the rule is enabled. Possible values: "Enable" and "Disable". + Default is "Enable".' + example: Enable + name: status + required: false + schema: + type: string + value: Enable + - description: 'The IP family. Possible values: "IPv4" and "IPv6". Default is "IPv4".' + example: IPv4 + name: ip_family + required: false + schema: + type: string + value: IPv4 + - description: 'The position of the new rule in the list. Possible values: "top", + "bottom", "before", and "after". If "before" or "after" is selected, you must + provide a value for the position_policy_name argument.' + example: '' + name: position + required: false + schema: + type: string + value: '' + - description: The name of the policy that the rule should be created before or + after. This argument is required when the value of the position argument is + "before" or "after". + example: '' + name: position_policy_name + required: false + schema: + type: string + value: '' + - description: 'Policy type of the new rule. Possible values: "User" and "Network".' + example: '' + name: policy_type + required: false + schema: + type: string + value: '' + - description: 'Source zones to add to the rule. Possible values: "Any", "LAN". + "WAN", "VPN", "DMZ", and "WiFi".' + example: '' + name: source_zones + required: false + schema: + type: string + value: '' + - description: Source networks to add to the rule. + example: '' + name: source_networks + required: false + schema: + type: string + value: '' + - description: 'Destination zones to add to the rule. Possible values: "Any", "LAN". + "WAN", "VPN", "DMZ", and "WiFi".' + example: '' + name: destination_zones + required: false + schema: + type: string + value: '' + - description: Destination networks to add to the rule. + example: '' + name: destination_networks + required: false + schema: + type: string + value: '' + - description: Destination services to add to the rule. + example: '' + name: services + required: false + schema: + type: string + value: '' + - description: 'The schedule for the rule. Possible values: "All the time", "Work + hours (5 Day week)", "Work hours (6 Day week)", "All Time on Weekdays", "All + Time on Weekends", "All Time on Sunday", "All Days 10:00 to 19:00". IMPORTANT: + Creating a new schedule is available in the web console.' + example: '' + name: schedule + required: false + schema: + type: string + value: '' + - description: 'Whether to enable traffic logging for the policy. Possible values: + "Enable" and "Disable". Default is "Disable".' + example: Disable + name: log_traffic + required: false + schema: + type: string + value: Disable + - description: 'Whether to check if the specified user/user group from the\ \ selected + zone is allowed to access the selected service. Possible values: "Enable" and + "Disable". Default is "Disable". IMPORTANT: When enabling match_identity, the + members argument is required.' + example: Disable + name: match_identity + required: false + schema: + type: string + value: Disable + - description: 'Whether to accept traffic from unknown users. The captive portal + page\ \ is displayed to the user where the user can log in to access the Internet.\ + \ Possible values: "Enable" and "Disable". Default is "Disable". To enable this + argument, the match_identity argument must be enabled and the value of the policy_type + is "User".' + example: Disable + name: show_captive_portal + required: false + schema: + type: string + value: Disable + - description: An existing user(s) or group(s) to add to the rule. This argument + is required when match_identity is enabled. + example: '' + name: members + required: false + schema: + type: string + value: '' + - description: 'Action for the rule traffic. Possible values: "Accept", "Reject", + and "Drop". Default is "Drop".' + example: Drop + name: action + required: false + schema: + type: string + value: Drop + - description: The DSCP marking level to classify the flow of packets based on the + Traffic Shaping policy. + example: '' + name: dscp_marking + required: false + schema: + type: string + value: '' + - description: The primary gateway. Applicable only in case of multiple gateways. + example: '' + name: primary_gateway + required: false + schema: + type: string + value: '' + - description: The backup gateway. Applicable only in case of multiple gateways. + example: '' + name: backup_gateway + required: false + schema: + type: string + value: '' + - description: The Application Filter policy for the rule. Default is "Allow All". + example: Allow All + name: application_control + required: false + schema: + type: string + value: Allow All + - description: 'Whether to limit the bandwidth for the applications categorized\ + \ under the Application category. This tag is only applicable when\ \ an application_control + is selected. Possible values: "Apply" and "Revoke". Default is "Revoke".' + example: Revoke + name: application_based_qos_policy + required: false + schema: + type: string + value: Revoke + - description: The Web Filter policy for the rule. Default is "Allow All". + example: Allow All + name: web_filter + required: false + schema: + type: string + value: Allow All + - description: 'Whether to limit the bandwidth for the URLs categorized under the + Web\ \ category. This tag is only applicable when a web_filter is defined." + Possible values: "Apply" and "Revoke". Default is "Revoke".' + example: Revoke + name: web_category_base_qos_policy + required: false + schema: + type: string + value: Revoke + - description: The Traffic Shaping policy for the rule. Default is "None". + example: None + name: traffic_shaping_policy + required: false + schema: + type: string + value: None + - description: 'Whether to enable virus and spam scanning for HTTP protocol. Possible + values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: scan_http + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable virus and spam scanning for HTTPS protocol. Possible + values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: scan_https + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable sandstorm analysis. Possible values: "Enable" + and "Disable". Default is "Disable".' + example: Disable + name: sandstorm + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable Google websites to use HTTP/s instead of QUICK + QUIC. Possible values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: block_quick_quic + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable scanning of FTP traffic. Possible values: "Enable" + and "Disable". Default is "Disable".' + example: Disable + name: scan_ftp + required: false + schema: + type: string + value: Disable + - description: 'Whether to exclude a user''s network traffic from data accounting. + This option is available only if the match_identity argument is enabled. Possible + values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: data_accounting + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable the NAT policy. Possible values: "Enable" and + "Disable". Default is "Enable".' + example: Enable + name: rewrite_source_address + required: false + schema: + type: string + value: Enable + - description: 'Whether to enable the Internet scheme to apply the user-based Web + Filter policy for the rule. Possible values: "Enable" and "Disable". Default + is "Disable".' + example: Disable + name: web_filter_internet_scheme + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable the Internet scheme to apply user-based Application + Filter Policy for the rule. Possible values: "Enable" and "Disable". Default + is "Disable".' + example: Disable + name: application_control_internet_scheme + required: false + schema: + type: string + value: Disable + - description: 'Whether to override the gateway of the default NAT policy. Possible + values: "Enable" and "Disable". Default is "Disable".' + example: Disable + name: override_gateway_default_nat_policy + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable the source security heartbeat. Possible values: + "Enable" and "Disable". Default is "Disable".' + example: Disable + name: source_security_heartbeat + required: false + schema: + type: string + value: Disable + - description: 'Whether to enable the destination security heartbeat. Possible values: + "Enable" and "Disable". Default is "Disable".' + example: Disable + name: destination_security_heartbeat + required: false + schema: + type: string + value: Disable + - description: The NAT policy to be applied. Default is "MASQ". + example: MASQ + name: outbound_address + required: false + schema: + type: string + value: MASQ + - description: The minimum source health status permitted. Default is "No Restriction". + example: No Restriction + name: minimum_source_hb_permitted + required: false + schema: + type: string + value: No Restriction + - description: The minimum destination health status permitted. Default is "No Restriction". + example: No Restriction + name: minimum_destination_hb_permitted + required: false + schema: + type: string + value: No Restriction + - description: The IPS policy for the rule. Default is "generalpolicy". + example: generalpolicy + name: intrusion_prevention + required: false + schema: + type: string + value: generalpolicy + returns: + example: '' +- description: Deletes an existing firewall rule. + name: sophos-firewall-rule-delete + parameters: + - description: Name of the rule. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all firewall rule groups. IMPORTANT: The list starts at 0 (not + 1)!' + name: sophos-firewall-rule-group-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single firewall rule group by name. + name: sophos-firewall-rule-group-get + parameters: + - description: Name of the firewall rule group. + example: '' + name: name + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Adds a new firewall rule group. + name: sophos-firewall-rule-group-add + parameters: + - description: Name of the rule group. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the rule group. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'Type of the rules (policies) inside the group. Possible values: + "Any", "User/network rule", "User rule", and "Business application rule".' + example: '' + name: policy_type + required: false + schema: + type: string + value: '' + - description: Rules contained in the group. + example: '' + name: rules + required: false + schema: + type: string + value: '' + - description: 'Source zones contained in the group. Possible values: "Any", "LAN", + "WAN", "VPN", "DMZ", and "WiFi.' + example: '' + name: source_zones + required: false + schema: + type: string + value: '' + - description: 'Destination zones contained in the group. Possible values: "Any", + "LAN", "WAN", "VPN", "DMZ", and "WiFi.' + example: '' + name: destination_zones + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Updates an existing firewall rule group. + name: sophos-firewall-rule-group-update + parameters: + - description: Name of the rule group. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the rule group. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'Type of the rules (policies) inside the group. Possible values: + "Any", "User/network rule", "User rule", and "Business application rule".' + example: '' + name: policy_type + required: false + schema: + type: string + value: '' + - description: Rules contained in the group. + example: '' + name: rules + required: false + schema: + type: string + value: '' + - description: 'Source zones contained in the group. Possible values: "Any", "LAN", + "WAN", "VPN", "DMZ", and "WiFi.' + example: '' + name: source_zones + required: false + schema: + type: string + value: '' + - description: 'Destination zones contained in the group. Possible values: "Any", + "LAN", "WAN", "VPN", "DMZ", and "WiFi.' + example: '' + name: destination_zones + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Deletes an existing firewall group. + name: sophos-firewall-rule-group-delete + parameters: + - description: Name of the group. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all URL groups. IMPORTANT: The list starts at 0 (not 1)!' + name: sophos-firewall-url-group-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single URL group by name. + name: sophos-firewall-url-group-get + parameters: + - description: Name of the group. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Adds new URLs to the group. + name: sophos-firewall-url-group-add + parameters: + - description: Name of the group. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the group. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: Comma-separated list of URLs to add to the group. + example: '' + name: urls + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Updates an existing URL group. + name: sophos-firewall-url-group-update + parameters: + - description: Name of the group. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the group. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: Comma-separated list of URLs to add to the group. + example: '' + name: urls + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Deletes an existing URL group or groups. + name: sophos-firewall-url-group-delete + parameters: + - description: Name of the group(s). + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all IP hosts. IMPORTANT: The list starts at 0 (not 1)!' + name: sophos-firewall-ip-host-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single IP host by name. + name: sophos-firewall-ip-host-get + parameters: + - description: Name of the IP host. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Adds a new IP host. + name: sophos-firewall-ip-host-add + parameters: + - description: Name of the IP host. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: 'Type of the host. Possible values: "IP", "Network", "IPRange", and + "IPList".' + example: '' + name: host_type + required: true + schema: + type: string + value: '' + - description: 'The IP family. Possible values: "IPv4" and "IPv6". Default is "IPv4".' + example: IPv4 + name: ip_family + required: false + schema: + type: string + value: IPv4 + - description: IP address if IP or Network was the chosen host_type. + example: '' + name: ip_address + required: false + schema: + type: string + value: '' + - description: Subnet mask if Network was the chosen host_type. + example: '' + name: subnet_mask + required: false + schema: + type: string + value: '' + - description: Start of the IP range if IPRange was the chosen host_type. + example: '' + name: start_ip + required: false + schema: + type: string + value: '' + - description: End of the IP range if IPRange was the chosen host_type. + example: '' + name: end_ip + required: false + schema: + type: string + value: '' + - description: List of IP addresses if IPList was the chosen host_type. + example: '' + name: ip_addresses + required: false + schema: + type: string + value: '' + - description: Select the host group to which the host belongs. + example: '' + name: host_group + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Updates an existing IP host. + name: sophos-firewall-ip-host-update + parameters: + - description: Name of the IP host. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: 'Type of the host. Possible values: "IP", "Network", "IPRange", and + "IPList".' + example: '' + name: host_type + required: false + schema: + type: string + value: '' + - description: 'The IP family. Possible values: "IPv4" and "IPv6". Default is "IPv4".' + example: IPv4 + name: ip_family + required: false + schema: + type: string + value: IPv4 + - description: IP address if IP or Network was the chosen host_type. + example: '' + name: ip_address + required: false + schema: + type: string + value: '' + - description: Subnet mask if Network was the chosen host_type. + example: '' + name: subnet_mask + required: false + schema: + type: string + value: '' + - description: Start of the IP range if IPRange was the chosen host_type. + example: '' + name: start_ip + required: false + schema: + type: string + value: '' + - description: End of the IP range if IPRange was the chosen host_type. + example: '' + name: end_ip + required: false + schema: + type: string + value: '' + - description: List of IP addresses if IPList was the chosen host_type. + example: '' + name: ip_addresses + required: false + schema: + type: string + value: '' + - description: Select the host group to which the host belongs. + example: '' + name: host_group + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Deletes an existing IP host. + name: sophos-firewall-ip-host-delete + parameters: + - description: Name of the host. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all IP host groups. IMPORTANT: The list starts at 0 (not 1)!' + name: sophos-firewall-ip-host-group-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single IP host group by name. + name: sophos-firewall-ip-host-group-get + parameters: + - description: Name of the IP host group. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Adds a new IP host group. + name: sophos-firewall-ip-host-group-add + parameters: + - description: Name of the IP host group. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the IP host group. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'The IP family. Possible values: "IPv4" and "IPv6".' + example: '' + name: ip_family + required: false + schema: + type: string + value: '' + - description: IP hosts contained in the group. Must be hosts that exist in the + system. + example: '' + name: hosts + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Updates an existing IP host group. + name: sophos-firewall-ip-host-group-update + parameters: + - description: Name of the IP host group. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the IP host group. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'The IP family. Possible values: "IPv4" and "IPv6".' + example: '' + name: ip_family + required: false + schema: + type: string + value: '' + - description: IP hosts contained in the group. Must be hosts that exist in the + system. + example: '' + name: hosts + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Deletes an existing IP host group. + name: sophos-firewall-ip-host-group-delete + parameters: + - description: Name of the group. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all firewall services. IMPORTANT: The list starts at 0 (not + 1)!' + name: sophos-firewall-services-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single service by name. + name: sophos-firewall-services-get + parameters: + - description: Name of the firewall service. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Adds a new firewall service. + name: sophos-firewall-services-add + parameters: + - description: Name of the firewall service. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: 'Type of service. Possible values: "TCPorUDP", "IP", "ICMP", and + "ICMPv6".' + example: '' + name: service_type + required: true + schema: + type: string + value: '' + - description: 'The protocol for the service if service_type is TCPorUDP. Possible + values: "TCP" and "UDP".' + example: '' + name: protocol + required: false + schema: + type: string + value: '' + - description: Source port if service_type is TCPorUDP. + example: '' + name: source_port + required: false + schema: + type: string + value: '' + - description: Destination port if service_type is TCPorUDP. + example: '' + name: destination_port + required: false + schema: + type: string + value: '' + - description: Protocol name if service_type is IP. + example: '' + name: protocol_name + required: false + schema: + type: string + value: '' + - description: ICMP type if service_type is ICMP. + example: '' + name: icmp_type + required: false + schema: + type: string + value: '' + - description: ICMP code if service_type is ICMP. + example: '' + name: icmp_code + required: false + schema: + type: string + value: '' + - description: ICMPv6 type if service_type is ICMPv6. + example: '' + name: icmp_v6_type + required: false + schema: + type: string + value: '' + - description: ICMPv6 code if service_type is ICMPv6. + example: '' + name: icmp_v6_code + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Updates an existing firewall service. + name: sophos-firewall-services-update + parameters: + - description: Name of the firewall service. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: 'Type of service. Possible values: "TCPorUDP", "IP", "ICMP", and + "ICMPv6".' + example: '' + name: service_type + required: false + schema: + type: string + value: '' + - description: 'The protocol for the service if service_type is TCPorUDP. Possible + values: "TCP" and "UDP".' + example: '' + name: protocol + required: false + schema: + type: string + value: '' + - description: Source port if service_type is TCPorUDP. + example: '' + name: source_port + required: false + schema: + type: string + value: '' + - description: Destination port if service_type is TCPorUDP. + example: '' + name: destination_port + required: false + schema: + type: string + value: '' + - description: Protocol name if service_type is IP. + example: '' + name: protocol_name + required: false + schema: + type: string + value: '' + - description: ICMP type if service_type is ICMP. + example: '' + name: icmp_type + required: false + schema: + type: string + value: '' + - description: ICMP code if service_type is ICMP. + example: '' + name: icmp_code + required: false + schema: + type: string + value: '' + - description: ICMPv6 type if service_type is ICMPv6. + example: '' + name: icmp_v6_type + required: false + schema: + type: string + value: '' + - description: ICMPv6 code if service_type is ICMPv6. + example: '' + name: icmp_v6_code + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Deletes an existing firewall service. + name: sophos-firewall-services-delete + parameters: + - description: Name of the service. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all users. IMPORTANT: The list starts at 0 (not 1)!' + name: sophos-firewall-user-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single user by name. + name: sophos-firewall-user-get + parameters: + - description: Name of the user. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Adds a new user. + name: sophos-firewall-user-add + parameters: + - description: Username of the user. + example: '' + name: username + required: true + schema: + type: string + value: '' + - description: Name of the user. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the user. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: Email of the user. + example: '' + name: email + required: true + schema: + type: string + value: '' + - description: Group of the user. Default is "Guest Group". + example: Guest Group + name: group + required: false + schema: + type: string + value: Guest Group + - description: The password of the user. + example: '' + name: password + required: true + schema: + type: string + value: '' + - description: 'The type of the user. Possible values: "Administrator" and "User". + Default is "User".' + example: User + name: user_type + required: false + schema: + type: string + value: User + - description: 'Profile of the administrator if user_type is Administrator. Possible + values: "Administrator", "Crypto Admin", "Security Admin", "Audit Admin", and + "HAProfile". IMPORTANT: You can add more types in the web console.' + example: '' + name: profile + required: false + schema: + type: string + value: '' + - description: The Surfing Quota policy. Default is "Unlimited Internet Access". + example: Unlimited Internet Access + name: surfing_quota_policy + required: false + schema: + type: string + value: Unlimited Internet Access + - description: The Access Time policy. Default is "Allowed all the time". + example: Allowed all the time + name: access_time_policy + required: false + schema: + type: string + value: Allowed all the time + - description: The SSL VPN policy. Default is "No Policy Applied". + example: No Policy Applied + name: ssl_vpn_policy + required: false + schema: + type: string + value: No Policy Applied + - description: The clientless policy. Default is "No Policy Applied". + example: No Policy Applied + name: clientless_policy + required: false + schema: + type: string + value: No Policy Applied + - description: 'The Data Transfer policy. Default is: "100 MB Total Data Transfer + policy".' + example: 100 MB Total Data Transfer policy + name: data_transfer_policy + required: false + schema: + type: string + value: 100 MB Total Data Transfer policy + - description: 'Whether to enable simultaneous logins global. Possible values: "Enable" + and "Disable". Default is "Enable".' + example: Enable + name: simultaneous_logins_global + required: false + schema: + type: string + value: Enable + - description: 'The schedule for appliance access. Default is "All The Time". IMPORTANT: + This option\ \ is available only for Administrators.' + example: All The Time + name: schedule_for_appliance_access + required: false + schema: + type: string + value: All The Time + - description: The QoS policy. Default is "High Guarantee User". + example: High Guarantee User + name: qos_policy + required: false + schema: + type: string + value: High Guarantee User + - description: 'The login restriction option. Possible values: "AnyNode" and "UserGroupNode". + Default is "UserGroupNode".' + example: UserGroupNode + name: login_restriction + required: false + schema: + type: string + value: UserGroupNode + returns: + example: '' +- description: Updates a user. + name: sophos-firewall-user-update + parameters: + - description: Username of the user. + example: '' + name: username + required: true + schema: + type: string + value: '' + - description: Name of the user. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the user. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: Email of the user. + example: '' + name: email + required: false + schema: + type: string + value: '' + - description: Group of the user. Default is "Guest Group". + example: Guest Group + name: group + required: false + schema: + type: string + value: Guest Group + - description: The password of the user. + example: '' + name: password + required: false + schema: + type: string + value: '' + - description: 'The type of the user. Possible values: "Administrator" and "User". + Default is "User".' + example: User + name: user_type + required: false + schema: + type: string + value: User + - description: 'Profile of the administrator if user_type is Administrator. Possible + values: "Administrator", "Crypto Admin", "Security Admin", "Audit Admin", and + "HAProfile". IMPORTANT: You can add more types in the web console.' + example: '' + name: profile + required: false + schema: + type: string + value: '' + - description: The Surfing Quota policy. Default is "Unlimited Internet Access". + example: Unlimited Internet Access + name: surfing_quota_policy + required: false + schema: + type: string + value: Unlimited Internet Access + - description: The Access Time policy. Default is "Allowed all the time". + example: Allowed all the time + name: access_time_policy + required: false + schema: + type: string + value: Allowed all the time + - description: The SSL VPN policy. Default is "No Policy Applied". + example: No Policy Applied + name: ssl_vpn_policy + required: false + schema: + type: string + value: No Policy Applied + - description: The clientless policy. Default is "No Policy Applied". + example: No Policy Applied + name: clientless_policy + required: false + schema: + type: string + value: No Policy Applied + - description: 'The Data Transfer policy. Default is: "100 MB Total Data Transfer + policy".' + example: 100 MB Total Data Transfer policy + name: data_transfer_policy + required: false + schema: + type: string + value: 100 MB Total Data Transfer policy + - description: 'Whether to enable simultaneous logins global. Possible values: "Enable" + and "Disable". Default is "Enable".' + example: Enable + name: simultaneous_logins_global + required: false + schema: + type: string + value: Enable + - description: 'The schedule for appliance access. Default is "All The Time".IMPORTANT: + This option\ \ is available only for Administrators.' + example: All The Time + name: schedule_for_appliance_access + required: false + schema: + type: string + value: All The Time + - description: The QoS policy. Default is "High Guarantee User". + example: High Guarantee User + name: qos_policy + required: false + schema: + type: string + value: High Guarantee User + - description: 'The login restriction option. Possible values: "AnyNode" and "UserGroupNode". + Default is "UserGroupNode".' + example: UserGroupNode + name: login_restriction + required: false + schema: + type: string + value: UserGroupNode + returns: + example: '' +- description: Deletes an existing user. + name: sophos-firewall-user-delete + parameters: + - description: Name of the user. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all app policies. IMPORTANT: The list starst at 0 (not 1)!' + name: sophos-firewall-app-policy-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single app policy by name. + name: sophos-firewall-app-policy-get + parameters: + - description: Name of the policy. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Adds a new app policy. + name: sophos-firewall-app-policy-add + parameters: + - description: Name of the policy. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the policy. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'Whether microapp support is enabled. Possible values: "true" and + "false".' + example: '' + name: micro_app_support + required: false + schema: + type: string + value: '' + - description: 'Default action for the policy. Possible values: "Allow" and "Deny".' + example: '' + name: default_action + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the select all rule. Possible values: "Enable" + and "Disable".' + example: '' + name: select_all + required: false + schema: + type: string + value: '' + - description: Categories to add to the rule. + example: '' + name: categories + required: false + schema: + type: string + value: '' + - description: Risks to add to the rule. + example: '' + name: risks + required: false + schema: + type: string + value: '' + - description: Applications to add to the rule. + example: '' + name: applications + required: false + schema: + type: string + value: '' + - description: Characteristics to add to the rule. + example: '' + name: characteristics + required: false + schema: + type: string + value: '' + - description: Technologies to add to the rule. + example: '' + name: technologies + required: false + schema: + type: string + value: '' + - description: Classifications to add to the rule. + example: '' + name: classifications + required: false + schema: + type: string + value: '' + - description: 'Action for the rule. Possible values: "Allow" and "Deny".' + example: '' + name: action + required: false + schema: + type: string + value: '' + - description: 'The schedule for the rule. Possible values: "All the time", "Work + hours (5 Day week)", "Work hours (6 Day week)", "All Time on Weekdays", "All + Time on Weekends", "All Time on Sunday", "All Days 10:00 to 19:00". IMPORTANT: + Creating a new schedule is available in the web console.' + example: '' + name: schedule + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Updates an existing app policy. + name: sophos-firewall-app-policy-update + parameters: + - description: Name of the policy. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the policy. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'Whether microapp support is enabled. Possible values: "true" and + "false".' + example: '' + name: micro_app_support + required: false + schema: + type: string + value: '' + - description: 'Default action for the policy. Possible values: "Allow" and "Deny".' + example: '' + name: default_action + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the select all rule. Possible values: "Enable" + and "Disable".' + example: '' + name: select_all + required: false + schema: + type: string + value: '' + - description: Categories to add to the rule. + example: '' + name: categories + required: false + schema: + type: string + value: '' + - description: Risks to add to the rule. + example: '' + name: risks + required: false + schema: + type: string + value: '' + - description: Applications to add to the rule. + example: '' + name: applications + required: false + schema: + type: string + value: '' + - description: Characteristics to add to the rule. + example: '' + name: characteristics + required: false + schema: + type: string + value: '' + - description: Technologies to add to the rule. + example: '' + name: technologies + required: false + schema: + type: string + value: '' + - description: Classifications to add to the rule. + example: '' + name: classifications + required: false + schema: + type: string + value: '' + - description: 'Action for the rule. Possible values: "Allow" and "Deny".' + example: '' + name: action + required: false + schema: + type: string + value: '' + - description: 'The schedule for the rule. Possible values: "All the time", "Work + hours (5 Day week)", "Work hours (6 Day week)", "All Time on Weekdays", "All + Time on Weekends", "All Time on Sunday", "All Days 10:00 to 19:00". IMPORTANT: + Creating a new schedule is available in the web console.' + example: '' + name: schedule + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: Deletes an existing app policy. + name: sophos-firewall-app-policy-delete + parameters: + - description: Name of the policy. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all app filter categories. IMPORTANT: The list starts at 0 (not + 1)!' + name: sophos-firewall-app-category-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single app filter category by name. + name: sophos-firewall-app-category-get + parameters: + - description: Name of the app category. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Updates an existing app filter category. + name: sophos-firewall-app-category-update + parameters: + - description: Name of the app category. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: The description of the category. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: QoS policy of the category. + example: '' + name: qos_policy + required: false + schema: + type: string + value: '' + returns: + example: '' +- description: 'Lists all web filter policies. IMPORTANT: The list starts at 0 (not + 1)!' + name: sophos-firewall-web-filter-list + parameters: + - description: 'The start index for the rules to list, e.g: 5. Default is "0".' + example: '0' + name: start + required: false + schema: + type: string + value: '0' + - description: 'The end index for the rules to list, e.g: 20. Default is "50".' + example: '50' + name: end + required: false + schema: + type: string + value: '50' + returns: + example: '' +- description: Gets a single web filter policy by name. + name: sophos-firewall-web-filter-get + parameters: + - description: Name of the policy. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +- description: Adds a new web filter policy. + name: sophos-firewall-web-filter-add + parameters: + - description: Name of the policy + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the policy. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'Default action for the policy. Possible values: "Allow" and "Deny".' + example: '' + name: default_action + required: true + schema: + type: string + value: '' + - description: 'Whether the max download file size is enabled. Possible values: + "0" and "1".' + example: '' + name: download_file_size_restriction_enabled + required: false + schema: + type: string + value: '' + - description: Maximum file size to enable downloading in MB. + example: '' + name: download_file_size_restriction + required: false + schema: + type: string + value: '' + - description: 'Enable to specify domains allowed to access the Google service. + Possible values: "0" and "1".' + example: '' + name: goog_app_domain_list_enabled + required: false + schema: + type: string + value: '' + - description: The domains allowed to access the Google service. + example: '' + name: goog_app_domain_list + required: false + schema: + type: string + value: '' + - description: 'Whether to enable YouTube Restricted Mode to restrict the content + that is accessible. Possible values: "0" and "1".' + example: '' + name: youtube_filter_enabled + required: false + schema: + type: string + value: '' + - description: 'Whether to adjust the policy used for YouTube Restricted Mode. Possible + values: "0" and "1".' + example: '' + name: youtube_filter_is_strict + required: false + schema: + type: string + value: '' + - description: 'Enable to block websites containing pornography and explicit sexual + content from appearing in the search results of Google, Yahoo, and Bing search + results. Possible values: "0" and "1".' + example: '' + name: enforce_safe_search + required: false + schema: + type: string + value: '' + - description: 'Whether to further limit inappropriate content by enforcing search + engine filters for Creative Commons licensed images. Possible values: "0" and + "1".' + example: '' + name: enforce_image_licensing + required: false + schema: + type: string + value: '' + - description: Comma-separted list of URL groups to block, allow, warn, or log. + example: '' + name: url_group_names + required: false + schema: + type: string + value: '' + - description: 'The HTTP action. Possible values: "Deny", "Allow", "Warn", and "Log".' + example: '' + name: http_action + required: false + schema: + type: string + value: '' + - description: 'The HTTPs action. Possible values: "Deny", "Allow", "Warn", and + "Log".' + example: '' + name: https_action + required: false + schema: + type: string + value: '' + - description: 'The schedule for the rule. Possible values: "All the time", "Work + hours (5 Day week)", "Work hours (6 Day week)", "All Time on Weekdays", "All + Time on Weekends", "All Time on Sunday", "All Days 10:00 to 19:00". IMPORTANT: + Creating a new schedule is available in the web console.' + example: '' + name: schedule + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the policy rule. Possible values: "1" and "0".' + example: '' + name: policy_rule_enabled + required: false + schema: + type: string + value: '' + - description: A comma-separated list of users who this rule will apply to. + example: '' + name: user_names + required: false + schema: + type: string + value: '' + - description: A comma-separated list of CCL names. This argument is required When + ccl_rule_enabled is ON. + example: '' + name: ccl_names + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the CCL rule. Possible values: "0" and "1". If + enabled, ccl_name is required.' + example: '' + name: ccl_rule_enabled + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the HTTP action. Possible values: "0" and "1".' + example: '' + name: follow_http_action + required: false + schema: + type: string + value: '' + - description: 'Whether to enable reporting of the policy. Possible values: "Enable" + and "Disable". Default is "Enable".' + example: Enable + name: enable_reporting + required: false + schema: + type: string + value: Enable + returns: + example: '' +- description: Updates an existing web filter policy. + name: sophos-firewall-web-filter-update + parameters: + - description: Name of the policy. + example: '' + name: name + required: true + schema: + type: string + value: '' + - description: Description of the policy. + example: '' + name: description + required: false + schema: + type: string + value: '' + - description: 'Default action for the policy. Possible values: "Allow" and "Deny".' + example: '' + name: default_action + required: true + schema: + type: string + value: '' + - description: 'Whether the maximum download file size is enabled. Possible values: + "0" and "1".' + example: '' + name: download_file_size_restriction_enabled + required: false + schema: + type: string + value: '' + - description: The maximum file size to enable downloading in MB. + example: '' + name: download_file_size_restriction + required: false + schema: + type: string + value: '' + - description: 'Whether to enable specifying domains allowed to access the Google + service. Possible values: "0" and "1".' + example: '' + name: goog_app_domain_list_enabled + required: false + schema: + type: string + value: '' + - description: Comma-separated list of domains allowed to access the Google service. + example: '' + name: goog_app_domain_list + required: false + schema: + type: string + value: '' + - description: 'Whether to enable YouTube Restricted Mode to restrict the content + that is accessible. Possible values: "0" and "1".' + example: '' + name: youtube_filter_enabled + required: false + schema: + type: string + value: '' + - description: 'Whether to adjust the policy used for YouTube Restricted Mode. Possible + values: "0" and "1".' + example: '' + name: youtube_filter_is_strict + required: false + schema: + type: string + value: '' + - description: 'Whether to enable blocking websites containing pornography and explicit + sexual content from appearing in the search results of Google, Yahoo, and Bing + search results. Possible values: "0" and "1".' + example: '' + name: enforce_safe_search + required: false + schema: + type: string + value: '' + - description: 'Whether to further limit inappropriate content by enforcing search + engine filters for Creative Commons licensed images. Possible values: "0" and + "1".' + example: '' + name: enforce_image_licensing + required: false + schema: + type: string + value: '' + - description: Comma-separated list of URL groups to block, allow, warn, or log. + example: '' + name: url_group_names + required: false + schema: + type: string + value: '' + - description: 'The HTTP action. Possible values: "Deny", "Allow", "Warn", and "Log".' + example: '' + name: http_action + required: false + schema: + type: string + value: '' + - description: 'The HTTPs action. Possible values: "Deny", "Allow", "Warn", and + "Log".' + example: '' + name: https_action + required: false + schema: + type: string + value: '' + - description: 'The schedule for the rule. Possible values: "All the time", "Work + hours (5 Day week)", "Work hours (6 Day week)", "All Time on Weekdays", "All + Time on Weekends", "All Time on Sunday", "All Days 10:00 to 19:00". IMPORTANT: + Creating a new schedule is available in the web console.' + example: '' + name: schedule + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the policy rule. Possible values: "1" and "0".' + example: '' + name: policy_rule_enabled + required: false + schema: + type: string + value: '' + - description: A comma-separated list of users who this rule will apply to. + example: '' + name: user_names + required: false + schema: + type: string + value: '' + - description: 'A comma-separated list of CCL names. REQUIRED: when ccl_rule_enabled + is ON' + example: '' + name: ccl_names + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the CCL rule. Possible values: "0" and "1". IMPORTANT: + If enabled, ccl_name is required.' + example: '' + name: ccl_rule_enabled + required: false + schema: + type: string + value: '' + - description: 'Whether to enable the HTTP action. Possible values: "0" and "1".' + example: '' + name: follow_http_action + required: false + schema: + type: string + value: '' + - description: 'Whether to enable reporting of the policy. Possible values: "Enable" + and "Disable". Default is "Enable".' + example: Enable + name: enable_reporting + required: false + schema: + type: string + value: Enable + returns: + example: '' +- description: Deletes an existing web filter policy. + name: sophos-firewall-web-filter-delete + parameters: + - description: Name of the policy. + example: '' + name: name + required: true + schema: + type: string + value: '' + returns: + example: '' +app_version: 1.0.0 +authentication: + required: true + parameters: + - description: '' + example: '' + name: server_url + required: true + schema: + type: string + - description: '' + example: '' + name: credentials + required: true + schema: + type: string + - description: '' + example: '' + name: insecure + required: false + schema: + type: string +categories: +- Network Security +contact_info: + email: support@shuffler.io + name: support@shuffler.io + url: https://shuffler.io +description: "On-premise firewall by Sophos enables you to manage your firewall, respond\ + \ to threats, and monitor what\u2019s happening on your network." +large_image: '' +name: sophosxgfirewall +tags: [] +large_image: data:image/jpg;base64,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 +large_image: data:image/png;base64,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 diff --git a/unsupported/sophosxgfirewall/1.0.0/requirements.txt b/unsupported/sophosxgfirewall/1.0.0/requirements.txt new file mode 100644 index 00000000..15b9102f --- /dev/null +++ b/unsupported/sophosxgfirewall/1.0.0/requirements.txt @@ -0,0 +1,3 @@ +requests +json2xml +xmltodict diff --git a/unsupported/sophosxgfirewall/1.0.0/src/app.py b/unsupported/sophosxgfirewall/1.0.0/src/app.py new file mode 100644 index 00000000..983e3708 --- /dev/null +++ b/unsupported/sophosxgfirewall/1.0.0/src/app.py @@ -0,0 +1,2078 @@ + +# Remove CommonServer & demistomock things +# Remove _command +# Change functions from - to _ +# Add imports +# Add client to each function +# Add self +# Add to class +# Remove return types from functions +# -> CommandResults +# Add authentication params to each function +# Remove proxy +# Fix client init to not use super().__init__() +# Remove tableToMarkdown +# Always self in functions in class +# Parse out JSON fields? +# FIX: self._http_request(method=request_method. Client request handler to use requests +# xml2json + +import urllib3 +import requests +from typing import Callable +from walkoff_app_sdk.app_base import AppBase +from json2xml import json2xml +import json +import xmltodict + +#import demistomock as demisto +#from CommonServerPython import * +#from CommonServerUserPython import * + +# Disable insecure warnings +urllib3.disable_warnings() + +DATE_FORMAT = '%Y-%m-%dT%H:%M:%SZ' +API_VERSION = '1702.1' + +RULE = { + 'endpoint_tag': 'SecurityPolicy', + 'table_headers': [ + 'Name', 'Description', 'Status', 'PolicyType', 'IPFamily', 'AttachIdentity', 'Action', 'LogTraffic' + ] +} + +RULE_GROUP = { + 'endpoint_tag': 'SecurityPolicyGroup', + 'table_headers': ['Name', 'Description', 'SecurityPolicyList', 'SourceZones', + 'DestinationZones', 'PolicyType'] +} + +URL_GROUP = { + 'endpoint_tag': 'WebFilterURLGroup', + 'table_headers': ['Name', 'Description', 'URLlist'] +} + +IP_HOST = { + 'endpoint_tag': 'IPHost', + 'table_headers': ['Name', 'IPFamily', 'HostType'] +} + +IP_HOST_GROUP = { + 'endpoint_tag': 'IPHostGroup', + 'table_headers': ['Name', 'Description', 'IPFamily', 'HostList'] +} + +SERVICE = { + 'endpoint_tag': 'Services', + 'table_headers': ['Name', 'Type', 'ServiceDetails'] +} + +APP_POLICY = { + 'endpoint_tag': 'ApplicationFilterPolicy', + 'table_headers': ['Name', 'Description', 'MicroAppSupport', 'DefaultAction', 'RuleList'] +} + +APP_CATEGORY = { + 'endpoint_tag': 'ApplicationFilterCategory', + 'table_headers': ['Name', 'Description', 'QoSPolicy', 'ApplicationSettings', + 'BandwidthUsageType'] +} + +WEB_FILTER = { + 'endpoint_tag': 'WebFilterPolicy', + 'table_headers': ['Name', 'Description', 'DefaultAction', 'EnableReporting', + 'DownloadFileSizeRestrictionEnabled', 'DownloadFileSizeRestriction', + 'RuleList'] +} + +USER = { + 'endpoint_tag': 'User', + 'table_headers': ['Username', 'Name', 'Description', 'EmailList', 'Group', 'UserType', 'Status'] +} + + +#class Client(BaseClient): +class Client(object): + """Sophos XG Firewall Client""" + + def __init__(self, base_url: str, auth: tuple, verify: bool): + self.base_url=base_url + self.auth=auth + self.verify=verify + + def request(self, data: tuple, request_method: str, xml_method: str, operation: str = None) -> requests.Response: + print("In request") + data = self.request_builder( + self.auth, + xml_method, + data, + operation + ) + + print("In request 2") + response = requests.request( + request_method, + '%s/webconsole/APIController' % self.base_url, + params=data + ) + + print("In request 3") + return response + + def get_request(self, data: tuple) -> requests.Response: + return self.request(data, 'GET', 'get') + + def set_request(self, data: tuple, operation: str) -> requests.Response: + return self.request(data, 'POST', 'set', operation) + + def delete_request(self, data: tuple) -> requests.Response: + return self.request(data, 'POST', 'remove') + + def get_item_by_name(self, endpoint_tag: str, name: str) -> requests.Response: + data = (endpoint_tag, self.request_one_item_builder(name)) + return self.request(data, 'GET', 'get') + + def validate(self, data: tuple = (None, None)) -> requests.Response: + return self.request(data, 'GET', 'get') + + @staticmethod + def request_builder(auth: tuple, method: str, data: tuple, operation: str) -> dict: + """The builder of the basic xml request + + Args: + auth (tuple): authentication tuple -> (username, password) + method (str): Get/Set/Remove + data (tuple): request body + operation (str): operation for Get method -> add/update + + Returns: + dict: returned built dictionary + """ + request_data = { + 'Request': { + '@APIVersion': API_VERSION, + 'Login': { + 'Username': auth[0], + 'Password': auth[1] + }, + f'{method.title()}': { + '@operation': operation if operation else '', + data[0]: data[1] + } + } + } + + print("Parsed the data: %s") + return {'reqxml': json2xml.Json2xml(json.dumps(request_data))} + + @staticmethod + def request_one_item_builder(name: str) -> dict: + """Build a single filter request + + Args: + name (str): The name of the object to find with the filter + + Returns: + dict: returned built dictionary + """ + request_data = { + 'Filter': { + 'key': { + '@name': 'Name', + '@criteria': '=', + '#text': name + } + } + } + return request_data + +class SophosFirewall(AppBase): + __version__ = "1.0.0" + app_name = ( + "Sophos Firewall" + ) + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def sophos_firewall_rule_list(self, server_url: str, credentials: object, insecure: bool, start: int, end: int): + """List all the firewall rules. + Limited by start and end + + Args: + client (Client): Sophos XG Firewall Client + start (int): low limit of returned objects, starts with 0 + end (int): high limit of returned objects + + Returns: + CommandResults: Command results object + """ + + client = Client( + base_url=server_url, + verify=insecure, + auth=(credentials["username"], credentials["password"]), + ) + + return self.generic_list(client, start, end, **RULE) # type: ignore + + + #def sophos_firewall_rule_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve firewall rule by name. + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the rule to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **RULE) # type: ignore + # + # + def sophos_firewall_rule_add(self, client: Client, params: dict): + """Add firewall rule + + Args: + client (Client): Sophos XG Firewall Client + params (dict): Params for the creation of the firewall rule + + Returns: + CommandResults: Command results object + """ + return generic_save_and_get(client, RULE['endpoint_tag'], # type: ignore + params, rule_builder, RULE['table_headers']) # type: ignore + + # + #def sophos_firewall_rule_update_command(client: Client, params: dict) -> CommandResults: + # """Update an existing firewall rule + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): Params for updating the firewall rule + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, RULE['endpoint_tag'], params, rule_builder, # type: ignore + # RULE['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_rule_delete_command(client: Client, name: str) -> CommandResults: + # """Delete firewall rule + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the rule to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, RULE['endpoint_tag']) # type: ignore + # + # + #def sophos_firewall_rule_group_list_command(client: Client, start: int, end: int) -> CommandResults: + # """List firewall rule groups with limitation + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **RULE_GROUP) # type: ignore + # + # + #def sophos_firewall_rule_group_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve firewall rule group by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the rule group to get_request + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **RULE_GROUP) # type: ignore + # + # + #def sophos_firewall_rule_group_add_command(client: Client, params: dict) -> CommandResults: + # """Add rule group + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params for the creation of the rule group + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, RULE_GROUP['endpoint_tag'], params, rule_group_builder, # type: ignore + # RULE_GROUP['table_headers']) # type: ignore + # + # + #def sophos_firewall_rule_group_update_command(client: Client, params: dict) -> CommandResults: + # """Update firewall rule + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): Params for updating the rule group + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, RULE_GROUP['endpoint_tag'], params, rule_group_builder, # type: ignore + # RULE_GROUP['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_rule_group_delete_command(client: Client, name: str) -> CommandResults: + # """Delete a rule group by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the rule group to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, RULE_GROUP['endpoint_tag']) # type: ignore + # + # + #def sophos_firewall_url_group_list_command(client: Client, start: int, end: int) -> CommandResults: + # """List a URL group with limitations + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **URL_GROUP) # type: ignore + # + # + #def sophos_firewall_url_group_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve URL group by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the URL group to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **URL_GROUP) # type: ignore + # + # + #def sophos_firewall_url_group_add_command(client: Client, params: dict) -> CommandResults: + # """Add URL group + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params for the creation of the URL group + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, URL_GROUP['endpoint_tag'], params, url_group_builder, # type: ignore + # URL_GROUP['table_headers']) # type: ignore + # + # + #def sophos_firewall_url_group_update_command(client: Client, params: dict) -> CommandResults: + # """Update a URL group + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params for the update + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, URL_GROUP['endpoint_tag'], params, url_group_builder, # type: ignore + # URL_GROUP['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_url_group_delete_command(client: Client, name: str) -> CommandResults: + # """Delete a URL group by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the rule to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, URL_GROUP['endpoint_tag']) # type: ignore + # + # + #def sophos_firewall_ip_host_list_command(client: Client, start: int, end: int) -> CommandResults: + # """List IP host objects + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **IP_HOST) # type: ignore + # + # + #def sophos_firewall_ip_host_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve IP host by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the IP host to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **IP_HOST) # type: ignore + # + # + #def sophos_firewall_ip_host_add_command(client: Client, params: dict) -> CommandResults: + # """Add IP host + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params for the creation of the IP host + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, IP_HOST['endpoint_tag'], params, ip_host_builder, # type: ignore + # IP_HOST['table_headers']) # type: ignore + # + # + #def sophos_firewall_ip_host_update_command(client: Client, params: dict) -> CommandResults: + # """Update IP host + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params for the updating of the IP host + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, IP_HOST['endpoint_tag'], params, ip_host_builder, # type: ignore + # IP_HOST['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_ip_host_delete_command(client: Client, name: str) -> CommandResults: + # """Delete IP host by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, IP_HOST['endpoint_tag']) # type: ignore + # + # + #def sophos_firewall_ip_host_group_list_command(client: Client, start: int, + # end: int) -> CommandResults: + # """List IP host group objects + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **IP_HOST_GROUP) # type: ignore + # + # + #def sophos_firewall_ip_host_group_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve an IP host group object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **IP_HOST_GROUP) # type: ignore + # + # + #def sophos_firewall_ip_host_group_add_command(client: Client, params: dict) -> CommandResults: + # """Add IP host group + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to create the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, IP_HOST_GROUP['endpoint_tag'], params, ip_host_group_builder, # type: ignore + # IP_HOST_GROUP['table_headers']) # type: ignore + # + # + #def sophos_firewall_ip_host_group_update_command(client: Client, params: dict) -> CommandResults: + # """Update an existing IP host group object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to update the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, IP_HOST_GROUP['endpoint_tag'], params, ip_host_group_builder, # type: ignore + # IP_HOST_GROUP['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_ip_host_group_delete_command(client: Client, name: str) -> CommandResults: + # """Delete object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, IP_HOST_GROUP['endpoint_tag']) # type: ignore + # + # + #def sophos_firewall_services_list_command(client: Client, start: int, end: int) -> CommandResults: + # """List services + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **SERVICE) # type: ignore + # + # + #def sophos_firewall_services_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve an service object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **SERVICE) # type: ignore + # + # + #def sophos_firewall_services_add_command(client: Client, params: dict) -> CommandResults: + # """Add service object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to create the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, SERVICE['endpoint_tag'], params, service_builder, # type: ignore + # SERVICE['table_headers']) # type: ignore + # + # + #def sophos_firewall_services_update_command(client: Client, params: dict) -> CommandResults: + # """Update an existing object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to update the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, SERVICE['endpoint_tag'], params, service_builder, # type: ignore + # SERVICE['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_services_delete_command(client: Client, name: str) -> CommandResults: + # """Delete object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, SERVICE['endpoint_tag']) # type: ignore + # + # + #def sophos_firewall_app_policy_list_command(client: Client, start: int, end: int) -> CommandResults: + # """List app policy objects + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **APP_POLICY) # type: ignore + # + # + #def sophos_firewall_app_policy_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve an app policy object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **APP_POLICY) # type: ignore + # + # + #def sophos_firewall_app_policy_add_command(client: Client, params: dict) -> CommandResults: + # """Add app policy object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to create the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, APP_POLICY['endpoint_tag'], params, app_policy_builder, # type: ignore + # APP_POLICY['table_headers']) # type: ignore + # + # + #def sophos_firewall_app_policy_update_command(client: Client, params: dict) -> CommandResults: + # """Update an existing object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to update the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, APP_POLICY['endpoint_tag'], params, app_policy_builder, # type: ignore + # APP_POLICY['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_app_policy_delete_command(client: Client, name: str) -> CommandResults: + # """Delete object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, APP_POLICY['endpoint_tag']) # type: ignore + # + # + #def sophos_firewall_app_category_list_command(client: Client, start: int, + # end: int) -> CommandResults: + # """List app category objects + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **APP_CATEGORY) # type: ignore + # + # + #def sophos_firewall_app_category_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve an app category object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **APP_CATEGORY) # type: ignore + # + # + #def sophos_firewall_app_category_update_command(client: Client, params: dict) -> CommandResults: + # """Update an existing object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to update the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, APP_CATEGORY['endpoint_tag'], params, app_category_builder, # type: ignore + # APP_CATEGORY['table_headers']) # type: ignore + # + # + #def sophos_firewall_web_filter_list_command(client: Client, start: int, end: int) -> CommandResults: + # """List web filter objects + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **WEB_FILTER) # type: ignore + # + # + #def sophos_firewall_web_filter_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve an web filter object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **WEB_FILTER) # type: ignore + # + # + #def sophos_firewall_web_filter_add_command(client: Client, params: dict) -> CommandResults: + # """Add web filter object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to create the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, WEB_FILTER['endpoint_tag'], params, web_filter_builder, # type: ignore + # WEB_FILTER['table_headers']) # type: ignore + # + # + #def sophos_firewall_web_filter_update_command(client: Client, params: dict) -> CommandResults: + # """Update an existing object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to update the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, WEB_FILTER['endpoint_tag'], params, web_filter_builder, # type: ignore + # WEB_FILTER['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_web_filter_delete_command(client: Client, name: str) -> CommandResults: + # """Delete object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, WEB_FILTER['endpoint_tag']) # type: ignore + # + # + #def sophos_firewall_user_list_command(client: Client, start: int, end: int) -> CommandResults: + # """Retrieve a list of users + # + # Args: + # client (Client): Sophos XG Firewall Client + # start (int): low limit of returned objects, starts with 0 + # end (int): high limit of returned objects + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_list(client, start, end, **USER) # type: ignore + # + # + #def sophos_firewall_user_get_command(client: Client, name: str) -> CommandResults: + # """Retrieve an user object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to get + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_get(client, name, **USER) # type: ignore + # + # + #def sophos_firewall_user_add_command(client: Client, params: dict) -> CommandResults: + # """Add user object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to create the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, USER['endpoint_tag'], params, user_builder, # type: ignore + # USER['table_headers']) # type: ignore + # + # + #def sophos_firewall_user_update_command(client: Client, params: dict) -> CommandResults: + # """Update an existing object + # + # Args: + # client (Client): Sophos XG Firewall Client + # params (dict): params to update the object with + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_save_and_get(client, USER['endpoint_tag'], params, user_builder, # type: ignore + # USER['table_headers'], True) # type: ignore + # + # + #def sophos_firewall_user_delete_command(client: Client, name: str) -> CommandResults: + # """Delete object by name + # + # Args: + # client (Client): Sophos XG Firewall Client + # name (str): Name of the object to delete + # + # Returns: + # CommandResults: Command results object + # """ + # return generic_delete(client, name, USER['endpoint_tag']) # type: ignore + # + # + #def test_module(client): + # """ + # Returning 'ok' indicates that the integration works like it is supposed to. + # + # Args: + # client: Sophos XG Firewall client + # + # Returns: + # 'ok' if test passed, anything else will fail the test. + # """ + # try: + # result = client.validate() + # json_result = json.loads(xmltojson(result.text)) + # + # status_message = retrieve_dict_item_recursively(json_result, 'status') + # message = '' + # + # if status_message and 'Successful' in status_message: # type: ignore + # message = 'ok' + # elif status_message and 'Authentication Failure' in status_message: # type: ignore + # message = 'Please check your credentials' + # + # status_code = dict_safe_get(json_result, ['Response', 'Status', '@code'], 0) + # if status_code and int(status_code) >= 500: + # status_message = retrieve_dict_item_recursively(json_result, '#text') + # if status_message and 'enable the API Configuration' in status_message: # type: ignore + # message = 'Please enable API configuration from the webconsole ' \ + # '(in Backup & firmware)' + # else: + # message = status_message + # return message + # + # except DemistoException as error: + # return error.message + + + def generic_delete(client: Client, name: str, endpoint_tag: str): + """A generic deleting object function + + Args: + client (Client): Sophos XG Firewall Client + name (str): Name of the object to delete + endpoint_tag (str): Tag of the object to delete + + Returns: + CommandResults: Command results object + """ + response = client.delete_request((endpoint_tag, {'Name': name})) + response = json.loads(xmltodict.parse(response.text)) + + return response + + check_error_on_response(response) # type: ignore + + delete_status = retrieve_dict_item_recursively(response, '#text') + + old_context = demisto.dt(demisto.context(), f'SophosFirewall.{endpoint_tag}' + f'(val.Name == \'{name}\')') + if old_context: + if isinstance(old_context, list): + old_context = old_context[0] + + outputs = { + 'Name': name, + 'IsDeleted': False + } + + # check if there is a previous data about an object that has been deleted before, + # and if not, update the IsDeleted field by the message that returns from the API + if delete_status: + if old_context and old_context.get('IsDeleted'): + is_deleted = old_context['IsDeleted'] + else: + is_deleted = True if 'successfully' in delete_status else False # type: ignore + outputs['IsDeleted'] = is_deleted + + readable_output = tableToMarkdown(f'Deleting {endpoint_tag} Objects Results', outputs, + ['Name', 'IsDeleted']) + + return CommandResults( + outputs_prefix=f'SophosFirewall.{endpoint_tag}', + outputs_key_field='Name', + outputs=outputs, + raw_response=response, + readable_output=readable_output + ) + + + def merge_for_update(client: Client, name: str, data: dict, keys_for_update: dict, + endpoint_tag: str) -> dict: + """This function used when update is needed. + The steps for updating the object is as the following: + 1. Retrieve the object from the API + 2. Add the specified params in keys_for_update to the new object + 3. return the object with the previous and the new data merged. + + Args: + client (Client): Sophos XG Firewall Client + name (str): Name of the object we want to get data from + data (dict): the new object data + keys_for_update (dict): keys for update + endpoint_tag (str): The endpoint_tag of the object we want to get data from + + Returns: + dict: returned built dictionary + """ + previous_object = client.get_item_by_name(endpoint_tag, name) + previous_object = json.loads(xmltodict.parse(previous_object.text)) + + return previous_object + + check_error_on_response(previous_object) # type: ignore + + previous_object = retrieve_dict_item_recursively(previous_object, endpoint_tag) + + # find the related field by keys_for_update and adding it to data + for key in keys_for_update: + info = dict_safe_get(previous_object, keys_for_update[key], []) + if isinstance(info, str): + data[key].append(info) + else: + data[key].extend(info) # if the previous info is list we extent the current + + # remove duplications + for item in data: + data[item] = list(set(data[item])) + + # if there is nothing, makes sure its None so it'll get removed in the end + for item in data: + data[item] = None if not data[item] else data[item] + + return data + + + def prepare_builder_params(client: Client, keys: dict, is_for_update: bool, name: str, + endpoint_tag: str, locals_copy: dict) -> dict: + """prepare the list of objects for the builder - get the params for locals(), + split it into list, and return the params after the merge with the new + object was done (if the is_for_update flag is True) + + Args: + client (Client): Sophos XG Firewall Client + keys (dict): field to update + is_for_update (bool): True if this is an update request + name (str): name of the object we want to update if is_for_update is True + endpoint_tag (str): The endpoint_tag of the object we want to get data from + locals_copy (dict): the locals() object copy in order to extract the params + + Returns: + dict: returned built dictionary + """ + params = {} + # creates a dict with the variables names from keys, and add the current data that insides + # the locals() in the function that called this function. + for key in keys: + params[key] = locals_copy.get(key) + + # making the params a list + params = {key: argToList(item) for key, item in params.items()} + + # update the params with the previous information of the object if the desired action is update + if is_for_update: + params = merge_for_update(client, name, params, keys, endpoint_tag) + + return params + + + def update_dict_from_params_using_path(keys_to_update: dict, params: dict, data: dict) -> dict: + """Update a dictionary using a path given in a list [nest1, nest2] and update it. + For example: some_dict[nest1][nest2] = some_value + Args: + keys_to_update (dict): The keys names with the path to update it into + params (dict): params with the data of the keys name + data (dict): data of the object to update + + Returns: + dict: returned built dictionary + """ + for key in keys_to_update: + path = keys_to_update[key] + # check that there is at least 2 fields for adding the data + if len(path) >= 2: + data[f'{path[0]}'] = { + f'{path[1]}': params.get(key) + } + return data + + + def rule_builder(client: Client, is_for_update: bool, endpoint_tag: str, name: str, + policy_type: str = None, + position: str = None, description: str = None, status: str = None, + ip_family: str = None, position_policy_name: str = None, + source_zones: str = None, source_networks: str = None, # pylint: disable=unused-argument + destination_zones: str = None, destination_networks: str = None, # pylint: disable=unused-argument + services: str = None, members: str = None, # pylint: disable=unused-argument + log_traffic: str = None, match_identity: str = None, + show_captive_portal: str = None, schedule: str = None, + action: str = None, dscp_marking: str = None, + application_control: str = None, application_based_qos_policy: str = None, + web_filter: str = None, web_category_base_qos_policy: str = None, + intrusion_prevention: str = None, traffic_shapping_policy: str = None, + apply_nat: str = None, override_gateway_default_nat_policy: str = None, + scan_http: str = None, scan_https: str = None, sandstorm: str = None, + block_quick_quic: str = None, scan_ftp: str = None, + source_security_heartbeat: str = None, minimum_source_hb_permitted: str = None, + destination_security_heartbeat: str = None, rewrite_source_address: str = None, + minimum_destination_hb_permitted: str = None, data_accounting: str = None, + application_control_internet_scheme: str = None, + web_filter_internet_scheme: str = None, outbound_address: str = None, + backup_gateway: str = None, primary_gateway: str = None) -> dict: + """The builder of the rule object - build the body of the request + + Args: + client (Client): Sophos XG Firewall Client + is_for_update (bool): True if the rule should be updated + endpoint_tag (str): The endpoint_tag of the object we want to get data from + name (str): The name of the object we want to create/update + policy_type (str, optional): Policy Type information of the rule + position (str, optional): Position information of the rule + description (str, optional): Description information of the rule + status (str, optional): Status information of the rule + ip_family (str, optional): Ip Family information of the rule + position_policy_name (str, optional): Position Policy Name information of the rule + source_zones (str, optional): Source Zones information of the rule + source_networks (str, optional): Source Networks information of the rule + destination_zones (str, optional): Destination Zones information of the rule + destination_networks (str, optional): Destination Networks information of the rule + services (str, optional): Services information of the rule + schedule (str, optional): Schedule information of the rule + log_traffic (str, optional): Log Traffic information of the rule + match_identity (str, optional): Match Identity information of the rule + show_captive_portal (str, optional): Show Captive Portal information of the rule + members (str, optional): Members information of the rule + action (str, optional): Action information of the rule + dscp_marking (str, optional): Dscp Marking information of the rule + application_control (str, optional): Application Control information of the rule + application_based_qos_policy (str, optional): Application Based Qos Policy information of + the rule + web_filter (str, optional): Web Filter information of the rule + web_category_base_qos_policy (str, optional): Web Category Base Qos Policy information of + the rule + intrusion_prevention (str, optional): Intrusion Prevention information of the rule + traffic_shapping_policy (str, optional): Traffic Shapping Policy information of the rule + apply_nat (str, optional): Apply Nat information of the rule + override_gateway_default_nat_policy (str, optional): Override Gateway Default Nat Policy + information of the rule + scan_http (str, optional): Scan Http information of the rule + scan_https (str, optional): Scan Https information of the rule + sandstorm (str, optional): Sandstorm information of the rule + block_quick_quic (str, optional): Block Quick Quic information of the rule + scan_ftp (str, optional): Scan Ftp information of the rule + source_security_heartbeat (str, optional): Source Security Heartbeat information of the rule + minimum_source_hb_permitted (str, optional): Minimum Source Hb Permitted information + of the rule + destination_security_heartbeat (str, optional): Destination Security Heartbeat information + of the rule + rewrite_source_address (str, optional): Rewrite Source Address information of the rule + minimum_destination_hb_permitted (str, optional): Minimum Destination Hb Permitted + information of the rule + data_accounting (str, optional): Data Accounting information of the rule + application_control_internet_scheme (str, optional): Application Control Internet Scheme + information of the rule + web_filter_internet_scheme (str, optional): Web Filter Internet Scheme information + of the rule + outbound_address (str, optional): Outbound Address information of the rule + backup_gateway (str, optional): Backup Gateway information of the rule + primary_gateway (str, optional): Primary Gateway information of the rule + + Raises: + Exception: if there is an error with getting the previous rule + + Returns: + dict: returned built dictionary + """ + keys_for_update = { + 'members': ['Identity', 'Member'], + 'source_zones': ['SourceZones', 'Zone'], + 'source_networks': ['SourceNetworks', 'Network'], + 'destination_zones': ['DestinationZones', 'Zone'], + 'destination_networks': ['DestinationNetworks', 'Network'], + 'services': ['Services', 'Service'], + } + + params = prepare_builder_params(client, keys_for_update, is_for_update, name, + endpoint_tag, locals()) + if is_for_update: + response = client.get_item_by_name(endpoint_tag, name) + response = json.loads(xmltodict.parse(response.text)) + check_error_on_response(response) # type: ignore + policy_type = retrieve_dict_item_recursively(response, 'PolicyType') + + json_data = { + 'Name': name, + 'Description': description, + 'Status': status, + 'IPFamily': ip_family, + 'PolicyType': policy_type, + 'Position': position, + 'Schedule': schedule, + 'MatchIdentity': match_identity, + 'ShowCaptivePortal': show_captive_portal, + 'Action': action, + 'DSCPMarking': dscp_marking, + 'LogTraffic': log_traffic, + 'ApplyNAT': apply_nat, + 'ScanHTTP': scan_http, + 'ScanHTTPS': scan_https, + 'Sandstorm': sandstorm, + 'BlockQuickQuic': block_quick_quic, + 'ScanFTP': scan_ftp, + 'DataAccounting': data_accounting, + 'PrimaryGateway': primary_gateway, + 'RewriteSourceAddress': rewrite_source_address, + 'ApplicationControl': application_control, + 'ApplicationControlInternetScheme': application_control_internet_scheme, + 'ApplicationBaseQoSPolicy': application_based_qos_policy, + 'WebFilter': web_filter, + 'WebFilterInternetScheme': web_filter_internet_scheme, + 'WebCategoryBaseQoSPolicy': web_category_base_qos_policy, + 'IntrusionPrevention': intrusion_prevention, + 'TrafficShappingPolicy': traffic_shapping_policy, + 'OverrideGatewayDefaultNATPolicy': override_gateway_default_nat_policy, + 'SourceSecurityHeartbeat': source_security_heartbeat, + 'MinimumSourceHBPermitted': minimum_source_hb_permitted, + 'DestSecurityHeartbeat': destination_security_heartbeat, + 'MinimumDestinationHBPermitted': minimum_destination_hb_permitted, + 'OutboundAddress': outbound_address, + 'BackupGateway': backup_gateway + } + if (position == 'after' or position == 'before') and not position_policy_name: + raise Exception('please provide position_policy_name') + + if position == 'after': + json_data['After'] = {'Name': position_policy_name} # type: ignore + + elif position == 'before': + json_data['Before'] = {'Name': position_policy_name} # type: ignore + + json_data = update_dict_from_params_using_path(keys_for_update, params, json_data) + return remove_empty_elements(json_data) + + + def rule_group_builder(client: Client, is_for_update: bool, endpoint_tag: str, name: str, + destination_zones: str = None, source_zones: str = None, + rules: str = None, # pylint: disable=unused-argument + policy_type: str = None, description: str = None) -> dict: + """Rule group object builder. + + Args: + client (Client): Sophos XG Firewall Client + is_for_update (bool): True if the object should be updated + endpoint_tag (str): The endpoint_tag of the object we want to get data from + name (str): The name of the object we want to add/update + description (str, optional): Description information of the rule group + policy_type (str, optional): Policy Type information of the rule group + rules (str, optional): Rules information of the rule group + source_zones (str, optional): Source Zones information of the rule group + destination_zones (str, optional): Destination Zones information of the rule group + + Returns: + dict: returned built dictionary + """ + keys_for_update = { + 'rules': ['SecurityPolicyList', 'SecurityPolicy'], + 'source_zones': ['SourceZones', 'Zone'], + 'destination_zones': ['DestinationZones', 'Zone'], + } + + params = prepare_builder_params(client, keys_for_update, is_for_update, name, + endpoint_tag, locals()) + + json_data = { + 'Name': name, + 'Description': description, + 'PolicyType': policy_type + } + + json_data = update_dict_from_params_using_path(keys_for_update, params, json_data) + return remove_empty_elements(json_data) + + + def ip_host_builder(client: Client, is_for_update: bool, endpoint_tag: str, + name: str, host_type: str = None, ip_address: str = None, start_ip: str = None, + end_ip: str = None, ip_addresses: str = None, subnet_mask: str = None, + ip_family: str = None, host_group: str = None) -> dict: # pylint: disable=unused-argument + """Builder for the IP host object - build the body of the request + + Args: + client (Client): Sophos XG Firewall Client + is_for_update (bool): True if the object should be updated + endpoint_tag (str): The endpoint_tag of the object we want to get data from + name (str): The name of the object we want to add/update + host_type (str, optional): Host Type information of the IP host + ip_address (str, optional): Ip Address information of the IP host + start_ip (str, optional): Start Ip information of the IP host + end_ip (str, optional): End Ip information of the IP host + ip_addresses (str, optional): Ip Addresses information of the IP host + subnet_mask (str, optional): Subnet Mask information of the IP host + ip_family (str, optional): Ip Family information of the IP host + host_group (str, optional): Host Group information of the IP host + + Raises: + Exception: Missing IP address + Exception: Missing IP address and subnet mask + Exception: Missing start IP and end IP + Exception: Missing IP addresses + + Returns: + dict: returned built dictionary + """ + keys_for_update = { + 'host_group': ['HostGroupList', 'HostGroup'], + } + + params = prepare_builder_params(client, keys_for_update, is_for_update, name, + endpoint_tag, locals()) + if is_for_update: + response = client.get_item_by_name(endpoint_tag, name) + response = json.loads(xmltodict.parse(response.text)) + check_error_on_response(response) # type: ignore + host_type = retrieve_dict_item_recursively(response, 'HostType') + + json_data = { + 'Name': name, + 'IPFamily': ip_family, + 'HostType': host_type, + } + + if host_type == 'IP': + if not ip_address: + raise Exception('Please provide an IP address') + json_data['IPAddress'] = ip_address + + elif host_type == 'Network': + if not (ip_address and subnet_mask): + raise Exception('Please provide an IP address and subnet mask') + json_data['IPAddress'] = ip_address + json_data['Subnet'] = subnet_mask + + elif host_type == 'IPRange': + if not (start_ip and end_ip): + raise Exception('Please provide start IP and end ip') + json_data['StartIPAddress'] = start_ip + json_data['EndIPAddress'] = end_ip + + else: # host_type == 'IPList' + if not ip_addresses: + raise Exception('Please provide an ip_addresses') + json_data['ListOfIPAddresses'] = ip_addresses + + json_data = update_dict_from_params_using_path(keys_for_update, params, json_data) + return remove_empty_elements(json_data) + + + def url_group_builder(client: Client, is_for_update: bool, endpoint_tag: str, name: str, + description: str = None, urls: str = None) -> dict: # pylint: disable=unused-argument + """Builder for the URL group object - build the body of the request + + Args: + client (Client): Sophos XG Firewall Client + is_for_update (bool): True if the object should be updated + endpoint_tag (str): The endpoint_tag of the object we want to get data from + name (str): The name of the object we want to add/update + description (str, optional): Description information of the URL group + urls (str, optional): URLs information of the URL group + + Returns: + dict: returned built dictionary + """ + keys_for_update = { + 'urls': ['URLlist', 'URL'], + } + + params = prepare_builder_params(client, keys_for_update, is_for_update, name, + endpoint_tag, locals()) + + json_data = { + 'Name': name, + 'Description': description, + } + + json_data = update_dict_from_params_using_path(keys_for_update, params, json_data) + return remove_empty_elements(json_data) + + + def ip_host_group_builder(client: Client, is_for_update: bool, endpoint_tag: str, + name: str, description: str = None, ip_family: str = None, + hosts: str = None) -> dict: # pylint: disable=unused-argument + """Builder for the IP host group - build the body of the request + + Args: + client (Client): Sophos XG Firewall Client + is_for_update (bool): True if the object should be updated + endpoint_tag (str): The endpoint_tag of the object we want to get data from + name (str): The name of the object we want to add/update + description (str, optional): Description information of the IP host group + ip_family (str, optional): Ip Family information of the IP host group + hosts (str, optional): Hosts information of the IP host group + + Returns: + dict: returned built dictionary + """ + keys_for_update = { + 'hosts': ['HostList', 'Host'], + } + + params = prepare_builder_params(client, keys_for_update, is_for_update, name, + endpoint_tag, locals()) + + json_data = { + 'Name': name, + 'IPFamily': ip_family, + 'Description': description, + } + + json_data = update_dict_from_params_using_path(keys_for_update, params, json_data) + return remove_empty_elements(json_data) + + + def service_builder(client: Client, is_for_update: bool, endpoint_tag: str, + name: str, service_type: str, protocol: str = None, source_port: int = None, + destination_port: int = None, protocol_name: str = None, + icmp_type: str = None, icmp_code: str = None, + icmp_v6_type: str = None, icmp_v6_code: str = None) -> dict: + """Builder for the service object - build the body of the request + + Args: + client (Client): Sophos XG Firewall Client + is_for_update (bool): True if the object should be updated + endpoint_tag (str): The endpoint_tag of the object we want to get data from + name (str): The name of the object we want to add/update + service_type (str, optional): Service Type information of the service + protocol (str, optional): Protocol information of the service + source_port (str, optional): Source Port information of the service + destination_port (str, optional): Destination Port information of the service + protocol_name (str, optional): Protocol Name information of the service + icmp_type (str, optional): ICMP Type information of the service + icmp_code (str, optional): ICMP Code information of the service + icmp_v6_type (str, optional): ICMP V6 Type information of the service + icmp_v6_code (str, optional): ICMP V6 Code information of the service + + Raises: + Exception: Missing protocol, source port and destination port + Exception: Missing protocol name + Exception: Missing icmp_type and icmp_code + Exception: Missing icmp_v6_type and icmp_v6_code + + Returns: + dict: returned dictionary + """ + previous_service_details = [] # type: ignore + # if the object need to be updated, merge between old and new information will happen + if is_for_update: + previous_object = client.get_item_by_name(endpoint_tag, name) + previous_object = json.loads(xmltodict.parse(previous_object.text)) + + check_error_on_response(previous_object) # type: ignore + service_type = retrieve_dict_item_recursively(previous_object, 'Type') + + previous_service_details = retrieve_dict_item_recursively(previous_object, 'ServiceDetail') + if not previous_service_details: + previous_service_details = [] + elif not isinstance(previous_service_details, list): + previous_service_details = [previous_service_details] + + json_data = { + 'Name': name, + 'Type': service_type, + } + + if service_type == 'TCPorUDP': + if not (protocol and source_port and destination_port): + raise Exception('Please provide protocol, source_port and destination_port') + service_details = { + 'Protocol': protocol, + 'SourcePort': source_port, + 'DestinationPort': destination_port + } + + elif service_type == 'IP': + if not protocol_name: + raise Exception('Please provide protocol_name') + service_details = { + 'ProtocolName': protocol_name + } + + elif service_type == 'ICMP': + if not (icmp_type and icmp_code): + raise Exception('Please provide icmp_type and icmp_code') + service_details = { + 'ICMPType': icmp_type, + 'ICMPCode': icmp_code + } + + else: # type == 'ICMPv6' + if not (icmp_v6_type and icmp_v6_code): + raise Exception('Please provide icmp_v6_type and icmp_v6_code') + service_details = { + 'ICMPv6Type': icmp_v6_type, + 'ICMPv6Code': icmp_v6_code + } + + previous_service_details.append(service_details) + json_data.update({ + 'ServiceDetails': { # type: ignore + 'ServiceDetail': previous_service_details + } + }) + return remove_empty_elements(json_data) + + + def web_filter_builder(client: Client, is_for_update: bool, endpoint_tag: str, + name: str, default_action: str = None, description: str = None, + download_file_size_restriction_enabled: str = None, + download_file_size_restriction: int = None, enable_reporting: str = None, + goog_app_domain_list_enabled: str = None, goog_app_domain_list: str = None, + youtube_filter_enabled: str = None, youtube_filter_is_strict: str = None, + enforce_safe_search: str = None, enforce_image_licensing: str = None, + url_group_names: str = None, http_action: str = None, + https_action: str = None, schedule: str = None, + policy_rule_enabled: str = None, user_names: str = None, + ccl_names: str = None, ccl_rule_enabled: str = None, + follow_http_action: str = None) -> dict: + """Builder for web filter object + + Args: + client (Client): Sophos XG Firewall Client + is_for_update (bool): True if the object should be updated + endpoint_tag (str): The endpoint_tag of the object we want to get data from + name (str): The name of the object we want to add/update + default_action (str, optional): Default Action information of the web filter + description (str, optional): Description information of the web filter + download_file_size_restriction_enabled (str, optional): Download File Size Restriction + Enabled information of the web filter + download_file_size_restriction (str, optional): Download File Size Restriction information + of the web filter + enable_reporting (str, optional): Enable Reporting information of the web filter + goog_app_domain_list_enabled (str, optional): Goog App Domain List Enabled information of + the web filter + goog_app_domain_list (str, optional): Goog App Domain List information of the web filter + youtube_filter_enabled (str, optional): Youtube Filter Enabled information of the web filter + youtube_filter_is_strict (str, optional): Youtube Filter Is Strict information + of the web filter + enforce_safe_search (str, optional): Enforce Safe Search information of the web filter + enforce_image_licensing (str, optional): Enforce Image Licensing information + of the web filter + url_group_names (str, optional): Url Group Names information of the web filter + http_action (str, optional): Http Action information of the web filter + https_action (str, optional): Https Action information of the web filter + schedule (str, optional): Schedule information of the web filter + policy_rule_enabled (str, optional): Policy Rule Enabled information of the web filter + user_names (str, optional): User Names information of the web filter + ccl_names (str, optional): Ccl Names information of the web filter + ccl_rule_enabled (str, optional): Ccl Rule Enabled information of the web filter + follow_http_action (str, optional): Follow Http Action information of the web filter + + Returns: + dict: returned built dictionary + """ + previous_rules_details = [] # type: ignore + # if the object need to be updated, merge between old and new information will happen + if is_for_update: + previous_object = client.get_item_by_name(endpoint_tag, name) + previous_object = json.loads(xmltodict.parse(previous_object.text)) + check_error_on_response(previous_object) # type: ignore + + previous_rules_details = retrieve_dict_item_recursively(previous_object, 'Rule') + if not previous_rules_details: + previous_rules_details = [] + elif not isinstance(previous_rules_details, list): + previous_rules_details = [previous_rules_details] + json_data = { + 'Name': name, + 'Description': description, + 'DefaultAction': default_action, + 'EnableReporting': enable_reporting, + 'DownloadFileSizeRestriction': download_file_size_restriction, + 'DownloadFileSizeRestrictionEnabled': download_file_size_restriction_enabled, + 'GoogAppDomainListEnabled': goog_app_domain_list_enabled, + 'GoogAppDomainList': argToList(goog_app_domain_list), + 'YoutubeFilterEnabled': youtube_filter_enabled, + 'YoutubeFilterIsStrict': youtube_filter_is_strict, + 'EnforceSafeSearch': enforce_safe_search, + 'EnforceImageLicensing': enforce_image_licensing, + } + + categories = [{'ID': name, 'type': 'URLGroup'} for name in argToList(url_group_names)] + rule_details = { + 'PolicyRuleEnabled': policy_rule_enabled, + 'CCLRuleEnabled': ccl_rule_enabled, + 'FollowHTTPAction': follow_http_action, + 'CategoryList': { + 'Category': categories + }, + 'HTTPAction': http_action, + 'HTTPSAction': https_action, + 'Schedule': schedule, + 'UserList': { + 'User': argToList(user_names) + }, + 'CCLList': { + 'CCL': argToList(ccl_names) + } + } + + previous_rules_details.append(rule_details) + json_data.update({ + 'RuleList': { # type: ignore + 'Rule': previous_rules_details + } + }) + return remove_empty_elements(json_data) + + + def app_category_builder(name: str, description: str = None, qos_policy: str = None) -> dict: + """Builder for app category object + + Args: + name (str): The name of the object we want to add/update + description (str, optional): Description information of the app category + qos_policy (str, optional): Qos Policy information of the app category + + Returns: + dict: returned built dictionary + """ + json_data = { + 'Name': name, + 'Description': description, + 'QoSPolicy': qos_policy, + } + return remove_empty_elements(json_data) + + + def app_policy_builder(client: Client, is_for_update: bool, endpoint_tag: str, + name: str, description: str = None, micro_app_support: str = None, + default_action: str = None, select_all: str = None, categories: str = None, + risks: str = None, applications: str = None, characteristics: str = None, + technologies: str = None, classifications: str = None, + action: str = None, schedule: str = None) -> dict: + """Builder for the app policy object - build the body of the request + + Args: + client (Client): Sophos XG Firewall Client + is_for_update (bool): True if the object should be updated + endpoint_tag (str): The endpoint_tag of the object we want to get data from + name (str): The name of the object we want to add/update + description (str, optional): Description information of the app policy + micro_app_support (str, optional): Micro App Support information of the app policy + default_action (str, optional): Default Action information of the app policy + select_all (str, optional): Select All information of the app policy + categories (str, optional): Categories information of the app policy + risks (str, optional): Risks information of the app policy + applications (str, optional): Applications information of the app policy + characteristics (str, optional): Characteristics information of the app policy + technologies (str, optional): Technologies information of the app policy + classifications (str, optional): Classifications information of the app policy + action (str, optional): Action information of the app policy + schedule (str, optional): Schedule information of the app policy + + Returns: + dict: returned built dictionary + """ + previous_rules_details = [] # type: ignore + # if the object need to be updated, merge between old and new information will happen + if is_for_update: + previous_object = client.get_item_by_name(endpoint_tag, name) + previous_object = json.loads(xmltodict.parse(previous_object.text)) + check_error_on_response(previous_object) # type: ignore + + previous_rules_details = retrieve_dict_item_recursively(previous_object, 'Rule') + if not previous_rules_details: + previous_rules_details = [] + elif not isinstance(previous_rules_details, list): + previous_rules_details = [previous_rules_details] + json_data = { + 'Name': name, + 'Description': description, + 'MicroAppSupport': micro_app_support, + 'DefaultAction': default_action, + } + + rule_details = { + 'SelectAllRule': select_all, + 'CategoryList': { + 'Category': argToList(categories) + }, + 'RiskList': { + 'Risk': argToList(risks) + }, + 'CharacteristicsList': { + 'Characteristics': argToList(characteristics) + }, + 'TechnologyList': { + 'Technology': argToList(technologies) + }, + 'ClassificationList': { + 'Classification': argToList(classifications) + }, + 'ApplicationList': { + 'Application': argToList(applications) + }, + 'Action': action, + 'Schedule': schedule, + } + + previous_rules_details.append(rule_details) + json_data.update({ + 'RuleList': { # type: ignore + 'Rule': previous_rules_details + } + }) + return remove_empty_elements(json_data) + + + def user_builder(name: str, username: str, email: str = None, password: str = None, + description: str = None, group: str = None, user_type: str = None, + profile: str = None, surfing_quota_policy: str = None, + access_time_policy: str = None, ssl_vpn_policy: str = None, + clientless_policy: str = None, data_transfer_policy: str = None, + simultaneous_logins_global: str = None, schedule_for_appliance_access: str = None, + qos_policy: str = None, login_restriction: str = None) -> dict: + """Builder for the user object - build the body of the request + + Args: + name (str): The name of the object we want to add/update + username (str, optional): Username information of the user + email (str, optional): Email information of the user + password (str, optional): Password information of the user + description (str, optional): Description information of the user + group (str, optional): Group information of the user + user_type (str, optional): User Type information of the user + profile (str, optional): Profile information of the user + surfing_quota_policy (str, optional): Surfing Quota Policy information of the user + access_time_policy (str, optional): Access Time Policy information of the user + ssl_vpn_policy (str, optional): Ssl Vpn Policy information of the user + clientless_policy (str, optional): Clientless Policy information of the user + data_transfer_policy (str, optional): Data Transfer Policy information of the user + simultaneous_logins_global (str, optional): Simultaneous Logins Global information + of the user + schedule_for_appliance_access (str, optional): Schedule For Appliance Access information + of the user + qos_policy (str, optional): Qos Policy information of the user + login_restriction (str, optional): Login Restriction information of the user + + Raises: + Exception: if Administrator type was selected and profile was not provided + + Returns: + dict: returned built dictionary + """ + if user_type == 'Administrator' and not profile: + raise Exception('Administrator type was selected. Please provide profile.') + json_data = { + 'Username': username, + 'Name': name, + 'Password': password, + 'UserType': user_type, + 'Profile': profile, + 'EmailList': { + 'EmailID': email + }, + 'Group': group, + 'Description': description, + 'SurfingQuotaPolicy': surfing_quota_policy, + 'AccessTimePolicy': access_time_policy, + 'SSLVPNPolicy': ssl_vpn_policy, + 'ClientlessPolicy': clientless_policy, + 'DataTransferPolicy': data_transfer_policy, + 'SimultaneousLoginsGlobal': simultaneous_logins_global, + 'ScheduleForApplianceAccess': schedule_for_appliance_access, + 'QoSPolicy': qos_policy, + 'LoginRestriction': login_restriction, + } + return remove_empty_elements(json_data) + + + def check_error_on_response(response: dict) -> None: + """Check if there is an error on the response + + Args: + response (dict): the object to check the error on + + Raises: + Exception: if there if an error in the response + Exception: if there are no records on list or get + """ + response_message = retrieve_dict_item_recursively(response, '#text') + response_code = retrieve_dict_item_recursively(response, '@code') + response_status = retrieve_dict_item_recursively(response, 'Status') + + if response_message and 'successful' not in response_message: # type: ignore + if response_code and int(response_code) > 299: + raise Exception(f'{response_message} (error code: {response_code})') + if response_status and 'No. of records Zero.' in response_status: # type: ignore + raise Exception(response_status) + + + def generic_save_and_get(client: Client, endpoint_tag: str, params: dict, builder: Callable, + table_headers: list, to_update: bool = False): + """Generic function for add/update + + Args: + to_update (bool): True if the object should be updated + client (Client): Sophos XG Firewall Client + params (dict): params for the builder + builder (Callable): the builder to build the object + endpoint_tag (str): The endpoint_tag of the object + table_headers (list): table_headers for readable outputs + + Returns: + CommandResults: Command results object + """ + funcs_without_extra_args = [user_builder, app_category_builder] + if builder in funcs_without_extra_args: + data = builder(**params) + else: + data = builder(client, to_update, endpoint_tag, **params) + operation = 'update' if to_update else 'add' + response = client.set_request((endpoint_tag, data), operation) + response = json.loads(xmltodict.parse(response.text)) + + check_error_on_response(response) # type: ignore + return generic_get(client, params.get('name'), endpoint_tag, table_headers) # type: ignore + + + def generic_get(client: Client, name: str, endpoint_tag: str, + table_headers: list): + """Generic get, returns an object based on the endpoint tag and the name + + Args: + client (Client): Sophos XG Firewall Client + name (str): The name of the object to get + endpoint_tag (str): The endpoint tag of the object + table_headers (list): table headers for readable outputs + + Returns: + CommandResults: Command results object + """ + response = client.get_item_by_name(endpoint_tag, name) + response = json.loads(xmltodict.parse(response.text)) + + return response + + check_error_on_response(response) # type: ignore + + outputs = retrieve_dict_item_recursively(response, endpoint_tag) + if outputs: + outputs.pop('@transactionid') # type: ignore + outputs['IsDeleted'] = False # type: ignore + + table_title = f'{endpoint_tag} Object details' + + readable_output = tableToMarkdown(table_title, outputs, table_headers, removeNull=True) + return CommandResults( + outputs_prefix=f'SophosFirewall.{endpoint_tag}', + outputs_key_field='Name', + raw_response=outputs, + outputs=outputs, + readable_output=readable_output + ) + + + def generic_list(self, client: Client, start: int, end: int, endpoint_tag: str, table_headers: str): + """Generic function for listing objects + + Args: + client (Client): Sophos XG Firewall Client + start (int): low limit of returned objects, starts with 0 + end (int): high limit of returned objects + endpoint_tag (str): The endpoint tag of the objects + table_headers (list): table headers for readable outputs + + Returns: + CommandResults: Command results object + """ + response = client.get_request((endpoint_tag, None)) + return response.text + + outputs = dict_safe_get(response, ['Response', endpoint_tag]) + + check_error_on_response(response) # type: ignore + + outputs = outputs if isinstance(outputs, list) else [outputs] + for output in outputs: + output.pop('@transactionid') + output['IsDeleted'] = False + + start, end = int(start), int(end) + len_outputs = len(outputs) + if end > len_outputs: + end = len_outputs + outputs = outputs[start:end] + + table_title = f'Showing {start} to {end} {endpoint_tag} objects out of {len_outputs}' + + readable_output = tableToMarkdown(table_title, outputs, table_headers, removeNull=True) + return { + "outputs_prefix": f'SophosFirewall.{endpoint_tag}', + "outputs_key_field": 'Name', + "raw_response": outputs, + "outputs": outputs, + "readable_output": readable_output, + } + + + def retrieve_dict_item_recursively(obj, key) -> any: # type: ignore + """Find items in given dictionary by the key + + Args: + obj (dict): the dict to search in + key (str): the key to search for + + Returns: + The item if found + """ + if key in obj: + return obj[key] + for _, value in obj.items(): + if isinstance(value, dict): + item = retrieve_dict_item_recursively(value, key) + if item: + return item + return None + + +#def main(): +# """ +# PARSE AND VALIDATE INTEGRATION PARAMS +# """ +# params = demisto.params() +# command = demisto.command() +# args = demisto.args() +# +# username = params.get('credentials').get('identifier') +# password = params.get('credentials').get('password') +# +# server_url = params.get('server_url') +# +# verify_certificate = not params.get('insecure', False) +# +# proxy = params.get('proxy', False) +# +# demisto.debug(f'Command being called is {command}') +# try: +# client = Client( +# base_url=server_url, +# verify=verify_certificate, +# auth=(username, password), +# proxy=proxy +# ) +# +# if command == 'test-module': +# # This is the call made when pressing the integration Test button. +# return_results(test_module(client)) +# +# elif command == 'sophos-firewall-rule-list': +# return_results(sophos_firewall_rule_list_command(client, **args)) +# +# elif command == 'sophos-firewall-rule-get': +# return_results(sophos_firewall_rule_get_command(client, **args)) +# +# elif command == 'sophos-firewall-rule-add': +# return_results(sophos_firewall_rule_add_command(client, args)) +# +# elif command == 'sophos-firewall-rule-update': +# return_results(sophos_firewall_rule_update_command(client, args)) +# +# elif command == 'sophos-firewall-rule-delete': +# return_results(sophos_firewall_rule_delete_command(client, **args)) +# +# elif command == 'sophos-firewall-rule-group-list': +# return_results(sophos_firewall_rule_group_list_command(client, **args)) +# +# elif command == 'sophos-firewall-rule-group-get': +# return_results(sophos_firewall_rule_group_get_command(client, **args)) +# +# elif command == 'sophos-firewall-rule-group-add': +# return_results(sophos_firewall_rule_group_add_command(client, args)) +# +# elif command == 'sophos-firewall-rule-group-update': +# return_results(sophos_firewall_rule_group_update_command(client, args)) +# +# elif command == 'sophos-firewall-rule-group-delete': +# return_results(sophos_firewall_rule_group_delete_command(client, **args)) +# +# elif command == 'sophos-firewall-url-group-list': +# return_results(sophos_firewall_url_group_list_command(client, **args)) +# +# elif command == 'sophos-firewall-url-group-get': +# return_results(sophos_firewall_url_group_get_command(client, **args)) +# +# elif command == 'sophos-firewall-url-group-add': +# return_results(sophos_firewall_url_group_add_command(client, args)) +# +# elif command == 'sophos-firewall-url-group-update': +# return_results(sophos_firewall_url_group_update_command(client, args)) +# +# elif command == 'sophos-firewall-url-group-delete': +# return_results(sophos_firewall_url_group_delete_command(client, **args)) +# +# elif command == 'sophos-firewall-ip-host-list': +# return_results(sophos_firewall_ip_host_list_command(client, **args)) +# +# elif command == 'sophos-firewall-ip-host-get': +# return_results(sophos_firewall_ip_host_get_command(client, **args)) +# +# elif command == 'sophos-firewall-ip-host-add': +# return_results(sophos_firewall_ip_host_add_command(client, args)) +# +# elif command == 'sophos-firewall-ip-host-update': +# return_results(sophos_firewall_ip_host_update_command(client, args)) +# +# elif command == 'sophos-firewall-ip-host-delete': +# return_results(sophos_firewall_ip_host_delete_command(client, **args)) +# +# elif command == 'sophos-firewall-ip-host-group-list': +# return_results(sophos_firewall_ip_host_group_list_command(client, **args)) +# +# elif command == 'sophos-firewall-ip-host-group-get': +# return_results(sophos_firewall_ip_host_group_get_command(client, **args)) +# +# elif command == 'sophos-firewall-ip-host-group-add': +# return_results(sophos_firewall_ip_host_group_add_command(client, args)) +# +# elif command == 'sophos-firewall-ip-host-group-update': +# return_results(sophos_firewall_ip_host_group_update_command(client, args)) +# +# elif command == 'sophos-firewall-ip-host-group-delete': +# return_results(sophos_firewall_ip_host_group_delete_command(client, **args)) +# +# elif command == 'sophos-firewall-services-list': +# return_results(sophos_firewall_services_list_command(client, **args)) +# +# elif command == 'sophos-firewall-services-get': +# return_results(sophos_firewall_services_get_command(client, **args)) +# +# elif command == 'sophos-firewall-services-add': +# return_results(sophos_firewall_services_add_command(client, args)) +# +# elif command == 'sophos-firewall-services-update': +# return_results(sophos_firewall_services_update_command(client, args)) +# +# elif command == 'sophos-firewall-services-delete': +# return_results(sophos_firewall_services_delete_command(client, **args)) +# +# elif command == 'sophos-firewall-app-policy-list': +# return_results(sophos_firewall_app_policy_list_command(client, **args)) +# +# elif command == 'sophos-firewall-app-policy-get': +# return_results(sophos_firewall_app_policy_get_command(client, **args)) +# +# elif command == 'sophos-firewall-app-policy-add': +# return_results(sophos_firewall_app_policy_add_command(client, args)) +# +# elif command == 'sophos-firewall-app-policy-update': +# return_results(sophos_firewall_app_policy_update_command(client, args)) +# +# elif command == 'sophos-firewall-app-policy-delete': +# return_results(sophos_firewall_app_policy_delete_command(client, **args)) +# +# elif command == 'sophos-firewall-app-category-list': +# return_results(sophos_firewall_app_category_list_command(client, **args)) +# +# elif command == 'sophos-firewall-app-category-get': +# return_results(sophos_firewall_app_category_get_command(client, **args)) +# +# elif command == 'sophos-firewall-app-category-update': +# return_results( +# sophos_firewall_app_category_update_command(client, args)) +# +# elif command == 'sophos-firewall-web-filter-list': +# return_results(sophos_firewall_web_filter_list_command(client, **args)) +# +# elif command == 'sophos-firewall-web-filter-get': +# return_results(sophos_firewall_web_filter_get_command(client, **args)) +# +# elif command == 'sophos-firewall-web-filter-add': +# return_results(sophos_firewall_web_filter_add_command(client, args)) +# +# elif command == 'sophos-firewall-web-filter-update': +# return_results(sophos_firewall_web_filter_update_command(client, args)) +# +# elif command == 'sophos-firewall-web-filter-delete': +# return_results(sophos_firewall_web_filter_delete_command(client, **args)) +# +# elif command == 'sophos-firewall-user-list': +# return_results(sophos_firewall_user_list_command(client, **args)) +# +# elif command == 'sophos-firewall-user-get': +# return_results(sophos_firewall_user_get_command(client, **args)) +# +# elif command == 'sophos-firewall-user-add': +# return_results(sophos_firewall_user_add_command(client, args)) +# +# elif command == 'sophos-firewall-user-update': +# return_results(sophos_firewall_user_update_command(client, args)) +# +# elif command == 'sophos-firewall-user-delete': +# return_results(sophos_firewall_user_delete_command(client, **args)) +# +# # Log exceptions +# except Exception as error: +# message = f'Failed to execute {command} command. Error: {str(error)}' +# return_error(message) +# +# +#if __name__ in ('__main__', '__builtin__', 'builtins'): +# main() + +if __name__ == "__main__": + SophosFirewall.run() diff --git a/oauth2-example/1.0.0/Dockerfile b/unsupported/splunk/1.0.0/Dockerfile similarity index 100% rename from oauth2-example/1.0.0/Dockerfile rename to unsupported/splunk/1.0.0/Dockerfile diff --git a/splunk/1.0.0/api.yaml b/unsupported/splunk/1.0.0/api.yaml similarity index 100% rename from splunk/1.0.0/api.yaml rename to unsupported/splunk/1.0.0/api.yaml diff --git a/splunk/1.0.0/docker-compose.yml b/unsupported/splunk/1.0.0/docker-compose.yml similarity index 100% rename from splunk/1.0.0/docker-compose.yml rename to unsupported/splunk/1.0.0/docker-compose.yml diff --git a/splunk/1.0.0/env.txt b/unsupported/splunk/1.0.0/env.txt similarity index 100% rename from splunk/1.0.0/env.txt rename to unsupported/splunk/1.0.0/env.txt diff --git a/splunk/1.0.0/requirements.txt b/unsupported/splunk/1.0.0/requirements.txt similarity index 56% rename from splunk/1.0.0/requirements.txt rename to unsupported/splunk/1.0.0/requirements.txt index c5a5f6ea..bb76b456 100644 --- a/splunk/1.0.0/requirements.txt +++ b/unsupported/splunk/1.0.0/requirements.txt @@ -1,2 +1,2 @@ python-magic==0.4.18 -requests==2.25.1 \ No newline at end of file +requests==2.32.4 \ No newline at end of file diff --git a/splunk/1.0.0/src/app.py b/unsupported/splunk/1.0.0/src/app.py similarity index 100% rename from splunk/1.0.0/src/app.py rename to unsupported/splunk/1.0.0/src/app.py diff --git a/vulndb/1.0.0/Dockerfile b/unsupported/testing/1.0.0/Dockerfile similarity index 100% rename from vulndb/1.0.0/Dockerfile rename to unsupported/testing/1.0.0/Dockerfile diff --git a/testing/1.0.0/api.yaml b/unsupported/testing/1.0.0/api.yaml similarity index 100% rename from testing/1.0.0/api.yaml rename to unsupported/testing/1.0.0/api.yaml diff --git a/unsupported/testing/1.0.0/requirements.txt b/unsupported/testing/1.0.0/requirements.txt new file mode 100644 index 00000000..480d0c4b --- /dev/null +++ b/unsupported/testing/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 \ No newline at end of file diff --git a/thehive/1.1.0/run b/unsupported/testing/1.0.0/run old mode 100644 new mode 100755 similarity index 67% rename from thehive/1.1.0/run rename to unsupported/testing/1.0.0/run index 6127bfb7..e73f748d --- a/thehive/1.1.0/run +++ b/unsupported/testing/1.0.0/run @@ -1,9 +1,9 @@ #!/bin/sh -docker stop frikky/shuffle:thehive_1.0.0 --force -docker rm frikky/shuffle:thehive_1.0.0 --force -docker rmi frikky/shuffle:thehive_1.0.0 --force +docker stop frikky/shuffle:testing_1.0.0 --force +docker rm frikky/shuffle:testing_1.0.0 --force +docker rmi frikky/shuffle:testing_1.0.0 --force -docker build . -t frikky/shuffle:thehive_1.0.0 +docker build . -t frikky/shuffle:testing_1.0.0 echo "RUNNING!\n\n" docker run \ @@ -12,6 +12,6 @@ docker run \ --env FUNCTION_APIKEY="asdasd" \ --env EXECUTIONID="2349bf96-51ad-68d2-5ca6-75ef8f7ee814" \ --env AUTHORIZATION="8e344a2e-db51-448f-804c-eb959a32c139" \ - frikky/shuffle:thehive_1.0.0 + frikky/shuffle:testing_1.0.0 -docker push frikky/shuffle:thehive_1.0.0 +docker push frikky/shuffle:testing_1.0.0 diff --git a/testing/1.0.0/src/app.py b/unsupported/testing/1.0.0/src/app.py similarity index 100% rename from testing/1.0.0/src/app.py rename to unsupported/testing/1.0.0/src/app.py diff --git a/testing/1.0.0/tmp.py b/unsupported/testing/1.0.0/tmp.py similarity index 100% rename from testing/1.0.0/tmp.py rename to unsupported/testing/1.0.0/tmp.py diff --git a/splunk/1.0.0/Dockerfile b/unsupported/thehive/1.0.0/Dockerfile similarity index 100% rename from splunk/1.0.0/Dockerfile rename to unsupported/thehive/1.0.0/Dockerfile diff --git a/thehive/1.0.0/api.yaml b/unsupported/thehive/1.0.0/api.yaml similarity index 100% rename from thehive/1.0.0/api.yaml rename to unsupported/thehive/1.0.0/api.yaml diff --git a/microsoft-security-oauth2/1.0.0/docker-compose.yml b/unsupported/thehive/1.0.0/docker-compose.yml similarity index 100% rename from microsoft-security-oauth2/1.0.0/docker-compose.yml rename to unsupported/thehive/1.0.0/docker-compose.yml diff --git a/microsoft-security-oauth2/1.0.0/env.txt b/unsupported/thehive/1.0.0/env.txt similarity index 100% rename from microsoft-security-oauth2/1.0.0/env.txt rename to unsupported/thehive/1.0.0/env.txt diff --git a/microsoft-security-oauth2/1.0.0/requirements.txt b/unsupported/thehive/1.0.0/requirements.txt similarity index 69% rename from microsoft-security-oauth2/1.0.0/requirements.txt rename to unsupported/thehive/1.0.0/requirements.txt index 1d40c46a..175d3de0 100644 --- a/microsoft-security-oauth2/1.0.0/requirements.txt +++ b/unsupported/thehive/1.0.0/requirements.txt @@ -1,3 +1,3 @@ -requests==2.25.1 +requests==2.32.4 thehive4py==1.8.1 python-magic==0.4.18 diff --git a/microsoft-security-oauth2/1.0.0/run b/unsupported/thehive/1.0.0/run similarity index 100% rename from microsoft-security-oauth2/1.0.0/run rename to unsupported/thehive/1.0.0/run diff --git a/thehive/1.0.0/src/app.py b/unsupported/thehive/1.0.0/src/app.py similarity index 100% rename from thehive/1.0.0/src/app.py rename to unsupported/thehive/1.0.0/src/app.py diff --git a/thehive/1.0.0/Dockerfile b/unsupported/thehive/1.1.0/Dockerfile similarity index 100% rename from thehive/1.0.0/Dockerfile rename to unsupported/thehive/1.1.0/Dockerfile diff --git a/thehive/1.1.0/api.yaml b/unsupported/thehive/1.1.0/api.yaml similarity index 100% rename from thehive/1.1.0/api.yaml rename to unsupported/thehive/1.1.0/api.yaml diff --git a/oauth2-example/1.0.0/docker-compose.yml b/unsupported/thehive/1.1.0/docker-compose.yml similarity index 100% rename from oauth2-example/1.0.0/docker-compose.yml rename to unsupported/thehive/1.1.0/docker-compose.yml diff --git a/oauth2-example/1.0.0/env.txt b/unsupported/thehive/1.1.0/env.txt similarity index 100% rename from oauth2-example/1.0.0/env.txt rename to unsupported/thehive/1.1.0/env.txt diff --git a/oauth2-example/1.0.0/requirements.txt b/unsupported/thehive/1.1.0/requirements.txt similarity index 69% rename from oauth2-example/1.0.0/requirements.txt rename to unsupported/thehive/1.1.0/requirements.txt index 1d40c46a..175d3de0 100644 --- a/oauth2-example/1.0.0/requirements.txt +++ b/unsupported/thehive/1.1.0/requirements.txt @@ -1,3 +1,3 @@ -requests==2.25.1 +requests==2.32.4 thehive4py==1.8.1 python-magic==0.4.18 diff --git a/oauth2-example/1.0.0/run b/unsupported/thehive/1.1.0/run similarity index 100% rename from oauth2-example/1.0.0/run rename to unsupported/thehive/1.1.0/run diff --git a/thehive/1.1.0/src/app.py b/unsupported/thehive/1.1.0/src/app.py similarity index 100% rename from thehive/1.1.0/src/app.py rename to unsupported/thehive/1.1.0/src/app.py diff --git a/thehive/1.1.0/Dockerfile b/unsupported/thehive/1.1.1/Dockerfile similarity index 100% rename from thehive/1.1.0/Dockerfile rename to unsupported/thehive/1.1.1/Dockerfile diff --git a/thehive/1.1.1/api.yaml b/unsupported/thehive/1.1.1/api.yaml similarity index 100% rename from thehive/1.1.1/api.yaml rename to unsupported/thehive/1.1.1/api.yaml diff --git a/thehive/1.0.0/docker-compose.yml b/unsupported/thehive/1.1.1/docker-compose.yml similarity index 100% rename from thehive/1.0.0/docker-compose.yml rename to unsupported/thehive/1.1.1/docker-compose.yml diff --git a/thehive/1.0.0/env.txt b/unsupported/thehive/1.1.1/env.txt similarity index 100% rename from thehive/1.0.0/env.txt rename to unsupported/thehive/1.1.1/env.txt diff --git a/thehive/1.1.0/requirements.txt b/unsupported/thehive/1.1.1/requirements.txt similarity index 69% rename from thehive/1.1.0/requirements.txt rename to unsupported/thehive/1.1.1/requirements.txt index 1d40c46a..175d3de0 100644 --- a/thehive/1.1.0/requirements.txt +++ b/unsupported/thehive/1.1.1/requirements.txt @@ -1,3 +1,3 @@ -requests==2.25.1 +requests==2.32.4 thehive4py==1.8.1 python-magic==0.4.18 diff --git a/thehive/1.1.1/run b/unsupported/thehive/1.1.1/run similarity index 100% rename from thehive/1.1.1/run rename to unsupported/thehive/1.1.1/run diff --git a/thehive/1.1.1/src/app.py b/unsupported/thehive/1.1.1/src/app.py similarity index 100% rename from thehive/1.1.1/src/app.py rename to unsupported/thehive/1.1.1/src/app.py diff --git a/thehive/1.1.1/Dockerfile b/unsupported/thehive/1.1.2/Dockerfile similarity index 100% rename from thehive/1.1.1/Dockerfile rename to unsupported/thehive/1.1.2/Dockerfile diff --git a/thehive/1.1.2/api.yaml b/unsupported/thehive/1.1.2/api.yaml similarity index 100% rename from thehive/1.1.2/api.yaml rename to unsupported/thehive/1.1.2/api.yaml diff --git a/thehive/1.1.0/docker-compose.yml b/unsupported/thehive/1.1.2/docker-compose.yml similarity index 100% rename from thehive/1.1.0/docker-compose.yml rename to unsupported/thehive/1.1.2/docker-compose.yml diff --git a/thehive/1.1.0/env.txt b/unsupported/thehive/1.1.2/env.txt similarity index 100% rename from thehive/1.1.0/env.txt rename to unsupported/thehive/1.1.2/env.txt diff --git a/thehive/1.0.0/requirements.txt b/unsupported/thehive/1.1.2/requirements.txt similarity index 69% rename from thehive/1.0.0/requirements.txt rename to unsupported/thehive/1.1.2/requirements.txt index 1d40c46a..175d3de0 100644 --- a/thehive/1.0.0/requirements.txt +++ b/unsupported/thehive/1.1.2/requirements.txt @@ -1,3 +1,3 @@ -requests==2.25.1 +requests==2.32.4 thehive4py==1.8.1 python-magic==0.4.18 diff --git a/thehive/1.1.2/run b/unsupported/thehive/1.1.2/run similarity index 100% rename from thehive/1.1.2/run rename to unsupported/thehive/1.1.2/run diff --git a/thehive/1.1.2/src/app.py b/unsupported/thehive/1.1.2/src/app.py similarity index 100% rename from thehive/1.1.2/src/app.py rename to unsupported/thehive/1.1.2/src/app.py diff --git a/thehive/1.1.2/Dockerfile b/unsupported/thehive/1.1.3/Dockerfile similarity index 100% rename from thehive/1.1.2/Dockerfile rename to unsupported/thehive/1.1.3/Dockerfile diff --git a/thehive/1.1.3/api.yaml b/unsupported/thehive/1.1.3/api.yaml similarity index 91% rename from thehive/1.1.3/api.yaml rename to unsupported/thehive/1.1.3/api.yaml index f7f16932..75c8f97e 100644 --- a/thehive/1.1.3/api.yaml +++ b/unsupported/thehive/1.1.3/api.yaml @@ -843,6 +843,96 @@ actions: returns: schema: type: string + - name: update_alert + description: Update alert in TheHive + parameters: + - name: id + description: The alert id + example: "~123949208" + required: true + multiline: false + schema: + type: string + - name: alerttype + description: The type to use for the alert + example: "incident" + required: false + multiline: false + schema: + type: string + - name: source + description: The source to use + example: "SIEM" + required: false + multiline: false + schema: + type: string + - name: sourceRef + description: The source reference to use + example: "incident-1234" + required: false + multiline: false + schema: + type: string + - name: title + description: The alert title to be used + example: "MyAlert Title" + required: false + multiline: false + schema: + type: string + - name: description + description: The alert description to be used + example: "MyAlert description" + required: false + multiline: false + schema: + type: string + - name: tlp + description: "Alert's TLP: 0, 1, 2, 3 for WHITE, GREEN, AMBER, RED" + example: 2 + required: false + multiline: false + schema: + type: integer + - name: pap + description: "Alert's PAP: 0, 1, 2, 3 for WHITE, GREEN, AMBER, RED" + example: 2 + required: false + multiline: false + schema: + type: integer + - name: severity + description: "Alert's severity: 1, 2, 3, 4 for LOW, MEDIUM, HIGH, CRTICAL" + example: 2 + required: false + multiline: false + schema: + type: integer + - name: tags + description: List of tags to be used + example: "tag1,tag2,tag3" + required: false + multiline: false + schema: + type: string + - name: custom_fields + description: Alert customfields to be used + example: | + { + "mystrcustomfield": "blah blah blah", + "myintcustomfield": 1234, + "myboolcustomfield": False, + "myfloatcustomfield": 12.3456, + ... + } + required: false + multiline: true + schema: + type: string + returns: + schema: + type: string - name: get_organisations description: Get all TheHive organisations returns: diff --git a/thehive/1.1.1/docker-compose.yml b/unsupported/thehive/1.1.3/docker-compose.yml similarity index 100% rename from thehive/1.1.1/docker-compose.yml rename to unsupported/thehive/1.1.3/docker-compose.yml diff --git a/thehive/1.1.1/env.txt b/unsupported/thehive/1.1.3/env.txt similarity index 100% rename from thehive/1.1.1/env.txt rename to unsupported/thehive/1.1.3/env.txt diff --git a/unsupported/thehive/1.1.3/requirements.txt b/unsupported/thehive/1.1.3/requirements.txt new file mode 100644 index 00000000..175d3de0 --- /dev/null +++ b/unsupported/thehive/1.1.3/requirements.txt @@ -0,0 +1,3 @@ +requests==2.32.4 +thehive4py==1.8.1 +python-magic==0.4.18 diff --git a/thehive/1.1.3/run b/unsupported/thehive/1.1.3/run similarity index 100% rename from thehive/1.1.3/run rename to unsupported/thehive/1.1.3/run diff --git a/thehive/1.1.3/src/app.py b/unsupported/thehive/1.1.3/src/app.py similarity index 85% rename from thehive/1.1.3/src/app.py rename to unsupported/thehive/1.1.3/src/app.py index 8ab94b14..15a94d64 100644 --- a/thehive/1.1.3/src/app.py +++ b/unsupported/thehive/1.1.3/src/app.py @@ -22,7 +22,7 @@ class TheHive(AppBase): Inherit from the AppBase class to have Redis, logging, and console logging set up behind the scenes. """ - __version__ = "1.1.0" + __version__ = "1.1.3" app_name = "thehive" def __init__(self, redis, logger, console_logger=None): @@ -255,14 +255,14 @@ def create_alert( tlp = int(tlp) if isinstance(severity, str): if not severity.isdigit(): - return "Severity needs to be a number from 1-3, not %s" % severity + return "Severity needs to be a number from 1-4, not %s" % severity severity = int(severity) if tlp > 3 or tlp < 0: return "TLP needs to be a number from 0-3, not %d" % tlp - if severity > 3 or severity < 1: - return "Severity needs to be a number from 1-3, not %d" % severity + if severity > 4 or severity < 1: + return f"Severity needs to be a number from 1-4, not {severity}" all_artifacts = [] if isinstance(artifacts, str): @@ -423,7 +423,7 @@ def create_case_from_alert( def merge_alert_into_case(self, apikey, url, organisation, alert_id, case_id): self.__connect_thehive(url, apikey, organisation) req = url + f"/api/alert/{alert_id}/merge/{case_id}" - ret = requests.post(req, auth=self.thehive.auth) + ret = requests.post(req, auth=self.thehive.auth, verify=False) return ret.text # Not sure what the data should be @@ -457,6 +457,7 @@ def update_field( "Content-Type": "application/json", "Authorization": "Bearer %s" % apikey, }, + verify=False, ) else: ret = requests.patch( @@ -466,10 +467,11 @@ def update_field( "Authorization": "Bearer %s" % apikey, }, json=newdata, + verify=False, ) return str(ret.status_code) - + elif field_type.lower() == 'case': return 'Use update_case action for updating a case.' else: @@ -530,6 +532,7 @@ def add_task_log( headers=headers, files=files, data=data, + verify=False, ) return response.text @@ -785,6 +788,137 @@ def update_case( return json.dumps(result.json(), indent=4, sort_keys=True) + # Update TheHIVE alert + def update_alert( + self, + apikey, + url, + organisation, + id, + alerttype="", + source="", + sourceRef="", + title="", + description="", + tlp=None, + pap=None, + severity=None, + tags="", + custom_fields=None + ): + self.__connect_thehive(url, apikey, organisation) + + # get the current data for the alert + alert = self.thehive.get_alert(id).json() + + # Update information if given by the user, otherwise, + # use the already present data retrieved above + alert_type = alerttype if alerttype else alert["type"] + alert_source = source if source else alert["source"] + alert_sourceRef = sourceRef if sourceRef else alert["sourceRef"] + alert_title = title if title else alert["title"] + alert_description = description if description else alert["description"] + + # tlp handling + alert_tlp = int(tlp) if tlp else alert["tlp"] + + if alert_tlp > 3 or alert_tlp < 0: + return "TLP needs to be a number from 0-3, not %d" % alert_tlp + + # pap handling + alert_pap = int(pap) if pap else alert["pap"] + + if alert_pap > 3 or alert_pap < 0: + return "PAP needs to be a number from 0-3, not %d" % alert_pap + + # severity handling + alert_severity = int(severity) if severity else alert["severity"] + + if alert_severity > 4 or alert_severity < 1: + return "Severity needs to be a number from 1-4, not %s" % alert_severity + + # tags handling + if tags: + if ", " in tags: + alert_tags = tags.split(", ") + elif "," in tags: + alert_tags = tags.split(",") + else: + alert_tags = [tags] + else: + alert_tags = alert["tags"] + + # custom fields handling + alert_customFields = alert["customFields"] + + customfields = CustomFieldHelper() + if alert_customFields: + for key, value in alert_customFields.items(): + if list(value)[0] == "integer": + customfields.add_integer(key, list(value.items())[0][1]) + elif list(value)[0] == "string": + customfields.add_string(key, list(value.items())[0][1]) + elif list(value)[0] == "boolean": + customfields.add_boolean(key, list(value.items())[0][1]) + elif list(value)[0] == "float": + customfields.add_float(key, list(value.items())[0][1]) + else: + print(f'The value type "{value}" of the field {key} is not suported by the function.') + + if isinstance(custom_fields, str): + try: + custom_fields = json.loads(custom_fields) if custom_fields else {} + except json.decoder.JSONDecodeError: + return "Custom fields need to be valid json" + + for key, value in custom_fields.items(): + if type(value) == int: + customfields.add_integer(key, value) + elif type(value) == str: + customfields.add_string(key, value) + elif type(value) == bool: + customfields.add_boolean(key, value) + elif type(value) == float: + customfields.add_float(key, value) + else: + print(f'The value type "{value}" of the field {key} is not suported by the function.') + + alert_customfields = customfields.build() + + # Prepare the fields to be updated + alert = Alert( + id=id, + type=alert_type, + source=alert_source, + sourceRef=alert_sourceRef, + title=alert_title, + description=alert_description, + tlp=alert_tlp, + pap=alert_pap, + severity=alert_severity, + tags=alert_tags, + customFields=alert_customfields, + ) + + result = self.thehive.update_alert( + alert_id=id, + alert=alert, + fields=[ + "type", + "source", + "sourceRef", + "title", + "description", + "tlp", + "pap", + "severity", + "tags", + "customFields", + ], + ) + + return json.dumps(result.json(), indent=4, sort_keys=True) + # Get TheHive Organisations def get_organisations( self, @@ -965,23 +1099,24 @@ def create_task( response = self.thehive.create_case_task(case_id, case_task) return response.text - + # Close TheHive case Task def update_task(self,apikey,url,organisation,task_id,status): if status == "Completed": - + # Add EndDate Time before close headers = { "Authorization": f"Bearer {apikey}", } if organisation: headers["X-Organisation"] = organisation - + data = {"endDate": round(time.time() * 1000)} requests.patch( f"{url}/api/case/task/{task_id}", headers=headers, data=data, + verify=False, ) task = CaseTask( id=task_id, @@ -992,9 +1127,9 @@ def update_task(self,apikey,url,organisation,task_id,status): id = task_id, status = status, ) - + response = self.thehive.update_case_task(task, fields=["status"]) - + return response.text diff --git a/thehive/README.md b/unsupported/thehive/README.md similarity index 87% rename from thehive/README.md rename to unsupported/thehive/README.md index 003726ad..657492d3 100644 --- a/thehive/README.md +++ b/unsupported/thehive/README.md @@ -2,7 +2,7 @@ ## Configuration -![conf](conf.png) +![conf](https://github.com/Shuffle/python-apps/blob/master/thehive/conf.png?raw=true) ### Thehive3 - Leave **Organisation** empty @@ -19,4 +19,4 @@ **Note:** You may want one api key from thehive to be used by Shuffle or one per org, so the configuration of the Thehive App depends on your choice. -Of course on each use case, you can setup an **Authentication**, and every time you add a new node you just need to select from the list which authentication to use. The only different will be between having multiple api users or a single one. -- recommended way \ No newline at end of file +Of course on each use case, you can setup an **Authentication**, and every time you add a new node you just need to select from the list which authentication to use. The only different will be between having multiple api users or a single one. -- recommended way diff --git a/thehive/conf.png b/unsupported/thehive/conf.png similarity index 100% rename from thehive/conf.png rename to unsupported/thehive/conf.png diff --git a/http/1.3.0/Dockerfile b/unsupported/twitter/1.0.0/Dockerfile similarity index 98% rename from http/1.3.0/Dockerfile rename to unsupported/twitter/1.0.0/Dockerfile index 9bbc5110..364e1531 100644 --- a/http/1.3.0/Dockerfile +++ b/unsupported/twitter/1.0.0/Dockerfile @@ -17,7 +17,6 @@ RUN pip install --prefix="/install" -r /requirements.txt FROM base COPY --from=builder /install /usr/local COPY src /app -RUN apk add curl # Install any binary dependencies needed in our final image # RUN apk --no-cache add --update my_binary_dependency diff --git a/twitter/1.0.0/api.yaml b/unsupported/twitter/1.0.0/api.yaml similarity index 100% rename from twitter/1.0.0/api.yaml rename to unsupported/twitter/1.0.0/api.yaml diff --git a/unsupported/twitter/1.0.0/requirements.txt b/unsupported/twitter/1.0.0/requirements.txt new file mode 100644 index 00000000..5d086241 --- /dev/null +++ b/unsupported/twitter/1.0.0/requirements.txt @@ -0,0 +1,2 @@ +requests==2.32.4 +twython==3.9.1 diff --git a/twitter/1.0.0/src/app.py b/unsupported/twitter/1.0.0/src/app.py similarity index 100% rename from twitter/1.0.0/src/app.py rename to unsupported/twitter/1.0.0/src/app.py diff --git a/shuffle-tools/1.1.0/Dockerfile b/unsupported/vulndb/1.0.0/Dockerfile similarity index 82% rename from shuffle-tools/1.1.0/Dockerfile rename to unsupported/vulndb/1.0.0/Dockerfile index 5c1a8af4..364e1531 100644 --- a/shuffle-tools/1.1.0/Dockerfile +++ b/unsupported/vulndb/1.0.0/Dockerfile @@ -5,13 +5,13 @@ FROM frikky/shuffle:app_sdk as base FROM base as builder # Install all alpine build tools needed for our pip installs -RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev git +RUN apk --no-cache add --update alpine-sdk libffi libffi-dev musl-dev openssl-dev # Install all of our pip packages in a single directory that we can copy to our base image later RUN mkdir /install WORKDIR /install COPY requirements.txt /requirements.txt -RUN pip install --no-cache-dir --prefix="/install" -r /requirements.txt +RUN pip install --prefix="/install" -r /requirements.txt # Switch back to our base image and copy in all of our built packages and source code FROM base @@ -20,8 +20,7 @@ COPY src /app # Install any binary dependencies needed in our final image # RUN apk --no-cache add --update my_binary_dependency -RUN apk --no-cache add jq git curl # Finally, lets run our app! WORKDIR /app -CMD ["python", "app.py", "--log-level", "DEBUG"] +CMD python app.py --log-level DEBUG diff --git a/unsupported/vulndb/1.0.0/api.yaml b/unsupported/vulndb/1.0.0/api.yaml new file mode 100644 index 00000000..1a55a810 --- /dev/null +++ b/unsupported/vulndb/1.0.0/api.yaml @@ -0,0 +1,35 @@ +app_version: 1.0.0 +name: VulnDB +description: VulnDB vulnerability notifications (https://vulndb.cyberriskanalytics.com/) +contact_info: + name: "@fritzbacke" + url: https://github.com/fritzbacke + email: fritzbacke@gmx.org +tags: + - Testing + - Assets + - Vulnerabilities +categories: + - Assets +authentication: + required: true + parameters: + - name: ClientID + description: The client ID generated at VulnDB for this OAuth2 application + example: "" + required: true + schema: + type: string + - name: ClientSecret + description: The client secret generated at VulnDB for this OAuth2 application + example: "*****" + required: true + schema: + type: string +actions: + - name: latest_20_vulns + description: Return the 20 most recent vulnerabilities as JSON object + returns: + schema: + type: string +large_image: data:image/jpg;base64,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 diff --git a/vulndb/1.0.0/docs.md b/unsupported/vulndb/1.0.0/docs.md similarity index 100% rename from vulndb/1.0.0/docs.md rename to unsupported/vulndb/1.0.0/docs.md diff --git a/unsupported/vulndb/1.0.0/requirements.txt b/unsupported/vulndb/1.0.0/requirements.txt new file mode 100644 index 00000000..bd6f2345 --- /dev/null +++ b/unsupported/vulndb/1.0.0/requirements.txt @@ -0,0 +1 @@ +requests==2.32.4 diff --git a/vulndb/1.0.0/shield-vulndb.svg b/unsupported/vulndb/1.0.0/shield-vulndb.svg similarity index 100% rename from vulndb/1.0.0/shield-vulndb.svg rename to unsupported/vulndb/1.0.0/shield-vulndb.svg diff --git a/vulndb/1.0.0/src/app.py b/unsupported/vulndb/1.0.0/src/app.py similarity index 100% rename from vulndb/1.0.0/src/app.py rename to unsupported/vulndb/1.0.0/src/app.py diff --git a/velociraptor/1.0.0/Dockerfile b/velociraptor/1.0.0/Dockerfile new file mode 100644 index 00000000..80c2f814 --- /dev/null +++ b/velociraptor/1.0.0/Dockerfile @@ -0,0 +1,20 @@ +# GRPC base image to reduce build time +FROM frikky/shuffle:app_sdk_grpc as base + +# We're going to stage away all of the bloat from the build tools so lets create a builder stage +FROM base as builder + +# Install all of our pip packages in a single directory that we can copy to our base image later +RUN mkdir /install +WORKDIR /install +COPY requirements.txt /requirements.txt +RUN pip install --prefix="/install" -r /requirements.txt + +# Switch back to our base image and copy in all of our built packages and source code +FROM base +COPY --from=builder /install /usr/local +COPY src /app + +# Finally, lets run our app! +WORKDIR /app +CMD python app.py --log-level DEBUG diff --git a/velociraptor/1.0.0/README.md b/velociraptor/1.0.0/README.md new file mode 100644 index 00000000..53085be4 --- /dev/null +++ b/velociraptor/1.0.0/README.md @@ -0,0 +1,54 @@ +# Velociraptor +## Overview +Velociraptor is an open source, cross-platform endpoint visibility tool that allows for endpoint detection, forensics, monitoring, and response at scale. + +You can read more about Velociraptor here: https://docs.velociraptor.app/ + +This app allows provides integration with Velociraptor's GRPC API to facilitate the automation of artifact collection and response actions to increase context and save defenders time during security operations and investigations. + +## Actions +The following actions are currently available: + +- Add client label +- Add client quarantine (Only Windows hosts supported at this time) +- Get client ID +- Get client flows +- Get client flow results +- Get client label +- Get hunt flows +- Get hunt results +- Remove client label +- Remove client quarantine +- Search filename (create a hunt for a particular file name) +- Search hash (create a hunt for a particular file hash) +- Search with custom query (free-form VQL query) + +## Authentication + +#### Create API config file +An API config file must be created for authentication to the Velociraptor API. Instructions on how to create this file can be found here: + +https://docs.velociraptor.app/docs/server_automation/server_api/#creating-a-client-api-certificate + +#### Upload file to Shuffle +Navigate to `ADMIN -> Files`, then upload your API config file. Make sure to copy the file ID, as you'll need it when configuring the app in the workflow +![image](https://user-images.githubusercontent.com/16829864/165663167-35c965fd-829b-497d-9265-12da98736a64.png) + +#### Add Authentication in Worklow +Next, inside of a new workflow, add the Velociraptor app, then click to configure it: + +![image](https://user-images.githubusercontent.com/16829864/165663321-c9760a57-1d6c-4ccc-a4f9-9c3d0ce5d289.png) + + +Enter a title for the authentication configuration, and paste the file ID into the `api_config` input field: + +![image](https://user-images.githubusercontent.com/16829864/165663556-bd48696c-e613-4079-8feb-383012f2fa1b.png) + +#### Test Authentication +To test authentication, try using the `Search with custom query` action with the following query: + +`SELECT * FROM info()` + +Results similar to the following should be returned: + +![image](https://user-images.githubusercontent.com/16829864/165664085-ac40f855-c32b-4b18-ad90-cb1a3651ca35.png) diff --git a/velociraptor/1.0.0/api.yaml b/velociraptor/1.0.0/api.yaml new file mode 100644 index 00000000..39fd1b4a --- /dev/null +++ b/velociraptor/1.0.0/api.yaml @@ -0,0 +1,247 @@ +walkoff_version: 1.0.0 +app_version: 1.0.0 +name: velociraptor +description: Interact with Velociraptor API +tags: + - Collect + - DFIR + - Hunt + - Incident Response +categories: + - Incident Response +contact_info: + name: "@therealwlambert" + url: https://github.com/weslambert + email: "wlambertts@gmail.com" +authentication: + required: true + parameters: + - name: api_config + description: Velociraptor API config file + example: $fileid + required: true + schema: + type: string +actions: + - name: add_client_label + description: Add label to Velociraptor client + parameters: + - name: client_id + description: Velociraptor client ID + multiline: false + example: + required: true + schema: + type: string + - name: label + description: Label to apply to Velociraptor client + multiline: false + example: badfile.txt + required: true + schema: + type: string + returns: + schema: + type: string + + - name: add_client_quarantine + description: Add Velociraptor client host to quarantine (only supported for Windows hosts at this time) + parameters: + - name: client_id + description: Host to correlate to client ID + multiline: false + example: C.C9FCF48FF278C + required: true + schema: + type: string + returns: + schema: + type: string + + - name: get_artifact_definitions + description: Get Velociraptor artifact definitions + returns: + schema: + type: string + + - name: get_client_id + description: Get Velociraptor client ID for a host + parameters: + - name: host + description: Host to correlate to client ID + multiline: false + example: 192.168.6.60 + required: true + schema: + type: string + returns: + schema: + type: string + + - name: get_client_flows + description: Get flows for a Velociraptor client + parameters: + - name: client_id + description: Velociraptor client ID + multiline: false + example: C.C9FCF48FF278C + required: true + schema: + type: string + returns: + schema: + type: string + + - name: get_client_flow_results + description: Get results for a Velociraptor client flow + parameters: + - name: flow_id + description: Velociraptor flow ID + multiline: false + example: F.C9FCF48FF278C + required: true + schema: + type: string + - name: client_id + description: Velociraptor client ID + multiline: false + example: C.C9FCF48FF278C + required: true + schema: + type: string + returns: + schema: + type: string + + - name: get_client_label + description: Check if label exists for Velociraptor client + parameters: + - name: client_id + description: Velociraptor client ID + multiline: false + example: + required: true + schema: + type: string + - name: label + description: Label to check for Velociraptor client + multiline: false + example: badfile.txt + required: true + schema: + type: string + returns: + schema: + type: string + + - name: get_hunt_flows + description: Get flows for a Velociraptor hunt + parameters: + - name: hunt_id + description: Velociraptor hunt ID + multiline: false + example: H.C9FCF48FF278C + required: true + schema: + type: string + returns: + schema: + type: string + + - name: get_hunt_results + description: Get results for a Velociraptor hunt + parameters: + - name: hunt_id + description: Velociraptor hunt ID + multiline: false + example: H.C9FCF48FF278C + required: true + schema: + type: string + returns: + schema: + type: string + + - name: remove_client_label + description: Remove label from Velociraptor client + parameters: + - name: client_id + description: Velociraptor client ID + multiline: false + example: + required: true + schema: + type: string + - name: label + description: Label to remove from Velociraptor client + multiline: false + example: badfile.txt + required: true + schema: + type: string + returns: + schema: + type: string + + - name: remove_client_quarantine + description: Remove Velociraptor client host from quarantine + parameters: + - name: client_id + description: Velociraptor client ID + multiline: false + example: C.C9FCF48FF278C + required: true + schema: + type: string + returns: + schema: + type: string + - name: search_filename + description: Start Velociraptor Hunt for a file of a particular name + parameters: + - name: filepath + description: File path + multiline: false + example: + required: true + schema: + type: string + - name: filename + description: Filename + multiline: false + example: badfile.txt + required: true + schema: + type: string + returns: + schema: + type: string + + - name: search_hash + description: Start Velociraptor Hunt for a hash of a particular file + parameters: + - name: filehash + description: Hash + multiline: false + example: abcd1234 + required: true + schema: + type: string + returns: + schema: + type: string + + - name: search_with_custom_query + description: Perform free-form Velociraptor query and get back a response + parameters: + - name: query + description: Query + multiline: false + example: 'SELECT * FROM info()' + required: true + schema: + type: string + returns: + schema: + type: string +large_image: data:image/png;base64,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 diff --git a/velociraptor/1.0.0/requirements.txt b/velociraptor/1.0.0/requirements.txt new file mode 100644 index 00000000..7698bd2c --- /dev/null +++ b/velociraptor/1.0.0/requirements.txt @@ -0,0 +1 @@ +pyvelociraptor==0.1.8 diff --git a/velociraptor/1.0.0/src/app.py b/velociraptor/1.0.0/src/app.py new file mode 100644 index 00000000..0e8bed87 --- /dev/null +++ b/velociraptor/1.0.0/src/app.py @@ -0,0 +1,155 @@ +import json +import grpc +import ipaddress +import time +import yaml +from pyvelociraptor import api_pb2 +from pyvelociraptor import api_pb2_grpc +from walkoff_app_sdk.app_base import AppBase + + +class Velociraptor(AppBase): + + __version__ = "1.0.0" + app_name = "velociraptor" + + def __init__(self, redis, logger, console_logger=None): + """ + Each app should have this __init__ to set up Redis and logging. + :param redis: + :param logger: + :param console_logger: + """ + super().__init__(redis, logger, console_logger) + + def auth(self, api_config): + credfile = self.get_file(api_config)["data"] + config = yaml.load(credfile, Loader=yaml.FullLoader) + creds = grpc.ssl_channel_credentials( + root_certificates=config["ca_certificate"].encode("utf8"), + private_key=config["client_private_key"].encode("utf8"), + certificate_chain=config["client_cert"].encode("utf8") + ) + + return creds, config + + def request(self, api_config, query): + creds = self.auth(api_config)[0] + config = self.auth(api_config)[1] + options = (('grpc.ssl_target_name_override', "VelociraptorServer",),) + with grpc.secure_channel(config["api_connection_string"], creds, options) as channel: + stub = api_pb2_grpc.APIStub(channel) + client_query = query + client_request = api_pb2.VQLCollectorArgs( + max_wait=60, + Query=[api_pb2.VQLRequest( + Name="ShuffleQuery", + VQL=client_query, + )]) + + r = [] + for response in stub.Query(client_request): + if response.Response: + r = r + json.loads(response.Response) + return r + + def add_client_label(self, api_config, client_id, label): + query = "SELECT label(client_id='" + client_id + "', labels=['" + label +"'], op='set') FROM scope()'" + results = self.request(api_config, query) + return results + + + def get_client_label(self, api_config, client_id, label): + query = "SELECT label(client_id='" + client_id + "', labels=['" + label +"'], op='check') FROM scope()'" + results = self.request(api_config, query) + return results + + def remove_client_label(self, api_config, client_id, label): + query = "SELECT label(client_id='" + client_id + "', labels=['" + label +"'], op='remove') FROM scope()'" + results = self.request(api_config, query) + return results + + + def add_client_quarantine(self, api_config, client_id): + query = 'SELECT collect_client(client_id="' + client_id + '", artifacts=["Windows.Remediation.Quarantine"], spec=dict(`Windows.Remediation.Quarantine`=dict())) FROM scope()' + results = self.request(api_config, query) + return results + + def remove_client_quarantine(self, api_config, client_id): + query = 'SELECT collect_client(client_id="' + client_id + '", artifacts=["Windows.Remediation.Quarantine"], spec=dict(`Windows.Remediation.Quarantine`=dict(`RemovePolicy`="Y"))) FROM scope()' + results = self.request(api_config, query) + return results + + def get_artifact_definitions(self, api_config): + query = 'SELECT name, description, parameters FROM artifact_definitions(deps=True)' + results = self.request(api_config, query) + return results + + def get_client_id(self, api_config, host): + try: + if ipaddress.ip_address(host): + query = "SELECT client_id FROM clients() WHERE last_ip =~ '" + host + "'" + except: + query = "SELECT client_id FROM clients(search=" + host + ")" + results = self.request(api_config, query) + + try: + return { + "success": True, + "reason": results [0]['client_id'] + } + except Exception as e: + return { + "success": False, + "reason": "An error happened getting client ID. This usually means the Client ID doesn't exist.", + "details": f"{e}" + } + + def get_client_flows(self, api_config, client_id): + query = "SELECT * FROM flows(client_id='" + client_id + "')" + results = self.request(api_config, query) + return results + + def get_client_flow_results(self, api_config, client_id, flow_id): + state = self.get_client_flow_status(api_config, client_id, flow_id) + while (state == "RUNNING"): + state = self.get_client_flow_status(api_config, client_id, flow_id) + if state == "FINISHED": + break + else: + time.sleep(5) + query = "SELECT * FROM flow_results(flow_id='" + flow_id + "', client_id='" + client_id + "')" + results = self.request(api_config, query) + return results[0] + + def get_client_flow_status(self, api_config, client_id, flow_id): + query = "SELECT * FROM flows(flow_id='" + flow_id + "', client_id='" + client_id + "')" + results = self.request(api_config, query) + return results[0]['state'] + + def get_hunt_flows(self, api_config, hunt_id): + query = 'SELECT * FROM hunt_flows(hunt_id="' + hunt_id + '")' + results = results = self.request(api_config, query) + return results[0] + + def get_hunt_results(self, api_config, hunt_id): + query = 'SELECT * FROM hunt_results(hunt_id="' + hunt_id + '")' + results = results = self.request(api_config, query) + return results + + def search_with_custom_query(self, api_config, query): + results = results = self.request(api_config, query) + return results + + def search_filename(self, api_config, filepath, filename): + query = 'SELECT hunt(description=\"Shuffle Filename Hunt::' + filename + '\", expires=(now() + 60) * 1000000,artifacts=[\"Linux.Search.FileFinder\",\"MacOS.Search.FileFinder\","Windows.Forensics.FilenameSearch\"],spec=dict(`Linux.Search.FileFinder`=dict(`SearchFilesGlob`=\"' + filename + '\"),`MacOS.Search.FileFinder`=dict(`SearchFilesGlob`=\"' + filename + '\"),`Windows.Forensics.FilenameSearch`=dict(`yaraRule`=\"wide nocase:' + filepath + filename + '\"))) AS Hunt FROM scope()' + results = self.request(api_config, query) + return results[0] + + def search_hash(self, api_config, filehash): + query = 'SELECT hunt(description=\"Shuffle Hash Hunt::' + filehash + '", expires=(now() + 60) * 1000000, artifacts=[\"Generic.Forensic.LocalHashes.Query\"],spec=dict(`Generic.Forensic.LocalHashes.Query`=dict(Hashes="Hash\\n' + filehash + '\\n"))) AS Hunt from scope()' + results = results = self.request(api_config, query) + return results[0] + +if __name__ == "__main__": + Velociraptor.run() diff --git a/vulndb/1.0.0/api.yaml b/vulndb/1.0.0/api.yaml deleted file mode 100644 index f67f7904..00000000 --- a/vulndb/1.0.0/api.yaml +++ /dev/null @@ -1,35 +0,0 @@ -app_version: 1.0.0 -name: VulnDB -description: VulnDB vulnerability notifications (https://vulndb.cyberriskanalytics.com/) -contact_info: - name: "@fritzbacke" - url: https://github.com/fritzbacke - email: fritzbacke@gmx.org -tags: - - Testing - - Assets - - Vulnerabilities -categories: - - Assets -authentication: - required: true - parameters: - - name: ClientID - description: The client ID generated at VulnDB for this OAuth2 application - example: "" - required: true - schema: - type: string - - name: ClientSecret - description: The client secret generated at VulnDB for this OAuth2 application - example: "*****" - required: true - schema: - type: string -actions: - - name: latest_20_vulns - description: Return the 20 most recent vulnerabilities as JSON object - returns: - schema: - type: string -large_image: data:image/svg+xml;base64,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 diff --git a/vulndb/1.0.0/requirements.txt b/vulndb/1.0.0/requirements.txt deleted file mode 100644 index f2293605..00000000 --- a/vulndb/1.0.0/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -requests diff --git a/yara/1.0.0/Dockerfile b/yara/1.0.0/Dockerfile index 04e84376..6212a329 100644 --- a/yara/1.0.0/Dockerfile +++ b/yara/1.0.0/Dockerfile @@ -57,4 +57,4 @@ RUN git clone https://github.com/Yara-Rules/rules /rules # Finally, lets run our app! WORKDIR /app -CMD python app.py --log-level DEBUG +CMD python app.py --log-level DEBUG \ No newline at end of file diff --git a/yara/1.0.0/api.yaml b/yara/1.0.0/api.yaml index 88fa9fc7..94935b7b 100644 --- a/yara/1.0.0/api.yaml +++ b/yara/1.0.0/api.yaml @@ -1,5 +1,5 @@ app_version: 1.0.0 -name: Yara +name: Yara description: Analyzes files based on set rules tags: - Intel @@ -32,6 +32,33 @@ actions: returns: schema: type: string + - name: analyze_by_file_category + description: Verifies if the file matches a certain rule + parameters: + - name: file_id + description: The file(s) to run towards + required: true + multiline: false + example: 2ff4c409-f66a-4bdc-bede-5dd5969a8c55 + schema: + type: string + - name: file_category + description: The rules to run from files + required: true + multiline: false + example: 'rule dummy { condition: true }' + schema: + type: string + - name: timeout + description: The timeout for all rules. Default 15 + required: false + multiline: false + example: 15 + schema: + type: string + returns: + schema: + type: string - name: download_rules description: Downloading rule testing parameters: @@ -72,4 +99,31 @@ actions: returns: schema: type: string + - name: custom_rules + description: Verifies if the file matches a certain rule + parameters: + - name: file_id + description: The file(s) to run towards + required: true + multiline: false + example: 2ff4c409-f66a-4bdc-bede-5dd5969a8c55 + schema: + type: string + - name: namespace + description: The rule to run + required: true + multiline: false + example: 'rule dummy { condition: true }' + schema: + type: string + - name: timeout + description: The timeout per rule. Default 15 + required: false + multiline: false + example: 15 + schema: + type: string + returns: + schema: + type: string large_image: data:image/png;base64,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 diff --git a/yara/1.0.0/requirements.txt b/yara/1.0.0/requirements.txt index 64fe70a3..73f08b38 100644 --- a/yara/1.0.0/requirements.txt +++ b/yara/1.0.0/requirements.txt @@ -1,2 +1,2 @@ # No extra requirements needed -requests==2.25.1 \ No newline at end of file +requests==2.32.4 diff --git a/yara/1.0.0/src/app.py b/yara/1.0.0/src/app.py index 5a09efac..a53f3896 100644 --- a/yara/1.0.0/src/app.py +++ b/yara/1.0.0/src/app.py @@ -6,7 +6,8 @@ import requests import yara import os - +import zipfile +from io import BytesIO from walkoff_app_sdk.app_base import AppBase class Yara(AppBase): @@ -40,6 +41,74 @@ def download_rules(self, namespace): return all_files + # Write your data inside this function + #https://yara.readthedocs.io/en/latest/yarapython.html + def analyze_by_file_category(self, file_id, file_category, timeout=15): + zipfiles = self.get_file_namespace(namespace) + if zipfiles == None: + return { + "success": False, + "reason": "Failed loading files from namespace %s" % namespace, + } + + all_files = "" + for name in zipfiles.namelist(): + for line in zipfiles.open(name).readlines(): + linedata = line.decode('utf-8') + all_files += linedata + + + print("Downloaded a lot of files from category %s!" % file_category) + if timeout == 0 or not timeout: + timeout = 15 + else: + timeout = int(timeout) + + file_ret = self.get_file(file_id) + #print("Getting file: %s" % file_id) + #print("FINISHED GETTING FILE: %s" % file_ret) + #rules.match(file) + + all_matches = [] + + rule='rule dummy { condition: true }' + rules = yara.compile(sources={ + 'rule': all_files, + }) + + matches = rules.match(data=file_ret["data"], timeout=timeout) + if len(matches) > 0: + for item in matches: + submatch = { + "tags": item.tags, + "file": filepath, + } + + try: + submatch["rule"] = item.rule.decode("utf-8") + except: + print(f"Failed RULE decoding for {item.rule}") + + try: + submatch["match"] = item.strings.decode("utf-8") + except: + print(f"Failed MATCH decoding for {item.strings}") + + all_matches.append(submatch) + + print("Matches: %d" % len(all_matches)) + print(all_matches) + + return_data = { + "success": True, + "matches": all_matches + } + + try: + return json.dumps(return_data) + except (json.JSONDecodeError, TypeError): + return return_data + # Write your data inside this function #https://yara.readthedocs.io/en/latest/yarapython.html def analyze_by_rule(self, file_id, rule, timeout=15): @@ -187,5 +256,73 @@ def analyze_file(self, file_id, timeout=15): except (json.JSONDecodeError, TypeError): return return_data + def custom_rules(self, file_id, namespace,timeout=15): + if timeout == 0 or not timeout: + timeout = 15 + else: + timeout = int(timeout) + + file_ret = self.get_file(file_id) + myzipfile = self.get_file_namespace(namespace) + failed_rules = list() + total_string_matches = 0 + all_matches = [] + + result = {} + + for name in myzipfile.namelist(): + file_data = myzipfile.open(name,mode="r").read().decode('utf-8') + try: + rules = yara.compile(source=file_data) + except Exception as e: + print("exception",e) + print(f"[INFO] Rule {name} failed") + failed_rules.append(file_data) + continue + + matches = rules.match(data=file_ret["data"].decode('utf-8'), timeout=timeout) + # result[str(name)] = matches[0] + if len(matches) > 0: + for item in matches: + submatch = { + "rule": item.rule, + "tags": item.tags, + "file": name, + "matches": [] + } + + for string in item.strings: + try: + submatch["matches"].append({ + "number": string[0], + "name": string[1], + "string": string[2].decode("utf-8"), + }) + except: + print(f"Failed MATCH decoding for {string}") + + submatch["total_matches"] = len(item.strings) + total_string_matches += len(item.strings) + all_matches.append(submatch) + + #print("Matches: %d" % len(all_matches)) + #print(all_matches) + + if len(all_matches) >= 10: + all_matches = all_matches[0:9] + + return_data = { + "success": True, + "matches": all_matches, + "failed_rules": len(failed_rules), + "total_rule_files": len(myzipfile.namelist()), + "total_string_matches": total_string_matches, + } + + try: + return json.dumps(return_data) + except (json.JSONDecodeError, TypeError): + return return_data + if __name__ == "__main__": Yara.run() diff --git a/yara/1.0.0/upload.sh b/yara/1.0.0/upload.sh new file mode 100644 index 00000000..e098fa32 --- /dev/null +++ b/yara/1.0.0/upload.sh @@ -0,0 +1,33 @@ +# Download it +#docker pull frikky/shuffle:yara_1.0.0 + +# NGROK TESTING: +# ./ngrok http 33340 +# Set reference_url to https://url.ngrok.io/api/v1/run + +## Starts Yara in swarm mode +#docker run \ +# -p "33340:33340" \ +# -e "SHUFFLE_APP_EXPOSED_PORT=33340" \ +# -e "SHUFFLE_SWARM_CONFIG=run" \ +# -e "SHUFFLE_LOGS_DISABLED=true" \ +# frikky/shuffle:yara_1.0.0 + + +## PS: This is all for testing for how to run it in Containers, and systems like Cloud Run +#europe-west2-docker.pkg.dev/shuffler/cloud-run-source-deploy/yara +#docker tag frikky/shuffle:yara_1.0.0 gcr.io/shuffle/yara-1.0.0 +#docker push gcr.io/shuffle/yara-1.0.0 + +# https://console.cloud.google.com/run/detail/europe-west2/yara/metrics +# gcloud run deploy --region=europe-west2 --max-instances=1 --set-env-vars=SHUFFLE_APP_EXPOSED_PORT=8080,SHUFFLE_SWARM_CONFIG=run,SHUFFLE_LOGS_DISABLED=true --image=europe-west2-docker.pkg.dev/shuffler/cloud-run-source-deploy/yara + +gcloud run deploy yara \ + --region=europe-west2 \ + --max-instances=1 \ + --set-env-vars=SHUFFLE_APP_EXPOSED_PORT=8080,SHUFFLE_SWARM_CONFIG=run,SHUFFLE_LOGS_DISABLED=true --source=./ \ + --service-account=shuffle-apps@shuffler.iam.gserviceaccount.com \ + --timeout=1800s + +# With image +## gcloud run deploy --region=europe-west2 --max-instances=1 --set-env-vars=SHUFFLE_APP_EXPOSED_PORT=8080,SHUFFLE_SWARM_CONFIG=run,SHUFFLE_LOGS_DISABLED=true --image=europe-west2-docker.pkg.dev/shuffler/cloud-run-source-deploy/yara