Partial

RFC 6793 - BGP Support for Four-Octet Autonomous System (AS) Number Space

Every requirement this repository extracted from RFC 6793, the tests bound to it, and what a reader has verified about them. This summary is enrolled and gated by ./le rfc check.

Overview

Positive

what Ze has

Tested both ways93.3%28 of 30 gated MUSTs

a positive test proves Ze does what the requirement demands and a negative one proves it refuses what the requirement forbids

One polarity plus reason3.3%1 of 30 gated MUSTs

the requirement admits no counter-case, so one polarity plus a recorded reason is the whole proof available for it

One polarity, unexcused0.0%0 of 30 gated MUSTs

one direction is tested, the other is neither tested nor excused, and nothing states which

Partial proof; remaining gap0.0%0 of 30 gated MUSTs

scoped tests exist; the remaining obligation is unmet or unproven, with zero whole-requirement credit

Proven by a recorded break57.6%49 of 85 tagged units

a red was observed once under a recorded procedure, and the unit, the claim and the producer it rested on still hash to what was recorded. The break is not re-run. A test pair is not a proof until one has been observed

Neutral

measures that are neither good news nor bad

Gated MUSTs30of 36 this summary declares

MUST-level requirements the gate HOLDS. A population, not a result: the shares beside it are what says how Ze stands

Out of scope0of 30 gated MUSTs

an obligation that does not bind Ze. A {not-applicable} annotation says it never bound; a {feature-declined} annotation says its condition is an optional feature Ze does not offer, and quotes the RFC sentence that makes it optional. Scope, not coverage: it stays in the denominator every share on this page is taken over

Not applicable0.0%0 of 30 gated MUSTs

a {not-applicable} annotation says the obligation does not bind Ze, so no test is owed for it. It stays in the denominator every share here is taken over

Met below Ze0.0%0 of 30 gated MUSTs

a {lower-layer} annotation says a layer under Ze performs the behavior, on state Ze installs into that layer, and names the producer that installs it. The obligation binds Ze and is met; Ze proves none of it, because its own boundary carries no value the behavior reads

Optional feature declined0.0%0 of 30 gated MUSTs

a {feature-declined} annotation says the obligation is conditional on a feature the RFC makes optional and Ze does not offer, and it quotes the sentence that makes it optional. The condition is false, so nothing is owed and nothing is missing. It stays in the denominator every share here is taken over

Negative

what Ze owes

No test at all3.3%1 of 30 gated MUSTs

no test carries the requirement id, whether or not a gap states why

The 8 shares marked as a part above are the whole of the 30 gated MUSTs: they add to 100%. Proven by a recorded break is a share of TAGGED UNITS, a different population, so it is not one of them.

How to read the colors

A color names what the measure MEANS, not how well Ze scores on it. Green is a good outcome at any value, red is a bad one, and neither a population nor a scope count is an outcome, so both take no color. The number under the label is what says how far Ze has got.

Card	Tone here	Why that color
Gated MUSTs	neutral	no color: a population is a scale, and a larger one is neither good news nor bad. It is the accounting total
Out of scope	neutral	no color: an obligation that never bound Ze is neither an achievement nor a failure, and counting it either way would be a claim
Tested both ways	ok	green at every value: a test pair is the outcome this gate exists to produce, and the share under the label is what says how far Ze has got
One polarity plus reason	ok	green at every value: where no counter-case exists, one polarity IS the complete answer, and a recorded reason is what the gate demands beside it
One polarity, unexcused	ok	green at zero, RED above it: half a proof with no reason for the other half
Partial proof; remaining gap	ok	green at zero, RED above it: a tested clause cannot prove the whole requirement
No test at all	bad	green at zero, RED above it: a binding obligation nothing exercises is a claim with nothing behind it, whether or not a reason is stated
Not applicable	neutral	no color: an obligation that never bound Ze is neither an achievement nor a failure, and counting it either way would be a claim
Met below Ze	neutral	no color: an obligation met below Ze is neither a test Ze wrote nor work Ze owes, and the two green shares above are what says how much Ze proves itself
Optional feature declined	neutral	no color: an obligation whose condition Ze never meets is neither an achievement nor a failure. The absent FEATURE is disclosed on the RFC's own status row, as an implementation gap a later scope decision can revisit
Proven by a recorded break	ok	green at every value: an observed break is the outcome the discrimination gate exists to produce. The denominator is TAGGED UNITS, not obligations, so this share is not one of the parts above
Audit verdicts	warn	RED on the first weak, wrong or unimplemented verdict, amber while a verdict is no longer current or a gated MUST is unjudged, green when every one is judged sound and current

At a glance

Field	Value
Public status	Partial
Enrolment	Enrolled
Requirements	36
Gated MUST-level	30
Not applicable, so out of scope	0
Declared gaps	1
Declared gaps a test demonstrates	0
Gated with no test	0
Nightly-only evidence	0
Test tags	85
Tagged units	85
Recorded audit verdicts	27
Discrimination records	49
Summary	`rfc/short/rfc6793.md`
Requirement shard	`rfc/requirements/rfc6793.md`
RFC text	`rfc/full/rfc6793.txt`

Enrolment

Enrolled: BGP Support for Four-Octet AS Number Space

What the public ledger says

Status: Partial

What the ledger says is covered

ASN4 capability advertisement and negotiation, 4-octet AS_PATH/AGGREGATOR between NEW speakers, 2-octet AS_PATH with AS_TRANS toward OLD speakers, AS4_PATH and AS4_AGGREGATOR construction (confederation segments excluded), the whole receive-side procedure of Section 4.2.3 (the AGGREGATOR versus AS4_AGGREGATOR choice, the AS-number-count comparison, the leading-segment prepend and its confederation adjacency rule), the Section 4.1 and Section 6 discard of an AS4_PATH or AS4_AGGREGATOR received from a NEW speaker, AS4_PATH/AS4_AGGREGATOR malformed-attribute validation, AS_TRANS in the OPEN My AS field
tests bound per requirement in rfc/requirements/rfc6793.md.

What the ledger says remains

One MUST-level gap, annotated in rfc/short/rfc6793.md.

Peer identity: RFC6793-4.1-3 -- UnpackOpen never populates Open.ASN4 from the code-65 capability (internal/component/bgp/message/open.go), so the session's OPEN-derived peer AS falls back to the two-octet My AS field (internal/component/bgp/reactor/reactor_dynamic.go).

Coverage

Bucket	Count	What it counts
Positive and negative tests	28	one part of the gated population
Annotated (including scoped evidence)	2	one part of the gated population
One polarity only	0	one part of the gated population
No test and no annotation	0	one part of the gated population
Partial proof; remaining gap (subset of annotated; zero whole-requirement credit)	0	an overlay: each of these is also counted by the part it falls in
Evidence that runs nightly only	0	an overlay: each of these is also counted by the part it falls in
Derived from other rows	0	outside the gated population: each asserts nothing and derives its state from the rows it names, which the parts above already count
Gated MUST-level requirements	30	every gated MUST falls in exactly one bucket above

Positive and negative tests (28): RFC6793-4.1-1, RFC6793-4.1-2, RFC6793-4.1-4, RFC6793-4.1-5, RFC6793-4.1-6, RFC6793-4.1-7, RFC6793-4.2.1-1, RFC6793-4.2.2-1, RFC6793-4.2.2-2, RFC6793-4.2.2-3, RFC6793-4.2.2-4, RFC6793-3-1, RFC6793-4.2.2-5, RFC6793-4.2.2-6, RFC6793-4.2.3-1, RFC6793-4.2.3-3, RFC6793-4.2.3-4, RFC6793-4.2.3-5, RFC6793-4.2.3-6, RFC6793-4.2.3-7, RFC6793-4.2.3-8, RFC6793-4.2.3-9, RFC6793-4.2.3-10, RFC6793-6-1, RFC6793-6-2, RFC6793-6-3, RFC6793-6-4, RFC6793-6-5

