1. Resources
  2. Detection rules
  3. App Service Publishing Credentials and Function Keys Retrieved

App Service Publishing Credentials and Function Keys Retrieved detection rules

Someone retrieves the publishing profile, the app settings or the function keys of an Azure web app or function app through Resource Manager. They open the app's deployment endpoints and code without a Microsoft Entra sign-in.

Platform
Azure
Severity
High
Log source
Azure Activity log
Last updated
MITRE ATT&CK technique
T1552Unsecured Credentials
Rule formats
Sigmaand queries for: SplunkMicrosoft SentinelIBM QRadar
What an attacker needs
Contributor-level rights on the app, such as Contributor or Website Contributor, and for use of the publishing credentials an app that allows basic authentication.
Impact
Deployment access to the app's code, settings and connection strings, and through code in the app the permissions of its managed identity.
Response
Reset the app-scope publishing credentials and renew the function keys, disable basic authentication on the apps, and contain the caller.
Mitigation
Disable basic authentication for FTP and SCM on every app, deploy with Microsoft Entra authentication, and keep each app's managed identity least privileged.
Operations
MICROSOFT.WEB/SITES/CONFIG/LIST/ACTIONMICROSOFT.WEB/SITES/SLOTS/CONFIG/LIST/ACTIONMICROSOFT.WEB/SITES/BASICPUBLISHINGCREDENTIALSPOLICIES/WRITEMICROSOFT.WEB/SITES/SLOTS/BASICPUBLISHINGCREDENTIALSPOLICIES/WRITEMICROSOFT.WEB/SITES/HOST/LISTKEYS/ACTIONMICROSOFT.WEB/SITES/FUNCTIONS/LISTKEYS/ACTIONMICROSOFT.WEB/SITES/FUNCTIONS/LISTSECRETS/ACTIONMICROSOFT.WEB/SITES/SLOTS/HOST/LISTKEYS/ACTIONMICROSOFT.WEB/SITES/SLOTS/FUNCTIONS/LISTKEYS/ACTIONMICROSOFT.WEB/SITES/SLOTS/FUNCTIONS/LISTSECRETS/ACTIONMICROSOFT.WEB/SITES/PUBLISHXML/ACTIONMICROSOFT.WEB/SITES/SLOTS/PUBLISHXML/ACTION

How the attack works

Every Azure App Service app and function app has app-scope deployment credentials that are generated when the app is created. Microsoft.Web/sites/publishxml/Action returns them in the publishing profile, and Microsoft.Web/sites/config/list/Action lists what Microsoft calls the app's security sensitive settings: publishing credentials, app settings and connection strings. While basic authentication is allowed on the app, the credentials are accepted by FTP, Web Deploy and the SCM (Kudu) site at https://<app-name>.scm.azurewebsites.net, where Microsoft documents that commands can be run in the Kudu console. Function apps add access keys. microsoft.web/sites/host/listkeys/action returns the host keys, and Microsoft describes the master key among them as an administrative credential.

An attacker with Contributor-level rights on an app uses these operations to turn control-plane access into credentials that work without any further Microsoft Entra sign-in. Microsoft's report on Storm-2949 describes an actor that invoked publishxml/action to obtain the publishing profiles of web apps and compromised several apps this way. Code that runs in the app can request tokens for the app's managed identity from its local identity endpoint, so control of the app is also control of that identity. Basic authentication is disabled by default for new apps, which is why an attacker may first switch it back on with Microsoft.Web/sites/basicPublishingCredentialsPolicies/Write. All of these are Azure Resource Manager operations recorded in the Activity log with their caller. What is done with the credentials afterwards is not in the Activity log.

What an attacker needs

  • Contributor-level permissions on the app: Owner, Contributor, Website Contributor or a custom role with Microsoft.Web/sites/publishxml/Action or Microsoft.Web/sites/config/list/Action. Microsoft states that the Reader role cannot access the deployment credentials.
  • For the credentials to be accepted: basic authentication allowed for FTP or SCM on the app, or the right to write basicPublishingCredentialsPolicies and switch it on.
  • For function keys: a role with microsoft.web/sites/host/listkeys/action or the function-level key and secret listing actions. The Logic App Contributor role includes Microsoft.Web/sites/functions/listSecrets/action.

