Outsourced ProgrammersPowered by StealthAgents

Set a mobile signing key custody note for outsourced app builds

A custody note that keeps signing keys with the client, records every build that uses one, and stages a rotation before a key is lost or leaked.

Set a mobile signing key custody note for outsourced app builds
WORK_LANE / FIELD GUIDE / MOBILEREVIEW QUEUEACCEPTANCEPASSowner review requiredEVIDENCE TRAILTICKET → BRANCH → REVIEW → CLIENT RELEASE
Table of contents
  1. Quick read
  2. Readiness check
  3. List the keys and what each one signs
  4. Keep the keystore with the client
  5. Record every build that uses a key
  6. Rotate a key with a staged release
  7. Respond to a lost or leaked key
  8. Review custody on a fixed cadence
  9. Role brief
  10. Frequently asked questions
  11. Sources

Is the handoff ready?

Use these checks before access expands or the first ticket begins.

Inventory

Ready: Every key, account, and signed artifact is listed.

Needs work: Keys are known only by the engineer who created them.

Custody

Ready: The client controls the keystore and the recovery copy.

Needs work: A keystore file sits in a personal folder.

Build log

Ready: Each signed build names the key, version, and operator.

Needs work: Store submissions have no matching build record.

Rotation

Ready: The rotation path is tested on an internal track.

Needs work: No key has been rotated since launch.

List the keys and what each one signs

A signing key custody note starts with every key that authenticates a build or an update. Include the Android upload key, the app signing key held by the store, the iOS distribution certificate, and any enterprise or internal distribution key. Record the platform, the account, and the artifact each key signs. Do not assume that one key covers one app.

Note which keys are managed by the client and which, if any, were created by the contractor. Mark any key that exists only in a personal account or a local keystore file. Those are the keys that disappear when a laptop is replaced. The list should be short enough to review each quarter.

Keep the keystore with the client

Store the keystore, the certificate, and the password in the client secret manager or a hardware token. Give the offshore team a build identity that can use the key without exporting it. Do not send a keystore file through chat or attach it to a ticket. A key that travels as an attachment is already exposed.

Separate the permission to build from the permission to change the key. The build identity should sign and publish to the internal track, while the client owner approves a production release. Record who holds the recovery material and where the second copy lives. A single copy in one person's possession is a continuity risk.

Record every build that uses a key

Log the key identifier, the app version, the commit, the build number, and the operator for every signed artifact. Store the log where the client can read it without asking the contractor. Link the record to the release ticket and the store submission. The log should answer which build used which key without opening the store console.

Compare the build log with the store submissions each month. Investigate a submission that has no matching build record. Record the investigation and its outcome. A gap in the log is a finding even when the build looks correct.

Rotate a key with a staged release

Plan a rotation as a release with its own ticket and rollback note. Confirm that the store accepts the new key and that the old key still verifies existing installs. Test the update path on an internal track before the production rollout. A rotation that skips the update path can strand users on a version that cannot upgrade.

Record the rotation date, the new key fingerprint, and the person who approved it. Keep the old key available for verification until the store and the install base have moved. Do not delete the old key on the same day as the rotation. The retention period should be written before the rotation starts.

Respond to a lost or leaked key

Treat a lost laptop, a shared keystore, or a public repository leak as a key compromise until proven otherwise. Revoke the build identity, rotate the key, and notify the store and the client contact. Preserve the logs before changing the pipeline. The first hour is about containment, not about explaining how it happened.

Record the timeline, the affected versions, and the recovery steps in one incident note. Decide with the client whether existing installs need a forced update. Add a control that would have caught the exposure earlier. Review the incident with the security owner before closing it.

Review custody on a fixed cadence

Review the key inventory every quarter against the apps that are actually published. Remove keys for retired apps and record why. Confirm that the client still controls the accounts and the recovery material. Check that the build identity still has only the permissions it needs.

Test one recovery path each year by signing an internal build with the backup material. Record the result and the time it took. Update the custody note with any change in personnel or platform. A custody note that is never tested describes an intention, not a control.

Put the operating agreement in writing.

Key inventory

Record the platform, account, key identifier, and the artifact each key signs.

Client custody

Keep the keystore and recovery copy in the client secret store or hardware token.

Build evidence

Log the key, app version, commit, build number, and operator for every signed artifact.

Rotation plan

Stage the new key on an internal track and keep the old key for verification.

Frequently asked questions

Can the offshore team keep a copy of the keystore?

No, give the build pipeline a signing identity that uses the key without exporting it.

How often should a key be rotated?

Set a fixed cadence and rotate immediately after any suspected exposure.

What if a signing key is lost?

Treat it as a compromise, revoke the build identity, and follow the store recovery process.

Sources

  1. OWASP Mobile Application Security

    Mobile key and build security controls.

  2. Android application signing

    Signing key roles and rotation behavior.

  3. NIST SP 800-57 Part 1

    Key management lifecycle guidance.

  4. CISA Secure by Design

    Secret ownership and accountability.

Build a programming lane your technical owner can review.

Bring the stack, backlog, acceptance checks, and release boundaries. We will help scope the role around the work.

Discuss your programming needs