Annotated (including scoped evidence) (2): RFC6793-4.1-3, RFC6793-4.2.3-2

Requirements

Requirement	Level	Section	Tests
`RFC6793-4.1-1`	A BGP speaker that supports four-octet AS numbers SHALL advertise this to its peers using BGP Capabilities Advertisements (Section 4.1)
	SHALL	4.1	positive`unit/verifyTestRFC6793OpenAdvertisesFourOctetASCapability` negative`unit/verifyTestRFC6793OpenOmitsCapabilityWhenDisabled`
`RFC6793-4.1-2`	The AS number of the BGP speaker MUST be carried in the Capability Value field of the "support for four-octet AS number capability" (Section 4.1)
	MUST	4.1	positive`unit/verifyTestRFC6793ASN4CapabilityCarriesSpeakerAS` negative`unit/verifyTestRFC6793ASN4CapabilityValueMustBeFourOctets`
`RFC6793-4.1-3`	When a NEW BGP speaker processes an OPEN message from another NEW BGP speaker, it MUST use the AS number encoded in the Capability Value field of the "support for four-octet AS number capability" in lieu of the "My Autonomous System" field of the OPEN message. (Section 4.1)
	MUST	4.1	positive`no test`no positive test negative`no test`no negative test {gap}: UnpackOpen never populates Open.ASN4 from the code-65 capability -- it sets only Version, MyAS, HoldTime and BGPIdentifier (internal/component/bgp/message/open.go:171-180) -- so the reactor's only OPEN-derived peer AS falls back to the two-octet header field: resolveDynamicPeerSettings reads the always-zero open.ASN4 and keeps uint32(open.MyAS), i.e. AS_TRANS for a non-mappable peer (internal/component/bgp/reactor/reactor_dynamic.go:311-316), and negotiateWith passes that same zero as the peer ASN into Negotiate (internal/component/bgp/reactor/session_negotiate.go:27-32). The route-server plugin does read the capability value for its event view (internal/component/bgp/plugins/rs/server.go:647-649), but that is a reporting path, not the session's peer AS
`RFC6793-4.1-4`	A BGP speaker that advertises such a capability to a particular peer, and receives from that peer the advertisement of such a capability, MUST encode AS numbers as four-octet entities in both the AS_PATH attribute and the AGGREGATOR attribute in the updates it sends to the peer (§4.1)
	MUST	4.1	positive`unit/verifyTestRFC6793EncodeFourOctetToNewSpeaker` negative`unit/verifyTestRFC6793EncodeTwoOctetToOldSpeaker`
`RFC6793-4.1-5`	A BGP speaker that advertises such a capability to a particular peer, and receives from that peer the advertisement of such a capability, MUST encode AS numbers as four-octet entities in both the AS_PATH attribute and the AGGREGATOR attribute in the updates it sends to the peer and MUST assume that these attributes in the updates received from the peer encode AS numbers as four-octet entities. (§4.1)
	MUST	4.1	positive`unit/verifyTestRFC6793DecodeFourOctetWhenNegotiated` negative`unit/verifyTestRFC6793DecodeTwoOctetWhenNotNegotiated`
`RFC6793-4.1-6`	The new attributes, AS4_PATH and AS4_AGGREGATOR, MUST NOT be carried in an UPDATE message between NEW BGP speakers. (Section 4.1, Section 6)
	MUST NOT	4.1	positive`unit/verifyTestOriginatedAggregatorOmitsAS4AggregatorTowardNewSpeaker` positive`unit/verifyTestOriginatedUpdateOmitsAS4PathTowardNewSpeaker` positive`functional/verifyrfc6793-no-as4aggregator-from-new-speaker.ci` positive`functional/verifyrfc6793-no-as4path-from-new-speaker.ci` negative`functional/verifyrfc6793-narrow-to-old-speaker.ci`
`RFC6793-4.1-7`	A NEW BGP speaker that receives the AS4_PATH attribute or the AS4_AGGREGATOR attribute in an UPDATE message from another NEW BGP speaker MUST discard the path attribute and continue processing the UPDATE message. (Section 4.1, Section 6)
	MUST	4.1	positive`unit/verifyTestRFC6793NewSpeakerAS4AttributesAreDiscarded` negative`unit/verifyTestRFC6793ReceivedAS4PathAcceptedAlongsideASPath` positive`functional/verifyrfc6793-no-as4path-from-new-speaker.ci`
`RFC6793-4.2.1-1`	However, this document does not assume that an Autonomous System with NEW BGP speakers has to have a globally unique two-octet AS number -- AS_TRANS MUST be used when the NEW BGP speaker does not have a two-octet AS number (even if multiple Autonomous Systems would use it). (Section 4.2.1)
	MUST	4.2.1	positive`unit/verifyTestRFC6793OpenMyASIsASTransWithoutTwoOctetAS` negative`unit/verifyTestRFC6793OpenMyASIsRealASWhenMappable`
`RFC6793-4.2.2-1`	When communicating with an OLD BGP speaker, a NEW BGP speaker MUST send the AS path information in the AS_PATH attribute encoded with two-octet AS numbers. (Section 4.2.2)
	MUST	4.2.2	positive`unit/verifyTestRFC6793EncodeTwoOctetToOldSpeaker` negative`unit/verifyTestRFC6793TwoOctetASPathKeepsMappableASNs`
`RFC6793-4.2.2-2`	The NEW BGP speaker MUST also send the AS path information in the AS4_PATH attribute (encoded with four-octet AS numbers), except for the case where all of the AS path information is composed of mappable four-octet AS numbers only. (Section 4.2.2)
	MUST	4.2.2	positive`unit/verifyTestOriginatedUpdateCarriesAS4PathForANonMappableLocalAS` positive`unit/verifyTestOriginatedUpdateCarriesAS4PathTowardOldSpeaker` positive`unit/verifyTestRFC6793TranscodeEmitsAS4PathForNonMappable` negative`unit/verifyTestOriginatedUpdateOmitsAS4PathWhenEveryASIsMappable` negative`unit/verifyTestRFC6793TranscodeOmitsAS4PathWhenAllMappable`
`RFC6793-4.2.2-3`	In this case, the NEW BGP speaker MUST NOT send the AS4_PATH attribute. (Section 4.2.2)
	MUST NOT	4.2.2	positive`unit/verifyTestOriginatedUpdateOmitsAS4PathWhenEveryASIsMappable` positive`unit/verifyTestRFC6793TranscodeOmitsAS4PathWhenAllMappable` negative`unit/verifyTestOriginatedUpdateCarriesAS4PathTowardOldSpeaker` negative`unit/verifyTestRFC6793TranscodeEmitsAS4PathForNonMappable`
`RFC6793-4.2.2-4`	Whenever the AS path information contains the AS_CONFED_SEQUENCE or AS_CONFED_SET path segment, the NEW BGP speaker MUST exclude such path segments from the AS4_PATH attribute being constructed. (Section 4.2.2)
	MUST	4.2.2	positive`unit/verifyTestRFC6793ConstructedAS4PathExcludesConfed` positive`unit/verifyTestRFC6793ConstructedAS4PathExcludesConfedSet` negative`unit/verifyTestRFC6793ConstructedAS4PathExcludesConfed` negative`unit/verifyTestRFC6793ConstructedAS4PathKeepsAnOrdinarySet`
