Back to skill

Security audit

Outlook for Work/School 365

Security checks for vulnerabilities and agentic risk

Overview

This Outlook skill mostly does what it claims, but it asks for powerful mail/calendar access and includes unsafe credential and file-handling patterns that users should review before installing.

Install only if you are comfortable granting this skill read/write access to Outlook mail and calendar, including sending mail and deleting or moving messages. Avoid using the token 'get' command, protect or periodically remove ~/.outlook-mcp, revoke the Azure app if you stop using the skill, do not run the curl | sudo bash installer suggestion, and be cautious downloading attachments because filenames are not safely contained.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (4)

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/outlook-setup.sh:25
Finding
Unpinned Remote Installer Is Recommended for Root-Level Execution<![CDATA[ ## Vulnerability Details **File Location**: `scripts/outlook-setup.sh:25-29` **Vulnerability Type**: Unverified remote payload retrieval and privileged execution **Risk Level**: Critical ### Vulnerable Code ```bash if ! command -v az &> /dev/null; then echo -e "${RED}Error: Azure CLI not installed${NC}" echo "Install with: curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash" exit 1 fi ``` ### Technical Analysis When Azure CLI is unavailable, the setup script recommends downloading a shell script from a mutable, redirecting URL and piping it directly into `sudo bash`. The command provides no version pinning, signature verification, checksum verification, or opportunity to inspect the downloaded content before execution. Although the URL is operated by Microsoft, its effective payload can change after the Skill has been reviewed. Consequently, executing the recommended command transfers complete trust to the current response returned through the URL and its redirect chain. This behavior exceeds the privileges needed merely to report a missing prerequisite: the Skill itself does not need to cause arbitrary remotely supplied shell content to run as root. ### Attack Path 1. A user starts `outlook-setup.sh` on a system without Azure CLI. 2. The script displays the `curl | sudo bash` installation command. 3. The user follows the displayed instruction. 4. `curl` follows redirects and retrieves the current remote installer. 5. The response is passed directly to `sudo bash` without validation. 6. If the upstream installer, redirect destination, delivery infrastructure, or trust chain is compromised, attacker-controlled commands execute as root. ### Impact Assessment Successful exploitation provides unrestricted root-level code execution. An attacker could read or alter all local files, extract Outlook and Azure credentials, install persistent services, modify system tools, or compromise other users and applications on the host. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Remove the `curl | sudo bash` recommendation. - Direct users to official Azure CLI installation documentation or use the operating system's authenticated package manager. - If automated retrieval is necessary, pin an explicit installer version and download it to a file before execution. - Verify a vendor signature or a securely distributed, pinned cryptographic checksum. - Display the resolved source and require explicit user review before privileged execution. - Avoid requesting root privileges except for the specific package-management operation that requires them. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/outlook-mail.sh:376
Finding
Attachment Names Permit Path Traversal and Arbitrary File Overwrite<![CDATA[ ## Vulnerability Details **File Location**: `scripts/outlook-mail.sh:376-405` **Vulnerability Type**: Path traversal and unsafe file creation **Risk Level**: High ### Vulnerable Code ```bash download) # Download an attachment: outlook-mail.sh download <msg-id> <attachment-name> [output-path] MSG_ID="$2" ATT_NAME="$3" OUTPUT="${4:-.}" if [ -z "$ATT_NAME" ]; then echo "Usage: outlook-mail.sh download <msg-id> <attachment-name> [output-path]" echo "Use 'attachments <id>' to see available attachments" exit 1 fi FULL_ID=$(curl -s "$API/messages?\$top=100&\$select=id" \ -H "Authorization: Bearer $ACCESS_TOKEN" | jq -r ".value[] | select(.id | endswith(\"$MSG_ID\")) | .id" | head -1) if [ -z "$FULL_ID" ]; then echo "Message not found" exit 1 fi # Get attachment by name ATT_DATA=$(curl -s "$API/messages/$FULL_ID/attachments" \ -H "Authorization: Bearer $ACCESS_TOKEN" | jq -r ".value[] | select(.name == \"$ATT_NAME\")") if [ -z "$ATT_DATA" ]; then echo "Attachment not found: $ATT_NAME" echo "Available attachments:" curl -s "$API/messages/$FULL_ID/attachments" -H "Authorization: Bearer $ACCESS_TOKEN" | jq -r '.value[].name' exit 1 fi # Get content and decode ATT_ID=$(echo "$ATT_DATA" | jq -r '.id') CONTENT=$(curl -s "$API/messages/$FULL_ID/attachments/$ATT_ID" \ -H "Authorization: Bearer $ACCESS_TOKEN" | jq -r '.contentBytes') OUTPUT_FILE="$OUTPUT/$ATT_NAME" echo "$CONTENT" | base64 -d > "$OUTPUT_FILE" ``` ### Technical Analysis The attachment name obtained from email metadata is appended directly to the caller-selected output directory. The code does not: - Reject absolute paths. - Reject `..` path components. - Reduce the name to a safe basename. - Canonicalize and verify that the final path remains under the intended directory. - Refuse existing files. ...[truncated 1289 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Treat attachment names exclusively as display metadata, not trusted filesystem paths. - Reject names containing `/`, backslashes, NUL bytes, absolute-path syntax, or `..` components. - Normalize the value to a safe basename and consider generating a local filename independently. - Resolve the canonical destination and verify that it remains beneath a dedicated download directory. - Create files with exclusive, no-follow semantics and refuse to overwrite existing files or symbolic links. - Apply restrictive permissions to downloaded files. - Return the sanitized local filename separately from the original attachment name. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/outlook-mail.sh:113
Finding
Untrusted Arguments Are Concatenated into JSON Request Bodies<![CDATA[ ## Vulnerability Details **File Location**: `scripts/outlook-mail.sh:113-128` and multiple related mail and calendar operations **Vulnerability Type**: JSON injection and malformed request construction **Risk Level**: Medium Additional affected locations include: - `scripts/outlook-mail.sh:254-261` - `scripts/outlook-mail.sh:294-310` - `scripts/outlook-mail.sh:342-355` - `scripts/outlook-mail.sh:421-447` - `scripts/outlook-mail.sh:563-576` - `scripts/outlook-calendar.sh:86-109` - `scripts/outlook-calendar.sh:117-140` - `scripts/outlook-calendar.sh:171-199` ### Vulnerable Code Representative mail-sending code: ```bash send) # Send email: outlook-mail.sh send "to@email.com" "Subject" "Body" TO="$2" SUBJECT="$3" BODY="$4" if [ -z "$TO" ] || [ -z "$SUBJECT" ]; then echo "Usage: outlook-mail.sh send <to> <subject> <body>" exit 1 fi RESULT=$(curl -s -w "\n%{http_code}" -X POST "$API/sendMail" \ -H "Authorization: Bearer $ACCESS_TOKEN" \ -H "Content-Type: application/json" \ -d "{ \"message\": { \"subject\": \"$SUBJECT\", \"body\": {\"contentType\": \"Text\", \"content\": \"$BODY\"}, \"toRecipients\": [{\"emailAddress\": {\"address\": \"$TO\"}}] } }") ``` Representative calendar-creation code: ```bash LOCATION_JSON="" if [ -n "$LOCATION" ]; then LOCATION_JSON=",\"location\": {\"displayName\": \"$LOCATION\"}" fi curl -s -X POST "$API/calendar/events" \ -H "Authorization: Bearer $ACCESS_TOKEN" \ -H "Content-Type: application/json" \ -d "{ \"subject\": \"$SUBJECT\", \"start\": {\"dateTime\": \"$START\", \"timeZone\": \"Europe/Madrid\"}, \"end\": {\"dateTime\": \"$END\", \"timeZone\": \"Europe/Madrid\"} $LOCATION_JSON }" | jq '{status: "event created", subject: .subject, start: .start.dateTime[0:16], end: .end.dateTime[0:16], id: .id[-20:]}' ``` ...[truncated 1790 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Construct every JSON body with `jq -n`, a language JSON library, or another serializer rather than string concatenation. - Pass each value through typed serializer arguments, for example: ```bash PAYLOAD=$(jq -n \ --arg to "$TO" \ --arg subject "$SUBJECT" \ --arg body "$BODY" \ '{ message: { subject: $subject, body: {contentType: "Text", content: $body}, toRecipients: [{emailAddress: {address: $to}}] } }') ``` - Submit the serialized value with `curl --data-binary "$PAYLOAD"`. - Validate recipients as email addresses and validate dates against the documented format. - Restrict update fields to the existing explicit allowlist. - Validate numeric count arguments and impose reasonable upper bounds. - Apply the same serializer-based construction to reply, forward, draft, folder, category, and calendar operations. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/outlook-setup.sh:187
Finding
OAuth Authorization Response Is Not Correlated or Validated<![CDATA[ ## Vulnerability Details **File Location**: `scripts/outlook-setup.sh:187-201` **Vulnerability Type**: Missing OAuth state validation and weak callback handling **Risk Level**: Medium The corresponding manual flow is also documented in `references/setup.md:75-92`. ### Vulnerable Code ```bash AUTH_TENANT="${TENANT_ID:-common}" AUTH_URL="https://login.microsoftonline.com/$AUTH_TENANT/oauth2/v2.0/authorize?client_id=$CLIENT_ID&response_type=code&redirect_uri=$REDIRECT_URI&scope=$(echo $SCOPES | sed 's/ /%20/g')&response_mode=query" echo "Open this URL in your browser:" echo "" echo -e "${BLUE}$AUTH_URL${NC}" echo "" echo "After authorizing, you'll be redirected to a page that won't load." echo "Copy the FULL URL from the address bar and paste it here:" echo "" read -p "URL: " REDIRECT_URL # Extract code from URL AUTH_CODE=$(echo "$REDIRECT_URL" | grep -oP 'code=\K[^&]+' || echo "") if [ -z "$AUTH_CODE" ]; then echo -e "${RED}Could not extract authorization code from URL${NC}" exit 1 fi ``` ### Technical Analysis The authorization request does not include a cryptographically random `state` parameter, and the setup script therefore cannot correlate the pasted response with the authorization request it initiated. It extracts any `code` query parameter from arbitrary pasted text without validating: - The callback scheme and host. - The configured redirect URI. - A request-specific state value. - The tenant or authorization context. - Whether the code belongs to the expected browser transaction. The flow also uses Authorization Code without PKCE and relies on the user manually copying a loopback HTTP redirect URL rather than using a controlled callback listener. The client secret still protects the token exchange, but it does not replace response correlation or callback validation. ### Attack Path 1. The victim begins setup and reaches the manual authorization-response step. 2. Through social engineering or response confusion, the victim ...[truncated 1012 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Generate a cryptographically random `state` value for every authorization attempt. - Include the state in the authorization URL and require an exact match in the callback. - Use Authorization Code with PKCE, generating a fresh verifier and SHA-256 challenge for each flow. - Validate that the callback scheme, host, port, path, and parameters exactly match the registered redirect URI. - Prefer a standards-compliant loopback listener bound to the local interface rather than asking the user to paste an arbitrary URL. - Alternatively, use Microsoft's supported device-code flow where appropriate. - URL-encode all OAuth parameters with a proper encoder rather than using `sed`. - Avoid logging authorization codes, access tokens, refresh tokens, or complete callback URLs. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (72)

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
The skill includes explicit token and credential lifecycle operations, including printing the raw access token and storing client secrets and refresh tokens locally, which are not reflected in the high-level description. This concealment materially changes the trust boundary: a user expecting mail/calendar management may unknowingly grant a skill that can expose reusable credentials and facilitate account compromise.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill includes explicit token and credential lifecycle operations, including printing the raw access token and storing client secrets and refresh tokens locally, which are not reflected in the high-level description. This concealment materially changes the trust boundary: a user expecting mail/calendar management may unknowingly grant a skill that can expose reusable credentials and facilitate account compromise.

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
The skill includes explicit token and credential lifecycle operations, including printing the raw access token and storing client secrets and refresh tokens locally, which are not reflected in the high-level description. This concealment materially changes the trust boundary: a user expecting mail/calendar management may unknowingly grant a skill that can expose reusable credentials and facilitate account compromise.

Credential Access

High
Category
Privilege Escalation
Content
```bash
./scripts/outlook-token.sh refresh  # Refresh expired token
./scripts/outlook-token.sh test     # Test connection
./scripts/outlook-token.sh get      # Print access token
```

### Reading Emails
Confidence
98% confidence
Finding
A command that prints the raw access token directly creates a straightforward credential disclosure path. Anyone able to invoke or observe this command can reuse the bearer token to access the victim's mailbox and calendar with the granted Microsoft Graph scopes until expiry, and potentially chain that with refresh-token access for longer compromise.

Credential Access

High
Category
Privilege Escalation
Content
## Files

- `~/.outlook-mcp/config.json` - Tenant ID, client ID, and client secret
- `~/.outlook-mcp/credentials.json` - OAuth tokens (access + refresh)

## Permissions
Confidence
94% confidence
Finding
The documentation states that client secrets, access tokens, and refresh tokens are stored in local files under the user's home directory. Local file storage of reusable credentials is dangerous because any other process, user, backup system, or agent with filesystem access could exfiltrate them and gain persistent access to the user's Microsoft account.

Credential Access

High
Category
Privilege Escalation
Content
curl -s -X POST "https://login.microsoftonline.com/$TENANT_ID/oauth2/v2.0/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "client_id=$CLIENT_ID&client_secret=$CLIENT_SECRET&code=$AUTH_CODE&redirect_uri=http://localhost&grant_type=authorization_code&scope=https://graph.microsoft.com/Mail.ReadWrite https://graph.microsoft.com/Mail.Send https://graph.microsoft.com/Calendars.ReadWrite offline_access" \
  > ~/.outlook-mcp/credentials.json

chmod 600 ~/.outlook-mcp/credentials.json
```
Confidence
96% confidence
Finding
The guide causes OAuth tokens to be saved to credentials.json on disk, creating a credential-access target for local attackers, malware, or accidental disclosure. Because the stored data likely includes a refresh token, compromise can provide sustained access to mail and calendar beyond a single session.

Credential Access

High
Category
Privilege Escalation
Content
-d "client_id=$CLIENT_ID&client_secret=$CLIENT_SECRET&code=$AUTH_CODE&redirect_uri=http://localhost&grant_type=authorization_code&scope=https://graph.microsoft.com/Mail.ReadWrite https://graph.microsoft.com/Mail.Send https://graph.microsoft.com/Calendars.ReadWrite offline_access" \
  > ~/.outlook-mcp/credentials.json

chmod 600 ~/.outlook-mcp/credentials.json
```

## Step 7: Verify Setup
Confidence
95% confidence
Finding
The credentials.json file is explicitly retained after token acquisition, which preserves bearer credentials on disk for later reuse. In the context of an email/calendar integration, theft of this file can expose sensitive communications, attachments, and scheduling data.

Credential Access

High
Category
Privilege Escalation
Content
- Make sure you click "Accept" on the consent screen

### "Token expired"
- Access tokens last ~1 hour
- Run `./scripts/outlook-token.sh refresh` to get a new one

### Work/School Account Issues
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
- Make sure you click "Accept" on the consent screen

### "Token expired"
- Access tokens last ~1 hour
- Run `./scripts/outlook-token.sh refresh` to get a new one

### Work/School Account Issues
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
- Make sure you click "Accept" on the consent screen

### "Token expired"
- Access tokens last ~1 hour
- Run `./scripts/outlook-token.sh refresh` to get a new one

### Work/School Account Issues
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
# Usage: outlook-calendar.sh <command> [args]

CONFIG_DIR="$HOME/.outlook-mcp"
CREDS_FILE="$CONFIG_DIR/credentials.json"

# Load token
ACCESS_TOKEN=$(jq -r '.access_token' "$CREDS_FILE" 2>/dev/null)
Confidence
81% confidence
Finding
The script relies on a bearer token stored in a predictable local file path under the user's home directory. If file permissions are weak, the host is multi-user, or another process can read that location, the token could be stolen and used to access or modify the victim's Outlook data through Microsoft Graph.

Credential Access

High
Category
Privilege Escalation
Content
# Usage: outlook-mail.sh <command> [args]

CONFIG_DIR="$HOME/.outlook-mcp"
CREDS_FILE="$CONFIG_DIR/credentials.json"

# Load token
ACCESS_TOKEN=$(jq -r '.access_token' "$CREDS_FILE" 2>/dev/null)
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
# Usage: outlook-mail.sh <command> [args]

CONFIG_DIR="$HOME/.outlook-mcp"
CREDS_FILE="$CONFIG_DIR/credentials.json"

# Load token
ACCESS_TOKEN=$(jq -r '.access_token' "$CREDS_FILE" 2>/dev/null)
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
# Usage: outlook-mail.sh <command> [args]

CONFIG_DIR="$HOME/.outlook-mcp"
CREDS_FILE="$CONFIG_DIR/credentials.json"

# Load token
ACCESS_TOKEN=$(jq -r '.access_token' "$CREDS_FILE" 2>/dev/null)
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
ACCESS_TOKEN=$(jq -r '.access_token' "$CREDS_FILE" 2>/dev/null)

if [ -z "$ACCESS_TOKEN" ] || [ "$ACCESS_TOKEN" = "null" ]; then
    echo "Error: No access token. Run setup first."
    exit 1
fi
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
ACCESS_TOKEN=$(jq -r '.access_token' "$CREDS_FILE" 2>/dev/null)

if [ -z "$ACCESS_TOKEN" ] || [ "$ACCESS_TOKEN" = "null" ]; then
    echo "Error: No access token. Run setup first."
    exit 1
fi
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
ACCESS_TOKEN=$(jq -r '.access_token' "$CREDS_FILE" 2>/dev/null)

if [ -z "$ACCESS_TOKEN" ] || [ "$ACCESS_TOKEN" = "null" ]; then
    echo "Error: No access token. Run setup first."
    exit 1
fi
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
CONFIG_DIR="$HOME/.outlook-mcp"
CONFIG_FILE="$CONFIG_DIR/config.json"
CREDS_FILE="$CONFIG_DIR/credentials.json"

APP_NAME="Clawdbot-Outlook"
REDIRECT_URI="http://localhost"
Confidence
96% confidence
Finding
The script is explicitly designed to create and persist credentials.json containing OAuth tokens for Outlook access. Because those tokens may allow reading mail, sending mail, and accessing calendars—and refresh tokens may preserve access over time—the file becomes a high-value local secret whose theft could directly compromise the user's Microsoft account data.

External Script Fetching

High
Category
Supply Chain
Content
check_prereqs() {
    if ! command -v az &> /dev/null; then
        echo -e "${RED}Error: Azure CLI not installed${NC}"
        echo "Install with: curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash"
        exit 1
    fi
Confidence
98% confidence
Finding
The command shown fetches a script over the network and immediately executes it with root privileges. In a setup script for an Outlook integration, this is unrelated to core mail/calendar functionality and introduces a serious supply-chain and arbitrary code execution risk on the host system.

Chaining Abuse

High
Category
Tool Misuse
Content
check_prereqs() {
    if ! command -v az &> /dev/null; then
        echo -e "${RED}Error: Azure CLI not installed${NC}"
        echo "Install with: curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash"
        exit 1
    fi
Confidence
97% confidence
Finding
Chaining a remote download directly into sudo bash combines untrusted network input with immediate privileged execution, which is a classic unsafe command pattern. If the downloaded content is altered or malicious, the user could grant full system compromise during what appears to be a routine prerequisite step.

Credential Access

High
Category
Privilege Escalation
Content
*)
        echo "Usage: outlook-token.sh [refresh|get|test]"
        echo "  refresh - Refresh the access token"
        echo "  get     - Print current access token"
        echo "  test    - Test the connection"
        ;;
esac
Confidence
97% confidence
Finding
The help text explicitly advertises a command that prints the current access token, reinforcing an insecure interface for exposing bearer credentials. In this skill's context, the token grants direct Microsoft Graph access to email and calendar functions, so disclosure can enable mailbox reading, message sending, and calendar manipulation.

Lp3

Medium
Category
MCP Least Privilege
Confidence
90% confidence
Finding
The skill exposes shell-based capabilities but does not declare any explicit tool scope or allowed-tools restrictions. In a skill that can read, send, delete mail and manage OAuth material, missing scope boundaries increases the chance the agent invokes shell commands more broadly than intended, enabling abuse or accidental execution paths.

Vague Triggers

Medium
Confidence
92% confidence
Finding
The activation text is broad enough to match many common email or scheduling requests, which can cause over-triggering of a powerful skill. Because this skill includes read/write mail, send, delete, token, and calendar actions, broad routing raises the risk of invoking sensitive capabilities in contexts where the user did not intend to authorize them.

Session Persistence

Medium
Category
Rogue Agent
Content
The setup script will:
1. Log you into Azure (device code flow)
2. Create an App Registration automatically
3. Configure API permissions (Mail.ReadWrite, Mail.Send, Calendars.ReadWrite)
4. Guide you through authorization
5. Save credentials (including tenant context) to `~/.outlook-mcp/`
Confidence
88% confidence
Finding
The setup process creates an app registration, grants broad mail/calendar permissions, and persists tenant context and credentials for future reuse. That persistence increases the blast radius of compromise because a one-time authorization can become long-lived delegated access, especially when paired with locally stored refresh tokens and client secrets.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
- Microsoft account (Outlook.com, Hotmail, Live, or Microsoft 365)
- Access to [Azure Portal](https://portal.azure.com)
- `jq` installed (`sudo apt install jq`)

## Step 1: Create Azure App Registration
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Static analysis

No suspicious patterns detected.