Skip to content
Merged
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
85 changes: 59 additions & 26 deletions .github/workflows/validate-milestone.yml
Original file line number Diff line number Diff line change
@@ -1,58 +1,91 @@
name: validate-milestone

concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true

permissions:
contents: read
pull-requests: read
issues: read

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

[medium/security] Milestone validation data sourced from mutable GitHub issue instead of immutable git content

This PR replaces reading the VERSION file from git (via repos.getContent, pinned to a specific commit SHA) with reading the body of issue #7526. That issue is mutable: any maintainer with issue-edit rights can alter the expected version mapping without leaving a commit-level audit trail.

Impact: The old approach tied the expected milestone to an immutable point in git history. The new approach means that whoever can edit issue #7526 controls what the CI considers the "correct" milestone for every branch. This could cause PRs to pass or fail milestone validation unexpectedly and silently.

Mitigating factors:

  • Only maintainers with write access to docker/cli can edit issues, so the attack surface is limited to trusted collaborators.
  • The check is advisory (milestone labeling), not a security gate for code deployments or releases.
  • The github.repository == 'docker/cli' guard prevents the workflow from running on forks.

Recommendation: Document this trust assumption explicitly in a comment near BRANCH_STATUS_ISSUE. For example:

# TRUST: Issue body is controlled by maintainers; altering it
# changes what CI considers the expected milestone for each branch.

This makes the design decision clear to future readers and reduces surprise if the issue is ever edited unintentionally.

Confidence Score
🟡 moderate 65/100


on:
pull_request:
types: [opened, synchronize, milestoned, demilestoned, edited]
types: [opened, reopened, edited, synchronize, milestoned, demilestoned]

jobs:
validate-milestone:
if: ${{ github.repository == 'docker/cli' && github.event.pull_request.state == 'open' }}
runs-on: ubuntu-26.04
timeout-minutes: 5
steps:
- name: Validate milestone matches VERSION
- name: Validate milestone matches next version
uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
env:
MILESTONE: ${{ github.event.pull_request.milestone.title }}
# Pinned "[Branch status]" issue with a "json docker-versions" block
# mapping each branch to its next and last version.
BRANCH_STATUS_ISSUE: 7526
with:
script: |
const files = await github.paginate(github.rest.pulls.listFiles, {
const issueNumber = Number(process.env.BRANCH_STATUS_ISSUE);
const source = `issue #${issueNumber}`;
const baseBranch = context.payload.pull_request.base.ref;
core.info(`Base branch: ${baseBranch}`);

const {data: issue} = await github.rest.issues.get({
owner: context.repo.owner,
repo: context.repo.repo,
pull_number: context.payload.pull_request.number,
issue_number: issueNumber,
});
core.info(`Modified files: ${files.map(f => f.filename).join(', ')}`);

const touchesVersion = files.some(f => f.filename === 'VERSION');
core.info(`Touches VERSION: ${touchesVersion}`);

// Use the PR's version when it bumps the file, base branch otherwise.
// It's fine to trust the author in this case, it's not meant to be
// a security gate, just a helpful check for maintainers.
const ref = touchesVersion
? context.payload.pull_request.head.sha
: context.payload.pull_request.base.ref;
const lines = (issue.body ?? '').split('\n').map(line => line.trimEnd());
const start = lines.indexOf('```json docker-versions') + 1;
const end = lines.indexOf('```', start);
if (start === 0 || end === -1) {
core.setFailed(`Could not find a 'json docker-versions' block in ${source}`);
return;
}

core.info(`Base ref: ${ref}`);
// For example: {"master": {"next": "29.10.0", "last": "29.9.1"}}
let versions;
try {
versions = JSON.parse(lines.slice(start, end).join('\n'));
} catch (err) {
core.setFailed(`Invalid 'json docker-versions' block in ${source}: ${err.message}`);
return;
}
core.info(`Versions: ${JSON.stringify(versions)}`);

const resp = await github.rest.repos.getContent({
owner: context.repo.owner,
repo: context.repo.repo,
path: 'VERSION',
ref,
});
const expected = Buffer.from(resp.data.content, resp.data.encoding).toString('utf8').trim();
const expected = versions?.[baseBranch]?.next;
if (!expected) {
core.setFailed(`Could not find the next version for branch '${baseBranch}' in ${source}`);
return;
}
const milestone = process.env.MILESTONE;

if (!milestone) {
core.setFailed(`PR must have a milestone set (expected: ${expected})`);
return;
}
if (milestone !== expected) {
core.setFailed(`Milestone '${milestone}' does not match VERSION '${expected}'`);
const guidance =
'This check prevents the PR from being merged accidentally before it is appropriate ' +
'for its milestone. If the milestone is intentional, no action is needed.';
await core.summary
.addHeading('This PR is intentionally blocked from merging for now')
.addTable([
[
{data: 'Milestone', header: true},
{data: 'Expected next version', header: true},
],
[milestone, expected],
])
.addRaw(`The expected version for the '${baseBranch}' branch comes from ${source}.`)
.addEOL()
.addRaw(guidance)
.write();
core.setFailed(
`This PR cannot be merged yet because milestone '${milestone}' does not match ` +
`the next version '${expected}'. ${guidance}`
);
return;
}
core.info(`Milestone: ${milestone} ✓`);
Loading