`RFC6793-3-1`	To prevent the possible propagation of Confederation-related path segments outside of a Confederation, the path segment types AS_CONFED_SEQUENCE and AS_CONFED_SET [RFC5065] are declared invalid for the AS4_PATH attribute and MUST NOT be included in the AS4_PATH attribute of an UPDATE message. (Section 3, Section 6)
	MUST NOT	3	positive`unit/verifyTestRFC6793AS4PathWireExcludesConfed` negative`unit/verifyTestRFC6793AS4PathWireExcludesConfed`
`RFC6793-4.2.2-5`	Similarly, if the NEW BGP speaker has to send the AGGREGATOR attribute, and if the aggregating Autonomous System's AS number is a non-mappable four-octet AS number, then the speaker MUST use the AS4_AGGREGATOR attribute and set the AS number field in the existing AGGREGATOR attribute to the reserved AS number, AS_TRANS. (Section 4.2.2)
	MUST	4.2.2	positive`unit/verifyTestForwardedAggregatorIsDowngradedWithItsCompanion` positive`unit/verifyTestOriginatedAggregatorCarriesItsCompanionTowardOldSpeaker` positive`unit/verifyTestRFC6793AS4AggregatorForNonMappableAggregator` negative`unit/verifyTestAMappableAggregatorGetsNoCompanion` negative`unit/verifyTestOriginatedMappableAggregatorGetsNoCompanion` negative`unit/verifyTestRFC6793NoAS4AggregatorForMappableAggregator`
`RFC6793-4.2.2-6`	Note that if the AS number is mappable, then the AS4_AGGREGATOR attribute MUST NOT be sent. (Section 4.2.2)
	MUST NOT	4.2.2	positive`unit/verifyTestAMappableAggregatorGetsNoCompanion` positive`unit/verifyTestOriginatedMappableAggregatorGetsNoCompanion` positive`unit/verifyTestRFC6793NoAS4AggregatorForMappableAggregator` negative`unit/verifyTestForwardedAggregatorIsDowngradedWithItsCompanion` negative`unit/verifyTestOriginatedAggregatorCarriesItsCompanionTowardOldSpeaker` negative`unit/verifyTestRFC6793AS4AggregatorForNonMappableAggregator`
`RFC6793-4.2.3-1`	When a NEW BGP speaker receives an update from an OLD BGP speaker, it MUST be prepared to receive the AS4_PATH attribute along with the existing AS_PATH attribute. (Section 4.2.3)
	MUST	4.2.3	positive`unit/verifyTestRFC6793ReceivedAS4PathAcceptedAlongsideASPath` negative`unit/verifyTestRFC6793ASPathAloneNotInventedIntoFourOctet`
`RFC6793-4.2.3-2`	A NEW BGP speaker MUST also be prepared to receive the AS4_AGGREGATOR attribute along with the AGGREGATOR attribute from an OLD BGP speaker. (Section 4.2.3)
	MUST	4.2.3	positive`unit/verifyTestRFC6793ReceivedAS4AggregatorAccepted` negative`no test`no negative test {single-polarity}: the obligation is to accept the pair, and ParseAttributes has no rejection path to drive negatively: AGGREGATOR is interned and AS4_AGGREGATOR falls through the default branch into OtherAttrs, so every AGGREGATOR plus AS4_AGGREGATOR combination is accepted (internal/component/bgp/plugins/rib/storage/attrparse.go:96-102, :138-140). What ze does with the pair afterwards is governed by RFC6793-4.2.3-3 through -7, which are recorded as gaps
`RFC6793-4.2.3-3`	- the AS4_AGGREGATOR attribute and the AS4_PATH attribute SHALL be ignored, (Section 4.2.3)
	SHALL	4.2.3	positive`unit/verifyTestRFC6793AggregatorWithRealASIgnoresAS4Attributes` negative`unit/verifyTestRFC6793AggregatorOfTheWrongWidthIsNotRead` negative`unit/verifyTestRFC6793AggregatorWithASTransPromotesAS4Aggregator`
`RFC6793-4.2.3-4`	When both of the attributes are received, if the AS number in the AGGREGATOR attribute is not AS_TRANS, then: - the AS4_AGGREGATOR attribute and the AS4_PATH attribute SHALL be ignored, - the AGGREGATOR attribute SHALL be taken as the information about the aggregating node (§4.2.3)
	SHALL	4.2.3	positive`unit/verifyTestRFC6793AggregatorWithRealASIgnoresAS4Attributes` negative`unit/verifyTestRFC6793AggregatorWithASTransPromotesAS4Aggregator`
`RFC6793-4.2.3-5`	When both of the attributes are received, if the AS number in the AGGREGATOR attribute is not AS_TRANS, then: - the AS4_AGGREGATOR attribute and the AS4_PATH attribute SHALL be ignored, - the AGGREGATOR attribute SHALL be taken as the information about the aggregating node, and - the AS_PATH attribute SHALL be taken as the AS path information. (§4.2.3)
	SHALL	4.2.3	positive`unit/verifyTestRFC6793AggregatorWithRealASIgnoresAS4Attributes` negative`unit/verifyTestRFC6793AggregatorWithASTransPromotesAS4Aggregator`
`RFC6793-4.2.3-6`	- the AGGREGATOR attribute SHALL be ignored, (Section 4.2.3)
	SHALL	4.2.3	positive`unit/verifyTestRFC6793AggregatorWithASTransPromotesAS4Aggregator` negative`unit/verifyTestRFC6793AggregatorWithRealASIgnoresAS4Attributes`
`RFC6793-4.2.3-7`	- the AS4_AGGREGATOR attribute SHALL be taken as the information about the aggregating node, and (Section 4.2.3)
	SHALL	4.2.3	positive`unit/verifyTestRFC6793AggregatorWithASTransPromotesAS4Aggregator` negative`unit/verifyTestRFC6793AggregatorWithRealASIgnoresAS4Attributes` negative`unit/verifyTestRFC6793LoneAS4AggregatorIsDropped`
`RFC6793-4.2.3-8`	If the number of AS numbers in the AS_PATH attribute is less than the number of AS numbers in the AS4_PATH attribute, then the AS4_PATH attribute SHALL be ignored, and the AS_PATH attribute SHALL be taken as the AS path information. (Section 4.2.3)
	SHALL	4.2.3	positive`unit/verifyTestRFC6793LongerAS4PathIsIgnored` negative`unit/verifyTestRFC6793LongerASPathPrependsLeadingHops`
`RFC6793-4.2.3-9`	If the number of AS numbers in the AS_PATH attribute is larger than or equal to the number of AS numbers in the AS4_PATH attribute, then the AS path information SHALL be constructed by taking as many AS numbers and path segments as necessary from the leading part of the AS_PATH attribute, and then prepending them to the AS4_PATH attribute so that the AS path information has a number of AS numbers identical to that of the AS_PATH attribute. (Section 4.2.3)
	SHALL	4.2.3	positive`unit/verifyTestRFC6793EqualCountsPrependNothing` positive`unit/verifyTestRFC6793LeadingASSetIsTakenWhole` positive`unit/verifyTestRFC6793LongerASPathPrependsLeadingHops` negative`unit/verifyTestRFC6793LongerAS4PathIsIgnored`