Impact

Deployment access to the app: its files and code can be read and replaced, its app settings and connection strings can be read, and commands can be run in the Kudu console. Code placed in the app runs with the app's managed identity and reaches whatever that identity's roles allow. A host key lets the holder call every HTTP-triggered function of a function app, and the master key gives administrative access to the runtime REST APIs. None of this depends on the attacker's Azure identity: the access lasts until the publishing credentials are reset and the keys are renewed.

Detection rules

Azure App Service Security Sensitive Settings Listed

Detects a successful Microsoft.Web/sites/config/list/Action on an Azure App Service app, a function app or a deployment slot. Microsoft describes the operation as listing the app's security sensitive settings, such as publishing credentials, app settings and connection strings. The Activity log event does not say which of them was listed, and every read of app settings or connection strings through Resource Manager is this operation, so the rule matches routine administration and deployments. Use it to build a baseline of callers for each app and for correlation with the other rules on this page, not as an alert on its own.

LevelLowStatusExperimentalLog sourceAzure Activity log
title: Azure App Service Security Sensitive Settings Listed
id: b4eccc62-83d8-48d0-a77e-0f525918ff93
status: experimental
description: >-
  Detects a successful Microsoft.Web/sites/config/list/Action on an Azure App
  Service app, a function app or a deployment slot. Microsoft describes the
  operation as listing the app's security sensitive settings, such as
  publishing credentials, app settings and connection strings. The Activity
  log event does not say which of them was listed, and every read of app
  settings or connection strings through Resource Manager is this operation,
  so the rule matches routine administration and deployments. Use it to build
  a baseline of callers for each app and for correlation with the other rules
  on this page, not as an alert on its own.
references:
  - https://attack.mitre.org/techniques/T1552/
  - https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/web-and-mobile
  - https://learn.microsoft.com/en-us/azure/app-service/deploy-configure-credentials
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1552
logsource:
  product: azure
  service: activitylogs
detection:
  selection:
    OperationNameValue:
      - MICROSOFT.WEB/SITES/CONFIG/LIST/ACTION
      - MICROSOFT.WEB/SITES/SLOTS/CONFIG/LIST/ACTION
    ActivityStatusValue:
      - Success
      - Succeeded
  condition: selection
falsepositives:
  - Administrators, deployment pipelines and infrastructure-as-code tools that read app settings, connection strings or publishing credentials. Exclude their identities in a filter_ selection by Caller once confirmed.
level: low

False positives

  • Administrators, deployment pipelines and infrastructure-as-code tools that read app settings, connection strings or publishing credentials. Exclude their identities in a filter_ selection by Caller once confirmed.

Azure App Service Basic Publishing Authentication Policy Changed

Detects a successful write to the basic publishing credentials policy of an Azure App Service app, a function app or a deployment slot (Microsoft.Web/sites/basicPublishingCredentialsPolicies/Write). The policy decides whether user name and password deployment credentials are accepted for FTP and for the SCM site. Basic authentication is disabled by default for new apps, and switching it on makes retrieved publishing credentials usable. The Activity log event does not say whether the policy was switched on or off, so read the current value of the ftp and scm policies of the app. Microsoft documents a custom role that excludes this operation for users who should not be able to enable basic authentication.

LevelMediumStatusExperimentalLog sourceAzure Activity log
title: Azure App Service Basic Publishing Authentication Policy Changed
id: 25e440ba-39bc-44ae-82df-457aec6cd5cc
status: experimental
description: >-
  Detects a successful write to the basic publishing credentials policy of an
  Azure App Service app, a function app or a deployment slot
  (Microsoft.Web/sites/basicPublishingCredentialsPolicies/Write). The policy
  decides whether user name and password deployment credentials are accepted
  for FTP and for the SCM site. Basic authentication is disabled by default
  for new apps, and switching it on makes retrieved publishing credentials
  usable. The Activity log event does not say whether the policy was switched
  on or off, so read the current value of the ftp and scm policies of the
  app. Microsoft documents a custom role that excludes this operation for
  users who should not be able to enable basic authentication.
references:
  - https://attack.mitre.org/techniques/T1552/
  - https://learn.microsoft.com/en-us/azure/app-service/configure-basic-auth-disable
  - https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/web-and-mobile
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1552
logsource:
  product: azure
  service: activitylogs
