IETF draft revises line-ending rules for end-to-end email signatures
News

17 November 2026 | Australia/Sydney
The IETF's MAILMAINT working group has published draft revision -03 of Unobtrusive End-to-End Email Signatures, changing which line-ending bytes implementations should normalize. Section 5.5 now specifies that bare LF must become CRLF, while bare CR should normally remain untouched. The change affects canonicalization before both signing and verification.
The revision, draft-ietf-mailmaint-unobtrusive-signatures-03, was officially published on 15 November 2026 at 15:30:09 UTC, recorded as Datatracker publication event 1245504. That was 16 November in Sydney. I regard this as a material implementation change because different treatment of bare CR changes the bytes presented to the cryptographic operation.
This is an active Internet-Draft, not a final RFC or current production requirement. Its requirements describe a proposed format that remains subject to change. Publication introduces no provider mandate, rollout, enforcement deadline, or final approval.
What changes in section 5.5
In revision -02, Section 5.5 used a general instruction to convert message line endings to CRLF. Revision -03 replaces that broad wording with separate treatment for bare linefeed and bare carriage return characters. This is more specific than an instruction to normalize every newline convention.
LF is the byte 0x0A. CR is 0x0D. CRLF is the two-byte sequence 0x0D 0x0A. A bare LF lacks a preceding CR; a bare CR lacks a following LF. Under the proposed revision, those isolated bytes have different treatment.
|
|
|
|---|---|---|
Bare LF | Generic CRLF rule | MUST convert |
Bare CR | Generic CRLF rule | SHOULD NOT modify |
Existing CRLF | CRLF form | Keep CRLF |
Proposed line-ending behavior in draft -03
The distinction between MUST and SHOULD NOT matters within the draft. LF conversion is mandatory for an implementation following -03. Preserving bare CR is a strong recommendation with room for a justified exception. Treating that exception as permission for unconditional CR conversion defeats the intended distinction.
The proposal covers signed-only email
The proposed structure carries end-to-end OpenPGP or CMS signatures, including CMS signatures used with S/MIME, in cleartext MIME email. Its purpose is to let older clients display the message normally without needing to understand the signature structure. Rendering compatibility does not mean an older client verifies the signature.
The format uses an outer multipart/mixed container with one Protected Part. Leading Sig header fields carry signature information. The signed material is the formatted Protected Part with those leading signature fields removed. This is a message-level signature workflow between the sender and recipient.
Signed-only cleartext
Within the proposal's scope. A valid end-to-end signature supplies evidence about authenticity and integrity of the protected material. The message remains readable without decryption.
Signed and encrypted
Excluded by the draft. Messages that are both signed and encrypted MUST NOT use this proposed structure. The revision adds no confidentiality and changes no encryption requirement.
Why a single carriage return matters
Signatures depend on bytes, even when two messages look identical on screen. Canonicalization creates the byte sequence that the signer signs and the recipient verifies. If one implementation preserves an isolated CR and another converts it to CRLF, their cryptographic inputs differ.
That is why I would not infer correctness from the displayed body. A viewer can show both variants as equivalent spacing or line breaks while the signing library hashes different octets. The useful diagnostic is a byte dump at the boundary between canonicalization and the cryptographic API, captured on both endpoints for the same test message.
For example, imagine a formatted Protected Part whose body contains A, a bare CR, B, a bare LF, and C, followed by two CRLF sequences. The body-only illustration below assumes the draft's recommended preservation of bare CR. The final step applies the existing trailing-empty-line rule.
Illustrative body bytes under draft -03text
Input body bytes (hex): 41 0D 42 0A 43 0D 0A 0D 0A After line-ending normalization: 41 0D 42 0D 0A 43 0D 0A 0D 0A After trailing-empty-line normalization: 41 0D 42 0D 0A 43 0D 0A
The 0D between A and B remains. The LF after B gains a preceding CR. The extra empty line at the end disappears. A generic newline conversion routine that also expands the first 0D produces different bytes. With the same key and message, that mismatch can cause verification failure.
This is an implementation risk inferred from the changed byte-handling rules, not a reported active exploit or incident. I would investigate the canonical byte sequences first when two draft implementations disagree, before assuming a problem with their cryptographic algorithms or keys.
Which normalization rules are unchanged
Revision -03 retains the rule that trailing empty body lines are removed and the body ends with one CRLF. An empty line means a line with no content after its terminator is removed. A line containing spaces is not an empty line under that definition.
An empty or missing body still canonicalizes to one CRLF, a two-byte result. Section 5.6 also retains the recommendation for binary OpenPGP signature type 0x00. Neither the empty-body behavior nor the binary-mode recommendation is new in this revision.
A shared technique does not change DKIM
The retained trailing-body normalization resembles DKIM simple body canonicalization. That resemblance does not make this proposal DKIM2, modify current DKIM, or extend its scope to domain authentication.
Appendix B.1 attributes the line-ending update to emerging consensus in openpgp-wg. It also records added guidance for registry experts. That registry work is a secondary revision item; the immediate interoperability question is whether implementations calculate signatures over matching bytes.
What draft implementers should test
Client developers, signature-library maintainers and interoperability testers implementing -03 are the audience for this change. Compare Section 5.5 in -02 with the full -03 draft, then trace how the formatted Protected Part becomes the byte stream passed into each cryptographic operation.
I would run each fixture through both signing and verification, including tests between separate implementations. Record expected canonical bytes as well as the verification result. A successful round trip inside one library does not establish interoperability if both paths share the same incorrect conversion.
- Bare LF. Check that isolated 0x0A becomes CRLF before signing and before verification.
- Bare CR. Check that isolated 0x0D survives both paths. Document any justified exception to SHOULD NOT.
- Existing CRLF. Check that valid pairs remain pairs without acquiring another CR.
- Mixed endings. Combine bare LF, bare CR and CRLF in one fixture and compare exact canonical output.
- Body endings. Test multiple trailing empty lines, a missing final terminator, and an empty or missing body. Keep whitespace-only lines distinct.
Preserve fixture bytes during test loading. Text-mode file handling or an editor can normalize line endings before the implementation sees them, hiding the very case under examination. Repeat the applicable fixtures for OpenPGP and CMS paths, because Section 5.5 covers the common canonicalization step.
Also check where MIME serialization occurs. Signing an object and then serializing it differently for transport can introduce another mismatch, even with the LF rule implemented correctly. The draft's sequence operates on the formatted Protected Part, so a test that starts with an already normalized string skips an important integration boundary. Keep the message extraction step under test too, so the verifier does not accidentally include the signature fields or MIME boundary.
What production email senders need to know
This draft calls for no DNS record change, DMARC policy adjustment, or key rotation by ordinary production senders. End-to-end signatures protect message material between endpoints. DKIM is a domain signature; SPF checks whether a sending host is authorized for an envelope identity. DMARC evaluates domain correspondence with the visible From address using SPF or DKIM results.
Those mechanisms answer different questions. A DKIM pass does not prove that an unobtrusive end-to-end signature verifies. Likewise, a mismatch in draft-specific canonicalization does not by itself establish an SPF or DMARC configuration problem.
For separate production authentication investigations, our Suped email tester examines a real message, and the DKIM checker validates a selector's DNS record. Those checks do not validate this proposed signature format. Draft conformance needs byte-level fixtures and end-to-end interoperability tests.
Keep implementation evidence with the draft version
For teams implementing this work in progress, I would label test results with the exact draft revision and retain the canonical bytes that produced each signature. Include the bare-CR preservation decision in the test record. That gives another implementation enough information to reproduce a mismatch and gives maintainers a concrete comparison when a later draft changes the proposal.
Frequency asked questions
No. It is an active MAILMAINT Internet-Draft published on 15 November 2026. Its normative language describes proposed implementation behavior. It is not a final RFC, final approval, or a production enforcement requirement.
Draft -03 recommends preserving bare CR through SHOULD NOT wording. Bare LF conversion to CRLF is mandatory within the proposal. A departure from the bare-CR recommendation needs a justified exception and interoperability testing.
No. The proposal concerns signed-only cleartext messages using OpenPGP or CMS signatures. It explicitly excludes signed-and-encrypted messages and adds no confidentiality.
No. DMARC reports concern domain authentication outcomes, not verification of this proposed end-to-end signature format. Confirming draft behavior requires inspecting canonical bytes and testing the signing and verification paths.