`RFC6793-4.2.3-10`	Note that a valid AS_CONFED_SEQUENCE or AS_CONFED_SET path segment SHALL be prepended if it is either the leading path segment or is adjacent to a path segment that is prepended. (Section 4.2.3)
	SHALL	4.2.3	positive`unit/verifyTestRFC6793ConfedSegmentAdjacentToPrependedIsPrepended` positive`unit/verifyTestRFC6793LeadingConfedSegmentIsPrepended` negative`unit/verifyTestRFC6793ConfedSegmentAdjacentToPrependedIsPrepended` negative`unit/verifyTestRFC6793UnadjacentConfedSegmentIsNotPrepended`
`RFC6793-6-1`	The AS4_PATH attribute in an UPDATE message SHALL be considered malformed under the following conditions: - the attribute length is not a multiple of two or is too small (i.e., less than 6) for the attribute to carry at least one AS number, or - the path segment length in the attribute is either zero or is inconsistent with the attribute length, or - the path segment type in the attribute is not one of the types defined: AS_SEQUENCE, AS_SET, AS_CONFED_SEQUENCE, and AS_CONFED_SET. (§6)
	SHALL	6	positive`unit/verifyTestRFC6793AS4PathWellFormedAccepted` positive`unit/verifyTestRFC6793MalformedAS4PathIsDiscarded` negative`unit/verifyTestRFC6793AS4PathMalformedRejected`
`RFC6793-6-2`	The AS4_AGGREGATOR attribute in an UPDATE message SHALL be considered malformed if the attribute length is not 8. (Section 6)
	SHALL	6	positive`unit/verifyTestRFC6793AS4AggregatorLengthEight` negative`unit/verifyTestRFC6793AS4AggregatorLengthEight`
`RFC6793-6-3`	A NEW BGP speaker that receives these path segment types in the AS4_PATH attribute of an UPDATE message from an OLD BGP speaker MUST discard these path segments, adjust the relevant attribute fields accordingly, and continue processing the UPDATE message. (Section 6)
	MUST	6	positive`unit/verifyTestRFC6793ReceivedAS4PathConfedSegmentsDiscarded` positive`unit/verifyTestRFC6793ReceivedConfedInAS4PathDiscarded` negative`unit/verifyTestRFC6793ReceivedAS4PathDiscardTakesOnlyConfedSegments` negative`unit/verifyTestRFC6793ReceivedConfedInAS4PathDiscarded`
`RFC6793-6-4`	A NEW BGP speaker that receives a malformed AS4_PATH attribute in an UPDATE message from an OLD BGP speaker MUST discard the attribute and continue processing the UPDATE message. (Section 6)
	MUST	6	positive`unit/verifyTestRFC6793MalformedAS4PathDiscarded` negative`unit/verifyTestRFC6793WellFormedAS4PathNotDiscarded`
`RFC6793-6-5`	A NEW BGP speaker that receives a malformed AS4_AGGREGATOR attribute in an UPDATE message from an OLD BGP speaker MUST discard the attribute and continue processing the UPDATE message. (Section 6)
	MUST	6	positive`unit/verifyTestCollapseAS4DiscardsMalformedAS4Aggregator` negative`unit/verifyTestCollapseAS4SelectsAggregatorPerSection423`
`RFC6793-6-6`	A NEW BGP speaker that receives the AS4_PATH attribute or the AS4_AGGREGATOR attribute in an UPDATE message from another NEW BGP speaker MUST discard the path attribute and continue processing the UPDATE message. This case SHOULD be logged locally for analysis. (§6)
	SHOULD	6	positive`no test`no positive test negative`no test`no negative test
`RFC6793-6-7`	A NEW BGP speaker that receives these path segment types in the AS4_PATH attribute of an UPDATE message from an OLD BGP speaker MUST discard these path segments, adjust the relevant attribute fields accordingly, and continue processing the UPDATE message. This case SHOULD be logged locally for analysis. (§6)
	SHOULD	6	positive`no test`no positive test negative`no test`no negative test
`RFC6793-6-8`	A NEW BGP speaker that receives a malformed AS4_PATH attribute in an UPDATE message from an OLD BGP speaker MUST discard the attribute and continue processing the UPDATE message. The error SHOULD be logged locally for analysis. (§6)
	SHOULD	6	positive`no test`no positive test negative`no test`no negative test
`RFC6793-6-9`	A NEW BGP speaker that receives a malformed AS4_AGGREGATOR attribute in an UPDATE message from an OLD BGP speaker MUST discard the attribute and continue processing the UPDATE message. The error SHOULD be logged locally for analysis. (§6)
	SHOULD	6	positive`no test`no positive test negative`no test`no negative test
`RFC6793-5-1`	Quite clearly, this would not work for a NEW BGP speaker with a non-mappable four-octet AS number. Such BGP speakers should use four-octet AS specific extended communities [RFC5668] instead. (§5)
	SHOULD	5	positive`no test`no positive test negative`no test`no negative test
`RFC6793-7-1`	When an Autonomous System is using a two-octet AS number, then the BGP speakers within that Autonomous System MAY be upgraded to support the four-octet AS number extensions on a piecemeal basis. (§7)
	MAY	7	positive`no test`no positive test negative`no test`no negative test

Gaps and untested MUSTs

Requirement	State	Reason
`RFC6793-4.1-3` When a NEW BGP speaker processes an OPEN message from another NEW BGP speaker, it MUST use the AS number encoded in the Capability Value field of the "support for four-octet AS number capability" in lieu of the "My Autonomous System" field of the OPEN message. (Section 4.1)	{gap}, no test	UnpackOpen never populates Open.ASN4 from the code-65 capability -- it sets only Version, MyAS, HoldTime and BGPIdentifier (internal/component/bgp/message/open.go:171-180) -- so the reactor's only OPEN-derived peer AS falls back to the two-octet header field: resolveDynamicPeerSettings reads the always-zero open.ASN4 and keeps uint32(open.MyAS), i.e. AS_TRANS for a non-mappable peer (internal/component/bgp/reactor/reactor_dynamic.go:311-316), and negotiateWith passes that same zero as the peer ASN into Negotiate (internal/component/bgp/reactor/session_negotiate.go:27-32). The route-server plugin does read the capability value for its event view (internal/component/bgp/plugins/rs/server.go:647-649), but that is a reporting path, not the session's peer AS

Proof state

A tagged unit reads unproven where no discrimination record exists for it: nothing in this tree has been observed to break it, so the claim its tag makes is unproven.

`RFC6793-4.1-1`

A BGP speaker that supports four-octet AS numbers SHALL advertise this to its peers using BGP Capabilities Advertisements (Section 4.1)

Audit verdict: not audited: no reader has judged these tests

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793OpenOmitsCapabilityWhenDisabled`	unit/verify	unproven
positive	`TestRFC6793OpenAdvertisesFourOctetASCapability`	unit/verify	unproven

`RFC6793-4.1-2`

The AS number of the BGP speaker MUST be carried in the Capability Value field of the "support for four-octet AS number capability" (Section 4.1)

Audit verdict: not audited: no reader has judged these tests

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793ASN4CapabilityValueMustBeFourOctets`	unit/verify	unproven
positive	`TestRFC6793ASN4CapabilityCarriesSpeakerAS`	unit/verify	unproven

`RFC6793-4.1-3`

When a NEW BGP speaker processes an OPEN message from another NEW BGP speaker, it MUST use the AS number encoded in the Capability Value field of the "support for four-octet AS number capability" in lieu of the "My Autonomous System" field of the OPEN message. (Section 4.1)