detection:
  selection:
    OperationNameValue:
      - MICROSOFT.WEB/SITES/BASICPUBLISHINGCREDENTIALSPOLICIES/WRITE
      - MICROSOFT.WEB/SITES/SLOTS/BASICPUBLISHINGCREDENTIALSPOLICIES/WRITE
    ActivityStatusValue:
      - Success
      - Succeeded
  condition: selection
falsepositives:
  - Hardening work that switches basic authentication off, by administrators or by an Azure Policy remediation. The event looks the same as switching it on.
  - Templates and pipelines that set the policy on every deployment. Exclude their deployment identities in a filter_ selection by Caller once confirmed.
level: medium

False positives

  • Hardening work that switches basic authentication off, by administrators or by an Azure Policy remediation. The event looks the same as switching it on.
  • Templates and pipelines that set the policy on every deployment. Exclude their deployment identities in a filter_ selection by Caller once confirmed.

Azure Function App Access Keys Listed

Detects a successful listing of the host keys of an Azure function app, or of the keys or secrets of one function, through Resource Manager, including deployment slots. A host key authorizes calls to any HTTP-triggered function in the app, and Microsoft describes the master key among the host keys as an administrative credential for the runtime REST APIs. The keys work without a Microsoft Entra sign-in until they are renewed. Tools and administrators that need a function URL with its key make the same calls, so baseline the callers for each function app.

LevelLowStatusExperimentalLog sourceAzure Activity log
title: Azure Function App Access Keys Listed
id: 4d94481d-d9a0-4e2f-a929-e97b06384895
status: experimental
description: >-
  Detects a successful listing of the host keys of an Azure function app, or
  of the keys or secrets of one function, through Resource Manager, including
  deployment slots. A host key authorizes calls to any HTTP-triggered function
  in the app, and Microsoft describes the master key among the host keys as an
  administrative credential for the runtime REST APIs. The keys work without a
  Microsoft Entra sign-in until they are renewed. Tools and administrators
  that need a function URL with its key make the same calls, so baseline the
  callers for each function app.
references:
  - https://attack.mitre.org/techniques/T1552/
  - https://learn.microsoft.com/en-us/azure/azure-functions/function-keys-how-to
  - https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/web-and-mobile
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1552
logsource:
  product: azure
  service: activitylogs
detection:
  selection:
    OperationNameValue:
      - MICROSOFT.WEB/SITES/HOST/LISTKEYS/ACTION
      - MICROSOFT.WEB/SITES/FUNCTIONS/LISTKEYS/ACTION
      - MICROSOFT.WEB/SITES/FUNCTIONS/LISTSECRETS/ACTION
      - MICROSOFT.WEB/SITES/SLOTS/HOST/LISTKEYS/ACTION
      - MICROSOFT.WEB/SITES/SLOTS/FUNCTIONS/LISTKEYS/ACTION
      - MICROSOFT.WEB/SITES/SLOTS/FUNCTIONS/LISTSECRETS/ACTION
    ActivityStatusValue:
      - Success
      - Succeeded
  condition: selection
falsepositives:
  - Developers, integration tools and deployment pipelines that read a function key to call or to wire up a function. Exclude their identities in a filter_ selection by Caller once confirmed.
level: low

False positives

  • Developers, integration tools and deployment pipelines that read a function key to call or to wire up a function. Exclude their identities in a filter_ selection by Caller once confirmed.

Azure App Service Publishing Profile Retrieved

Detects a successful retrieval of the publishing profile of an Azure App Service app, a function app or one of its deployment slots (Microsoft.Web/sites/publishxml/Action). The profile contains the app-scope deployment credentials for the app's deployment endpoints. Microsoft's report on Storm-2949 names this operation as the way the actor obtained deployment credentials for web apps. Developers and pipelines that deploy with a publishing profile download it as well, so baseline the callers for each app. The credentials can be used for publishing only while basic authentication is allowed on the app.