Audit verdict: not audited: no reader has judged these tests

No test carries RFC6793-4.1-3, so no unit is bound to it.

`RFC6793-4.1-4`

A BGP speaker that advertises such a capability to a particular peer, and receives from that peer the advertisement of such a capability, MUST encode AS numbers as four-octet entities in both the AS_PATH attribute and the AGGREGATOR attribute in the updates it sends to the peer (§4.1)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793EncodeFourOctetToNewSpeaker drives ASPath/Aggregator WriteToWithContext with an ASN4 context and asserts 4-byte AS_PATH stride and 8-octet AGGREGATOR; the negative shows the 2-octet form without the capability.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793EncodeTwoOctetToOldSpeaker`	unit/verify	unproven
positive	`TestRFC6793EncodeFourOctetToNewSpeaker`	unit/verify	unproven

`RFC6793-4.1-5`

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793DecodeFourOctetWhenNegotiated reads ParseASPath/ParseAggregator with fourByte=true and recovers 4200000001; the negative shows the same bytes decode on a 2-octet stride and an 8-octet AGGREGATOR is refused without the capability.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793DecodeTwoOctetWhenNotNegotiated`	unit/verify	unproven
positive	`TestRFC6793DecodeFourOctetWhenNegotiated`	unit/verify	unproven

`RFC6793-4.1-6`

The new attributes, AS4_PATH and AS4_AGGREGATOR, MUST NOT be carried in an UPDATE message between NEW BGP speakers. (Section 4.1, Section 6)

Audit verdict: enforced (the tests do what the requirement demands), fresh. RFC 6793 §4.1 states: 'The new attributes, AS4_PATH and AS4_AGGREGATOR, MUST NOT be carried in an UPDATE message between NEW BGP speakers.' Section 6 repeats the prohibition. Re-read both primary passages, summary and unannotated checklist row, all five tagged covers and actual producers. TestOriginatedUpdateOmitsAS4PathTowardNewSpeaker drives the seven enumerated AS_PATH builder entry points with a non-mappable AS, asserting no decoded AS4_PATH AS numbers and the exact four-octet AS_PATH; TestOriginatedAggregatorOmitsAS4AggregatorTowardNewSpeaker drives all four enumerated aggregator builders, asserting attribute-18 absence and the real non-mappable AS in AGGREGATOR. The actual origination gates are UpdateBuilder.appendASPath/ASPathNeedsAS4 and appendAggregator/AS4AggregatorFor. The two NEW-speaker CI carriers supply the forbidden attributes rather than merely observing their absence on clean input: no-as4path requires exactly 24 attribute octets and preserves AS_PATH tail 4200000123 rather than the supplied AS4_PATH tail 4200000000; no-as4aggregator requires exactly 35 attribute octets, preserves AGGREGATOR AS 4200000123 and excludes the supplied AS4_AGGREGATOR naming 4200000000. Each exact full frame also requires delivery of the route. The OLD-speaker negative carrier requires the actual relayed two-octet AS_PATH [65000,65001,AS_TRANS] and four-octet AS4_PATH [65000,65001,4200000123], distinguishing the destination-scoped prohibition from blanket suppression; it is not an independent negative for AS4_AGGREGATOR. Current receive validation prepares AS4FamilyPlan, session_read consumes its WriteTo result before publication, and WriteTo explicitly omits types 17 and 18 while copying unrelated attributes and NLRI. The corrected comment names that actual path. Current WriteTo halt records in job-final-functional-citations-and-precise-framing-8381327b.log prove reachability only, since replay/EOR can fail before byte comparison; the older CollapseAS4Family-wrapper halt is not semantic evidence for these fixtures. The combined origination and exact relay assertions support both named attributes without treating either single carrier or a halt as proof of the whole clause.

Polarity	Test	Kind and tier	Proof state
negative	`rfc6793-narrow-to-old-speaker.ci`	functional/verify	revert, verified
positive	`TestOriginatedUpdateOmitsAS4PathTowardNewSpeaker`	unit/verify	revert, verified
positive	`TestOriginatedAggregatorOmitsAS4AggregatorTowardNewSpeaker`	unit/verify	revert, verified
positive	`rfc6793-no-as4aggregator-from-new-speaker.ci`	functional/verify	revert, verified
positive	`rfc6793-no-as4path-from-new-speaker.ci`	functional/verify	revert, verified

`RFC6793-4.1-7`

A NEW BGP speaker that receives the AS4_PATH attribute or the AS4_AGGREGATOR attribute in an UPDATE message from another NEW BGP speaker MUST discard the path attribute and continue processing the UPDATE message. (Section 4.1, Section 6)

Audit verdict: enforced (the tests do what the requirement demands), fresh. RFC 6793 §4.1 states: 'A NEW BGP speaker that receives the AS4_PATH attribute or the AS4_AGGREGATOR attribute in an UPDATE message from another NEW BGP speaker MUST discard the path attribute and continue processing the UPDATE message.' Section 6 repeats that sentence; its following logging SHOULD is a separate obligation, not silently included in this verdict. Re-read the primary passages, summary and unannotated checklist row, all three tagged covers, ReconcileASPathFamily and the actual receive preparation/rewrite/publication consumers. TestRFC6793NewSpeakerAS4AttributesAreDiscarded feeds both attributes with SourceASN4=true, requires successful reconciliation, exact unchanged canonical AS_PATH and AGGREGATOR, and exactly the discard codes [AttrAS4Path,AttrAS4Aggregator]. Its AS_PATH and AS4_PATH values agree, so that value equality alone does not distinguish a mistaken merge; the explicit discard assertions and the live AS4_PATH carrier supply the missing distinction. That carrier deliberately disagrees on the path tail and requires the complete relayed frame containing the original AS_PATH, ORIGIN, NEXT_HOP and announced prefix, with no AS4_PATH: retaining it, substituting its tail, dropping the UPDATE or treating its route as withdrawn cannot satisfy the expectation. TestRFC6793ReceivedAS4PathAcceptedAlongsideASPath supplies the OLD-source control and requires the AS4_PATH's non-mappable AS to become canonical instead of retaining AS_TRANS. The unit cover establishes both attribute decisions; the CI tagged to this ID establishes continued route processing and non-substitution end to end for AS4_PATH only, not an AS4_AGGREGATOR-specific end-to-end claim. Source inspection confirms the shared AS4FamilyPlan.WriteTo dispatch explicitly drops both legacy attributes, preserves unrelated attributes and NLRI, and returns the rewritten WireUpdate for normal callback publication. The separately tagged AS4_AGGREGATOR carrier under RFC6793-4.1-6 corroborates that same writer boundary but is not misrepresented as a tagged cover of this ID. Whole-producer halts remain reachability evidence, not selective discard proof. The combined tagged unit and functional assertions enforce both discard and continued-processing obligations.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793ReceivedAS4PathAcceptedAlongsideASPath`	unit/verify	revert, verified
positive	`TestRFC6793NewSpeakerAS4AttributesAreDiscarded`	unit/verify	revert, verified
positive	`rfc6793-no-as4path-from-new-speaker.ci`	functional/verify	revert, verified

`RFC6793-4.2.1-1`

However, this document does not assume that an Autonomous System with NEW BGP speakers has to have a globally unique two-octet AS number -- AS_TRANS MUST be used when the NEW BGP speaker does not have a two-octet AS number (even if multiple Autonomous Systems would use it). (Section 4.2.1)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793OpenMyASIsASTransWithoutTwoOctetAS asserts the sent OPEN My AS is 23456 for AS 4200000001; the negative keeps 65001 as itself.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793OpenMyASIsRealASWhenMappable`	unit/verify	unproven
positive	`TestRFC6793OpenMyASIsASTransWithoutTwoOctetAS`	unit/verify	unproven

`RFC6793-4.2.2-1`

When communicating with an OLD BGP speaker, a NEW BGP speaker MUST send the AS path information in the AS_PATH attribute encoded with two-octet AS numbers. (Section 4.2.2)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793EncodeTwoOctetToOldSpeaker asserts a 2-octet AS_PATH with AS_TRANS toward a non-ASN4 context; the negative keeps mappable ASNs unsubstituted.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793TwoOctetASPathKeepsMappableASNs`	unit/verify	unproven
positive	`TestRFC6793EncodeTwoOctetToOldSpeaker`	unit/verify	unproven

`RFC6793-4.2.2-2`

The NEW BGP speaker MUST also send the AS path information in the AS4_PATH attribute (encoded with four-octet AS numbers), except for the case where all of the AS path information is composed of mappable four-octet AS numbers only. (Section 4.2.2)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Originate builders (message) and TranscodeASPath (wireu) both emit AS4_PATH with the real 4-octet AS toward an OLD speaker; negatives show no AS4_PATH when every AS is mappable.

Polarity	Test	Kind and tier	Proof state
negative	`TestOriginatedUpdateOmitsAS4PathWhenEveryASIsMappable`	unit/verify	revert, verified
negative	`TestRFC6793TranscodeOmitsAS4PathWhenAllMappable`	unit/verify	unproven
positive	`TestOriginatedUpdateCarriesAS4PathForANonMappableLocalAS`	unit/verify	revert, verified
positive	`TestOriginatedUpdateCarriesAS4PathTowardOldSpeaker`	unit/verify	revert, verified
positive	`TestRFC6793TranscodeEmitsAS4PathForNonMappable`	unit/verify	unproven

`RFC6793-4.2.2-3`

In this case, the NEW BGP speaker MUST NOT send the AS4_PATH attribute. (Section 4.2.2)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Originate builders and TranscodeASPath omit AS4_PATH when all ASNs are mappable; negatives show it present for a non-mappable AS.

Polarity	Test	Kind and tier	Proof state
negative	`TestOriginatedUpdateCarriesAS4PathTowardOldSpeaker`	unit/verify	revert, verified
negative	`TestRFC6793TranscodeEmitsAS4PathForNonMappable`	unit/verify	unproven
positive	`TestOriginatedUpdateOmitsAS4PathWhenEveryASIsMappable`	unit/verify	revert, verified
positive	`TestRFC6793TranscodeOmitsAS4PathWhenAllMappable`	unit/verify	unproven

`RFC6793-4.2.2-4`

Whenever the AS path information contains the AS_CONFED_SEQUENCE or AS_CONFED_SET path segment, the NEW BGP speaker MUST exclude such path segments from the AS4_PATH attribute being constructed. (Section 4.2.2)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Both confederation types now proven excluded from the constructed AS4_PATH. TestRFC6793ConstructedAS4PathExcludesConfedSet: AS_CONFED_SET {64514,64515}, AS_CONFED_SEQUENCE [64512], AS_SEQUENCE [non-mappable, 65001] through TranscodeASPath 4->2 yields an AS4_PATH of exactly the one AS_SEQUENCE, AS_PATH keeping all three. The AS_CONFED_SEQUENCE half is also held by the HEAD TestRFC6793ConstructedAS4PathExcludesConfed (exact single-segment assertion, no record) and by the AS_CONFED_SEQUENCE inside the new recorded unit. Negative TestRFC6793ConstructedAS4PathKeepsAnOrdinarySet: an ordinary AS_SET in the same place is carried, so the exclusion is scoped to type 3/4. Judge break (overlay, attribute/as4.go AS4Path.Len and WriteTo excluding only AS_CONFED_SEQUENCE) turned the new positive red, the HEAD sequence-only unit and the new negative green. Revert records on TranscodeASPath both polarities.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793ConstructedAS4PathExcludesConfed`	unit/verify	unproven
negative	`TestRFC6793ConstructedAS4PathKeepsAnOrdinarySet`	unit/verify	revert, verified
positive	`TestRFC6793ConstructedAS4PathExcludesConfed`	unit/verify	unproven
positive	`TestRFC6793ConstructedAS4PathExcludesConfedSet`	unit/verify	revert, verified

`RFC6793-3-1`

To prevent the possible propagation of Confederation-related path segments outside of a Confederation, the path segment types AS_CONFED_SEQUENCE and AS_CONFED_SET [RFC5065] are declared invalid for the AS4_PATH attribute and MUST NOT be included in the AS4_PATH attribute of an UPDATE message. (Section 3, Section 6)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793AS4PathWireExcludesConfed: AS4Path.WriteTo/Len skip both confed types and keep AS_SEQUENCE/AS_SET, with Len matching bytes written.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793AS4PathWireExcludesConfed`	unit/verify	unproven
positive	`TestRFC6793AS4PathWireExcludesConfed`	unit/verify	unproven

`RFC6793-4.2.2-5`

Similarly, if the NEW BGP speaker has to send the AGGREGATOR attribute, and if the aggregating Autonomous System's AS number is a non-mappable four-octet AS number, then the speaker MUST use the AS4_AGGREGATOR attribute and set the AS number field in the existing AGGREGATOR attribute to the reserved AS number, AS_TRANS. (Section 4.2.2)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Three producers (message originate, wireu TranscodeASPath, rib commit pack) each send AS_TRANS in a 6-octet AGGREGATOR plus AS4_AGGREGATOR with the real AS for a non-mappable aggregator; negatives keep a mappable AS with no companion.

Polarity	Test	Kind and tier	Proof state
negative	`TestOriginatedMappableAggregatorGetsNoCompanion`	unit/verify	revert, verified
negative	`TestAMappableAggregatorGetsNoCompanion`	unit/verify	unproven
negative	`TestRFC6793NoAS4AggregatorForMappableAggregator`	unit/verify	unproven
positive	`TestOriginatedAggregatorCarriesItsCompanionTowardOldSpeaker`	unit/verify	revert, verified
positive	`TestForwardedAggregatorIsDowngradedWithItsCompanion`	unit/verify	unproven
positive	`TestRFC6793AS4AggregatorForNonMappableAggregator`	unit/verify	unproven

`RFC6793-4.2.2-6`

Note that if the AS number is mappable, then the AS4_AGGREGATOR attribute MUST NOT be sent. (Section 4.2.2)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Same three producers send no AS4_AGGREGATOR for a mappable aggregating AS; negatives show it present for a non-mappable one.

Polarity	Test	Kind and tier	Proof state
negative	`TestOriginatedAggregatorCarriesItsCompanionTowardOldSpeaker`	unit/verify	revert, verified
negative	`TestForwardedAggregatorIsDowngradedWithItsCompanion`	unit/verify	unproven
negative	`TestRFC6793AS4AggregatorForNonMappableAggregator`	unit/verify	unproven
positive	`TestOriginatedMappableAggregatorGetsNoCompanion`	unit/verify	revert, verified
positive	`TestAMappableAggregatorGetsNoCompanion`	unit/verify	unproven
positive	`TestRFC6793NoAS4AggregatorForMappableAggregator`	unit/verify	unproven

`RFC6793-4.2.3-1`