LevelMediumStatusExperimentalLog sourceAzure Activity log
title: Azure App Service Publishing Profile Retrieved
id: 38a3c64a-075a-4a9e-a6b6-e08028b59d7a
status: experimental
description: >-
  Detects a successful retrieval of the publishing profile of an Azure App
  Service app, a function app or one of its deployment slots
  (Microsoft.Web/sites/publishxml/Action). The profile contains the app-scope
  deployment credentials for the app's deployment endpoints. Microsoft's
  report on Storm-2949 names this operation as the way the actor obtained
  deployment credentials for web apps. Developers and pipelines that deploy
  with a publishing profile download it as well, so baseline the callers for
  each app. The credentials can be used for publishing only while basic
  authentication is allowed on the app.
references:
  - https://attack.mitre.org/techniques/T1552/
  - https://learn.microsoft.com/en-us/azure/app-service/deploy-configure-credentials
  - https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/web-and-mobile
  - https://www.microsoft.com/en-us/security/blog/2026/05/18/storm-2949-turned-compromised-identity-into-cloud-wide-breach/
author: Forestall
date: 2026-11-18
tags:
  - attack.credential-access
  - attack.t1552
logsource:
  product: azure
  service: activitylogs
detection:
  selection:
    OperationNameValue:
      - MICROSOFT.WEB/SITES/PUBLISHXML/ACTION
      - MICROSOFT.WEB/SITES/SLOTS/PUBLISHXML/ACTION
    ActivityStatusValue:
      - Success
      - Succeeded
  condition: selection
falsepositives:
  - Developers who download the publishing profile for a deployment tool, and the setup of pipelines that deploy with it. Exclude the identities that do this routinely in a filter_ selection by Caller, per app where possible.
level: medium

False positives

  • Developers who download the publishing profile for a deployment tool, and the setup of pipelines that deploy with it. Exclude the identities that do this routinely in a filter_ selection by Caller, per app where possible.

Detection logic

Patterns that need more than one event, a baseline or knowledge of your own environment. Each is a hypothesis to build and tune in your SIEM, not a ready rule.

Publishing credentials retrieved, then a publishing logon from a new client address

Detection hypothesisJoins two logsNeeds a baseline

The Activity log shows who retrieved the publishing credentials of an app, and the app's audit log shows from where somebody logged on with publishing credentials. A retrieval followed by a logon from an address that never published to the app before is the use of stolen deployment credentials.

  1. In the Azure Activity log, find a successful MICROSOFT.WEB/SITES/PUBLISHXML/ACTION or MICROSOFT.WEB/SITES/CONFIG/LIST/ACTION (or the slot operations). Keep the Caller, the CallerIpAddress and the app from the resource ID.
  2. In the AppServiceAuditLogs of the same app, take the records after that time and read User, UserAddress and Protocol.
  3. Compare UserAddress with the addresses that logged on to this app in the 30 days before, and with the CallerIpAddress of the retrieval. Review a logon from an address that is new for the app.

EventsMICROSOFT.WEB/SITES/PUBLISHXML/ACTIONMICROSOFT.WEB/SITES/CONFIG/LIST/ACTION

LimitsIt needs a diagnostic setting for the AppServiceAuditLogs category on the app. Deployments that authenticate with Microsoft Entra ID are not publishing logons and are not in that log. A developer on a new network looks the same. The 30 days are a starting point.

Basic authentication policy written and the publishing profile retrieved by the same caller

Detection hypothesisSequence of events

Basic authentication is off by default for new apps, so stolen publishing credentials are useless there until somebody switches it on. A write to the basic publishing credentials policy followed by a retrieval of the publishing profile of the same app by the same caller is that preparation and collection in order.

  1. In the Azure Activity log, the policy of an app is written with status Success: MICROSOFT.WEB/SITES/BASICPUBLISHINGCREDENTIALSPOLICIES/WRITE or the slot operation. Keep the Caller and the app from the resource ID.
  2. Within 60 minutes the same Caller runs MICROSOFT.WEB/SITES/PUBLISHXML/ACTION or MICROSOFT.WEB/SITES/CONFIG/LIST/ACTION on the same app.
  3. Read the current ftp and scm policy values of the app. If basic authentication is now allowed, treat the publishing credentials as usable by the caller.

EventsMICROSOFT.WEB/SITES/BASICPUBLISHINGCREDENTIALSPOLICIES/WRITEMICROSOFT.WEB/SITES/PUBLISHXML/ACTION

LimitsA developer who sets up FTP or local Git deployment on purpose performs the same two steps, so match the result with change records. The write event does not say whether the policy was switched on or off. The 60 minutes are a starting point.

Triage

  • Identify the Caller, the caller's IP address and the app from the event, and whether this identity deploys or administers this app routinely. Developers and pipelines that publish with a profile download it as well.
  • Check whether basic authentication is allowed for FTP and SCM on the app. While both are off, the retrieved credentials cannot be used for publishing, but the app settings and connection strings that were listed are still exposed.
  • Look for a write to basicPublishingCredentialsPolicies on the same app around that time, and read the current policy values, because the event does not say whether basic authentication was switched on or off.
  • If AppServiceAuditLogs are collected, look for publishing logons after the retrieval and compare UserAddress and Protocol with what is normal for the app.
  • Find out which managed identity the app has and what its roles reach, and what the app settings and connection strings contain.
  • Check the Activity log for the same operations by this caller on other apps and function apps.

Response

Once the attack is confirmed:

  1. Reset the app-scope publishing credentials of every app whose profile or settings the caller retrieved, and renew the host keys and function keys of the function apps. Integrations that use the old values stop working and have to be reconfigured.
  2. Disable basic authentication for FTP and SCM on those apps, so that publishing credentials are no longer accepted at all.
  3. Contain the caller. Revoke its sessions, rotate its credentials and remove its role on the apps until the retrieval is explained.
  4. Treat the content of the app as untrusted. Redeploy it from a trusted build and remove files and jobs that are not part of that build.
  5. Rotate the secrets that were in the app settings and connection strings, such as database passwords, storage keys and API keys.
  6. Review the activity of the app's managed identity since the retrieval and reduce its role assignments until that review is done.

Mitigation

  • Disable basic authentication for FTP and for SCM on every app, and deploy with Microsoft Entra authentication or managed identities instead. Microsoft provides built-in Azure Policy definitions that audit and remediate apps and slots that still allow basic authentication.
  • Give operators a custom role that excludes Microsoft.Web/sites/basicPublishingCredentialsPolicies/Write and the slot equivalent, as Microsoft documents, so that they cannot switch basic authentication back on.
  • Limit Owner, Contributor and Website Contributor on apps, scope them to single apps and assign them through Privileged Identity Management.
  • Keep the managed identity of each app least privileged, so that control of an app does not become control of a subscription.
  • Create a diagnostic setting that collects the AppServiceAuditLogs category, which records logons through the publishing protocols with the user and the client address.
  • On function apps that do not need them, disable the administrative endpoints with the functionsRuntimeAdminIsolationEnabled site property, and share host keys only where a function key is not enough.

Frequently asked questions

Does the Activity log show whether the publishing credentials were used?

No. The Activity log records the control-plane call that returned the publishing profile, the settings or the keys, with its caller. A logon to FTP, Web Deploy or the SCM site with those credentials goes to the app's own endpoints. It is recorded in the AppServiceAuditLogs resource log category, with the user, the client address and the protocol, and only when a diagnostic setting collects that category.

Is a retrieved publishing profile dangerous when basic authentication is disabled on the app?

Less so. Microsoft documents that the deployment credentials cannot be used for publishing while basic authentication is disabled, and it is disabled by default for new apps. Two things remain. The same caller may be able to switch basic authentication back on, which is its own rule on this page, and the listing of app settings and connection strings exposes the secrets stored there regardless of basic authentication.

Why do the four rules have different levels?

The rules on the publishing profile and on the basic authentication policy are medium, because both operations are infrequent and directly tied to deployment credentials. The rules on listing the app's security sensitive settings and on listing function keys are low, because routine administration and deployments make the same calls and the event does not say what was read. Use the low rules for baselines and correlation.

Does disabling the attacker's account end the access gained with the credentials?

No. Publishing credentials and function keys are not tied to the Azure identity that retrieved them. They keep working until the app-scope credentials are reset and the keys are renewed. Resetting the credentials breaks integrations that still use the old publishing profile, so plan to reconfigure those.

References

We respect your privacy

We use cookies to keep this site secure and working properly. With your permission, we also use optional cookies to understand usage and improve the experience. Cookie Policy

You can change your choice at any time.