When a NEW BGP speaker receives an update from an OLD BGP speaker, it MUST be prepared to receive the AS4_PATH attribute along with the existing AS_PATH attribute. (Section 4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793ReceivedAS4PathAcceptedAlongsideASPath: ReconcileASPathFamily accepts AS_PATH+AS4_PATH from an OLD speaker and uses the AS4_PATH ASNs; the negative shows no 4-octet AS invented without AS4_PATH.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793ASPathAloneNotInventedIntoFourOctet`	unit/verify	revert, verified
positive	`TestRFC6793ReceivedAS4PathAcceptedAlongsideASPath`	unit/verify	revert, verified

`RFC6793-4.2.3-2`

A NEW BGP speaker MUST also be prepared to receive the AS4_AGGREGATOR attribute along with the AGGREGATOR attribute from an OLD BGP speaker. (Section 4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793ReceivedAS4AggregatorAccepted: the AGGREGATOR+AS4_AGGREGATOR pair from an OLD speaker is accepted and the 4-octet aggregating AS survives ingest (single-polarity marker).

Polarity	Test	Kind and tier	Proof state
positive	`TestRFC6793ReceivedAS4AggregatorAccepted`	unit/verify	revert, verified

`RFC6793-4.2.3-3`

- the AS4_AGGREGATOR attribute and the AS4_PATH attribute SHALL be ignored, (Section 4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793AggregatorWithRealASIgnoresAS4Attributes: with AGGREGATOR.AS 64500 the AS4_PATH does not reach the path and the AS4_AGGREGATOR is discarded; negatives with AS_TRANS use both.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793AggregatorOfTheWrongWidthIsNotRead`	unit/verify	revert, verified
negative	`TestRFC6793AggregatorWithASTransPromotesAS4Aggregator`	unit/verify	revert, verified
positive	`TestRFC6793AggregatorWithRealASIgnoresAS4Attributes`	unit/verify	revert, verified

`RFC6793-4.2.3-4`

When both of the attributes are received, if the AS number in the AGGREGATOR attribute is not AS_TRANS, then: - the AS4_AGGREGATOR attribute and the AS4_PATH attribute SHALL be ignored, - the AGGREGATOR attribute SHALL be taken as the information about the aggregating node (§4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Same unit: the AGGREGATOR (64500, 10.0.0.1) is the aggregating node; the AS_TRANS counterpart does not take it.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793AggregatorWithASTransPromotesAS4Aggregator`	unit/verify	revert, verified
positive	`TestRFC6793AggregatorWithRealASIgnoresAS4Attributes`	unit/verify	revert, verified

`RFC6793-4.2.3-5`

Audit verdict: enforced (the tests do what the requirement demands), fresh. Same unit: the route path is the AS_PATH widened with AS_TRANS intact; the AS_TRANS counterpart reconstructs instead.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793AggregatorWithASTransPromotesAS4Aggregator`	unit/verify	revert, verified
positive	`TestRFC6793AggregatorWithRealASIgnoresAS4Attributes`	unit/verify	revert, verified

`RFC6793-4.2.3-6`

- the AGGREGATOR attribute SHALL be ignored, (Section 4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793AggregatorWithASTransPromotesAS4Aggregator: with AGGREGATOR.AS AS_TRANS the stored aggregator is the AS4_AGGREGATOR value, not AS_TRANS; negative keeps a real-AS AGGREGATOR.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793AggregatorWithRealASIgnoresAS4Attributes`	unit/verify	revert, verified
positive	`TestRFC6793AggregatorWithASTransPromotesAS4Aggregator`	unit/verify	revert, verified

`RFC6793-4.2.3-7`

- the AS4_AGGREGATOR attribute SHALL be taken as the information about the aggregating node, and (Section 4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Same unit: the aggregating node is 4200000001/10.0.0.1 from AS4_AGGREGATOR; negatives: not promoted when AGGREGATOR is real, nor when AS4_AGGREGATOR arrives alone.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793AggregatorWithRealASIgnoresAS4Attributes`	unit/verify	revert, verified
negative	`TestRFC6793LoneAS4AggregatorIsDropped`	unit/verify	revert, verified
positive	`TestRFC6793AggregatorWithASTransPromotesAS4Aggregator`	unit/verify	revert, verified

`RFC6793-4.2.3-8`

If the number of AS numbers in the AS_PATH attribute is less than the number of AS numbers in the AS4_PATH attribute, then the AS4_PATH attribute SHALL be ignored, and the AS_PATH attribute SHALL be taken as the AS path information. (Section 4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793LongerAS4PathIsIgnored: AS_PATH 2 ASNs vs AS4_PATH 3 yields the widened AS_PATH only; negative shows AS4_PATH used when AS_PATH is longer.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793LongerASPathPrependsLeadingHops`	unit/verify	revert, verified
positive	`TestRFC6793LongerAS4PathIsIgnored`	unit/verify	revert, verified

`RFC6793-4.2.3-9`

If the number of AS numbers in the AS_PATH attribute is larger than or equal to the number of AS numbers in the AS4_PATH attribute, then the AS path information SHALL be constructed by taking as many AS numbers and path segments as necessary from the leading part of the AS_PATH attribute, and then prepending them to the AS4_PATH attribute so that the AS path information has a number of AS numbers identical to that of the AS_PATH attribute. (Section 4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793LongerASPathPrependsLeadingHops, EqualCountsPrependNothing, LeadingASSetIsTakenWhole assert exact reconstructed bytes; negative: no prepend when AS4_PATH is longer.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793LongerAS4PathIsIgnored`	unit/verify	revert, verified
positive	`TestRFC6793EqualCountsPrependNothing`	unit/verify	revert, verified
positive	`TestRFC6793LeadingASSetIsTakenWhole`	unit/verify	revert, verified
positive	`TestRFC6793LongerASPathPrependsLeadingHops`	unit/verify	revert, verified

`RFC6793-4.2.3-10`

Note that a valid AS_CONFED_SEQUENCE or AS_CONFED_SET path segment SHALL be prepended if it is either the leading path segment or is adjacent to a path segment that is prepended. (Section 4.2.3)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Judge 2026-09-30. TestRFC6793ConfedSegmentAdjacentToPrependedIsPrepended drives ReconcileASPathFamily: + AS_SEQ 64500, AS_CONFED_SEQ 65001, AS_SEQ TRANS TRANS beside a two-hop AS4_PATH keeps the confed segment after the prepended 64500; - the same confed segment behind a non-prepended AS_SEQ is dropped. Leading-segment clause is TestRFC6793LeadingConfedSegmentIsPrepended. Judge breaks in appendLeadingSegments: continuing past a non-prepended segment turned the negative red; stopping before a confed segment once the budget is spent turned the positive red.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793ConfedSegmentAdjacentToPrependedIsPrepended`	unit/verify	revert, verified
negative	`TestRFC6793UnadjacentConfedSegmentIsNotPrepended`	unit/verify	revert, verified
positive	`TestRFC6793ConfedSegmentAdjacentToPrependedIsPrepended`	unit/verify	revert, verified
positive	`TestRFC6793LeadingConfedSegmentIsPrepended`	unit/verify	revert, verified

`RFC6793-6-1`

The AS4_PATH attribute in an UPDATE message SHALL be considered malformed under the following conditions: - the attribute length is not a multiple of two or is too small (i.e., less than 6) for the attribute to carry at least one AS number, or - the path segment length in the attribute is either zero or is inconsistent with the attribute length, or - the path segment type in the attribute is not one of the types defined: AS_SEQUENCE, AS_SET, AS_CONFED_SEQUENCE, and AS_CONFED_SET. (§6)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793AS4PathMalformedRejected drives every Section 6 condition (odd length, <6 octets, zero and overrunning segment length, undefined type) through ParseAS4Path; positive accepts a well-formed path. The tag at rfc6793_reconcile_test.go TestRFC6793MalformedAS4PathIsDiscarded describes the RFC6793-6-4 discard obligation rather than this row.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793AS4PathMalformedRejected`	unit/verify	unproven
positive	`TestRFC6793AS4PathWellFormedAccepted`	unit/verify	unproven
positive	`TestRFC6793MalformedAS4PathIsDiscarded`	unit/verify	revert, verified

`RFC6793-6-2`

The AS4_AGGREGATOR attribute in an UPDATE message SHALL be considered malformed if the attribute length is not 8. (Section 6)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793AS4AggregatorLengthEight: ParseAS4Aggregator accepts 8 octets and refuses 0,6,7,9,12 with ErrInvalidLength.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793AS4AggregatorLengthEight`	unit/verify	unproven
positive	`TestRFC6793AS4AggregatorLengthEight`	unit/verify	unproven

`RFC6793-6-3`

A NEW BGP speaker that receives these path segment types in the AS4_PATH attribute of an UPDATE message from an OLD BGP speaker MUST discard these path segments, adjust the relevant attribute fields accordingly, and continue processing the UPDATE message. (Section 6)

Audit verdict: enforced (the tests do what the requirement demands), fresh. Re-judged 2026-10-02 (BGP c34 judge). internal/component/bgp/wireu/rfc6793_received_confed_test.go reads the output of CollapseAS4Family, the single ingest rewrite every downstream consumer sees, so the receive-side discard is measured apart from the AS4_PATH encoder's own confed filter (RFC6793-3-1). Positive: an OLD speaker's AS4_PATH holding an AS_CONFED_SEQUENCE and an AS_CONFED_SET ahead of an AS_SEQUENCE collapses to the exact payload (AS_PATH 40 02 10: [65001] then [4200000001,4200000002], attribute section 0x1E, NLRI kept, no error): both segment types discarded, lengths adjusted, processing continues (judge checked the RFC 6793 Section 4.2.3 arithmetic and both length octets). Negative: an AS_SET in the AS4_PATH and a leading AS_CONFED_SEQUENCE in the AS_PATH both survive (payload literal, 0x1C / 0x2A), so the discard is not blanket. Records: attribute/as4.go::appendAS4Segments revert, both polarities observed red; author overlay probes (kept confed segments -> only the positive red, discard widened to AS_SET -> only the negative red) re-read by the judge in scratch c34p. The HEAD egress units in rfc6793_as4_test.go stay as unrecorded supplementary tags. The Section 6 SHOULD-log clause is not this row.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793ReceivedConfedInAS4PathDiscarded`	unit/verify	unproven
negative	`TestRFC6793ReceivedAS4PathDiscardTakesOnlyConfedSegments`	unit/verify	revert, verified
positive	`TestRFC6793ReceivedConfedInAS4PathDiscarded`	unit/verify	unproven
positive	`TestRFC6793ReceivedAS4PathConfedSegmentsDiscarded`	unit/verify	revert, verified

`RFC6793-6-4`

A NEW BGP speaker that receives a malformed AS4_PATH attribute in an UPDATE message from an OLD BGP speaker MUST discard the attribute and continue processing the UPDATE message. (Section 6)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestRFC6793MalformedAS4PathDiscarded: an odd-length AS4_PATH from an OLD speaker contributes nothing and the rewrite proceeds; negative keeps a well-formed one.

Polarity	Test	Kind and tier	Proof state
negative	`TestRFC6793WellFormedAS4PathNotDiscarded`	unit/verify	unproven
positive	`TestRFC6793MalformedAS4PathDiscarded`	unit/verify	unproven

`RFC6793-6-5`

A NEW BGP speaker that receives a malformed AS4_AGGREGATOR attribute in an UPDATE message from an OLD BGP speaker MUST discard the attribute and continue processing the UPDATE message. (Section 6)

Audit verdict: enforced (the tests do what the requirement demands), fresh. TestCollapseAS4DiscardsMalformedAS4Aggregator: a 7-octet AS4_AGGREGATOR is removed from the collapsed payload, not promoted, NLRI kept, drop reported; negative reads an 8-octet one.

Polarity	Test	Kind and tier	Proof state
negative	`TestCollapseAS4SelectsAggregatorPerSection423`	unit/verify	revert, verified
positive	`TestCollapseAS4DiscardsMalformedAS4Aggregator`	unit/verify	revert, verified

Extraction sign-off

Field	Value
Reviewer	claude
Signed off	2026-09-21
Register	rfc2119
Source	rfc/full/rfc6793.txt
Source fingerprint	c532462ab07361de
Record	rfc/extraction/rfc6793.json
Mapped sentences	29
Declined as scope	3
Relocated to a spec, which Ze OWES	0
Unclassified	0

Sections

Section	Name	Sites	Disposition	Reason
`front`	not stated	0	walked	not stated
`1`	not stated	0	walked	not stated
`2`	not stated	0	walked	not stated
`3`	not stated	1	walked	not stated
`4`	not stated	0	walked	not stated
`4.1`	not stated	6	walked	not stated
`4.2`	not stated	0	walked	not stated
`4.2.1`	not stated	1	walked	not stated
`4.2.2`	not stated	6	walked	not stated
`4.2.3`	not stated	10	walked	not stated
`5`	not stated	0	walked	not stated
`6`	not stated	8	walked	not stated
`7`	not stated	0	walked	not stated
`8`	not stated	0	walked	not stated
`9`	not stated	0	walked	not stated
`10`	not stated	0	walked	not stated
`11`	not stated	0	walked	not stated
`12`	not stated	0	walked	not stated
`12.1`	not stated	0	walked	not stated
`12.2`	not stated	0	walked	not stated

Excluded sentences

Site	Excluded kind	Reason	Quote
`6:1`	`duplicate-of` never bound Ze the same obligation is already captured under another requirement id	Section 6 restates the Section 4.1 prohibition word for word; site 4.1:5 carries the same sentence and maps RFC6793-4.1-6, whose checklist row cites both sections.	The AS4_PATH attribute and AS4_AGGREGATOR attribute MUST NOT be carried in an UPDATE message between NEW BGP speakers.
`6:2`	`duplicate-of` never bound Ze the same obligation is already captured under another requirement id	Section 6 restates the Section 4.1 discard rule word for word; site 4.1:6 carries the same sentence and maps RFC6793-4.1-7, whose checklist row cites both sections.	A NEW BGP speaker that receives the AS4_PATH attribute or the AS4_AGGREGATOR attribute in an UPDATE message from another NEW BGP speaker MUST discard the path attribute and continue processing the UPDATE message.
`6:3`	`duplicate-of` never bound Ze the same obligation is already captured under another requirement id	Section 6 restates the Section 3 prohibition on AS_CONFED_SEQUENCE and AS_CONFED_SET inside AS4_PATH; site 3:1 maps RFC6793-3-1, whose checklist row cites both sections.	In addition, the path segment types AS_CONFED_SEQUENCE and AS_CONFED_SET [RFC5065] MUST NOT be carried in the AS4_PATH attribute of an UPDATE message.

Superseded

No document obsoletes RFC 6793, so its obligations are stated where they were written.