Re: [Ntp] NTS4UPTP Rev 03 - Formal request for WG adoption

Daniel Franke <> Thu, 27 May 2021 16:44 UTC

Return-Path: <>
Received: from localhost (localhost []) by (Postfix) with ESMTP id 416093A0857 for <>; Thu, 27 May 2021 09:44:02 -0700 (PDT)
X-Virus-Scanned: amavisd-new at
X-Spam-Flag: NO
X-Spam-Score: -2.098
X-Spam-Status: No, score=-2.098 tagged_above=-999 required=5 tests=[BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, URIBL_BLOCKED=0.001] autolearn=ham autolearn_force=no
Authentication-Results: (amavisd-new); dkim=pass (2048-bit key)
Received: from ([]) by localhost ( []) (amavisd-new, port 10024) with ESMTP id 9sF69JvyRCC4 for <>; Thu, 27 May 2021 09:43:57 -0700 (PDT)
Received: from ( [IPv6:2607:f8b0:4864:20::102c]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by (Postfix) with ESMTPS id A2DFB3A084D for <>; Thu, 27 May 2021 09:43:57 -0700 (PDT)
Received: by with SMTP id o17-20020a17090a9f91b029015cef5b3c50so2719589pjp.4 for <>; Thu, 27 May 2021 09:43:57 -0700 (PDT)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc:content-transfer-encoding; bh=k1arRy1MiKvaIAV9PrmjFUYGluvtIgK6WW25sdY1f2U=; b=etkHvh823dGtR8osWLGF4zZBltsQ9UsNn05pxJF9WyeX7rNLNtWvaEHfEJ6ISLj3ml NgwUOq5ZfZ/99NxWbIk4ICqq2KObbYLJxh4/pBVAFv/iMp9Gf6FLFnWcVp8p8JKPP8py W5oaDq4mXrHB+1n5z37w4H+py3WusphSMJXp76zXIlLdz0s0lKPBBOBirSQ53BOpQ2OF WxzWEX+GneOkJOWz8Zz4r34aIhYMqKA+EWPKO383qV5c1O9Q6VQTpc2QXoLwTxYHyEmX I0z768J8eJr/ad8MjPYiyGTGAXimxYXBf+4WgfcsBobt11ICnXtXgRfFegdUbQgNQgyz Ldug==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=k1arRy1MiKvaIAV9PrmjFUYGluvtIgK6WW25sdY1f2U=; b=jTZSg7FsPU+CVlBTCXKIkoXuijeoVJwNiG2RUg58LZuKW8XB+ZiHDKW/ZcDRjdZXkn du79QbXMmny3zrN51jLkPbW9Zecp3VlIKxhBu785LVoh6jvmmG9Zz8h6HWs+yBkS6mz4 u1lmnyLat4byy542AphgoMe1p1DEWVY84uDXJM+VATA/My8w+3ZZrKDB9EG2yg1fxrwc G1aI/oDGXKl1MEFSkb6rypdw7z5cE0nrIfFGGm9vYgul4a7Mvu5b9bHgdT4mie0mwTL4 4QxQlStXwWiLAtW+2mIXFkffMW/djn91zY+nU49K/HGu2fZMHZToXf4LK1htSel49R9Q jnvQ==
X-Gm-Message-State: AOAM530pIAF8TbIpMHwqEnxceEofhBJ2pH8usbjv8Ut/WKNwNwTAzhyZ Tl6xuf+Ssk1TJFwAx/nQwOMXerjYK9zxG0LsI8c5toGipnE=
X-Google-Smtp-Source: ABdhPJxUOJvYin1/gLusqR+Kv7B3GasArJO7hhVL2aDJTSvjtZY7fe87kFoZKTD2PHtKljl4wa9gjhy0VNTSeAhl8No=
X-Received: by 2002:a17:902:aa8c:b029:fd:86eb:66ca with SMTP id d12-20020a170902aa8cb02900fd86eb66camr4123389plr.41.1622133836530; Thu, 27 May 2021 09:43:56 -0700 (PDT)
MIME-Version: 1.0
References: <> <> <> <> <>
In-Reply-To: <>
From: Daniel Franke <>
Date: Thu, 27 May 2021 12:43:45 -0400
Message-ID: <>
To: Heiko Gerstung <>
Cc: "" <>, Doug Arnold <>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Archived-At: <>
Subject: Re: [Ntp] NTS4UPTP Rev 03 - Formal request for WG adoption
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: <>
List-Unsubscribe: <>, <>
List-Archive: <>
List-Post: <>
List-Help: <>
List-Subscribe: <>, <>
X-List-Received-Date: Thu, 27 May 2021 16:44:02 -0000

On Thu, May 27, 2021 at 11:13 AM Heiko Gerstung
<> wrote:
> I tried to explain that there is a RTT computation taking place, the client simply uses both sync and delay_req/resp messages for this. Maybe Doug can explain this to you in a better way.
> There is a RTT calculation, and a PTP client uses RTT/2 as a correction for the incoming sync messages.

I'm pretty sure I already understand. In the case of both NTP and PTP,
you have a calculation like

theta = ((t2-t1) + (t3-t4))/2

In NTP, there's just one exchange that gives you all four timestamps.
In PTP, you use DELAY_REQ/DELAY_RESP just for t2 and t1, and then you
get t3 and t4 from the SYNC message.
Trying to do without the SYNC message would give you bad results,
because there's no hardware timestamp on DELAY_RESP to give you t3, so
you'd be forced to treat t3 as equal to t2 or t2 plus some assumed
processing delay.

And then your maximum error bounds are ±((t4-t1) - (t3-t2))/2. Err,
okay, I guess that still works out when you do it with separate
messages? (t4-t1) will be big, but so will (t3-t2) so they'll cancel
each other. But by "works out" I still mean "works out to ±half-RTT".
It is not possible to improve on this.

> I try again to explain what I believe you are missing here. Any application that requires sync has a minimum requirement for synchronization, i.e. any time error greater than this limit is going to affect the application, in most cases it completely avoids that the application can be used anymore. In some cases it degrades the application to a point where financial damages are negatively impacting the owner/operator of that application. And in some cases it can cause physical harm to human beings (think of a power grid protection system which cannot continue to work without very tight synchronization and therefore might trip a circuit breaker as a precaution, creating a blackout for hundreds or thousands of households in the process). For those applications, there is no reduced sync performance under "adversarial conditions", the synchronization solution either delivers the required minimum accuracy or not. Most if not all applications that use PTP require a sync performance of a microsecond or less, that is the reason why they deployed PTP and not NTP.  NTP accuracy is not good enough for these people and therefore it does not help at all to introduce a concept which considers a degraded sync performance under adversarial conditions.

People who have these kinds of requirements *must* physically secure
the network links they use for time synchronization. NTS cannot
provide anything that will help them. My proposal won't do what they
need, and neither will yours. I know you have customers clamouring for
a solution and that you want to give them one, but it is simply. not.

> OK, you just changed your principal reason why you object to adopting the draft after it seems I convinced you that the initial reasons why you object adoption of the draft do not exist. I am a little bit at a loss here, because I do not know if I can convince you *at all* to support adoption. But anyway, this is too important and I will keep trying ;-) ...

Yes, at first my biggest objection was "this won't work". You've now
offered some clarifications and accepted some corrections that would
allow it to work about as well as my alternative, but still not nearly
as well as you claim it will and not nearly well enough to satisfy the
use cases you've described in the previous quote. And so different
objections rise to the top.

> I am puzzled that your main reason is that you believe this is a lot of work for a lot of people. Three people with a lot of experience in both NTP and PTP already put a lot of work into this draft and tried to reuse as many parts as possible from NTS4NTP to minimize the required work. These three people are willing to continue to work on this draft, and I am sure that others will join. If you personally do not think it is worthwhile, I fully accept that. But I believe you should not speak for others. In addition to that, your new principal reason to object the adoption can be applied to every new standard, especially when it is timing related. For example, you could ahve applied the same reason to NTS4NTP when it first came up as a topic.

Your proposal reuses some parts of NTS4NTP but still involves a lot of
new work, probably including building new silicon. Mine reuses all of
them. NTS4NTP was a lot of work for a lot of benefit, and part of that
benefit is that it gives us a nearly-trivial way to also secure PTP.
Sure, "this is a lot of work for little benefit" is an argument that
can be deployed against any new standard, but sometimes it's true and
sometimes it isn't!

> Nope. There is nothing available *TODAY* that comes even close. You are comparing apples and oranges. The draft offers the same level of protection against cybersecurity threats that are covered by NTS4NTP. It does so by maintaining the full accuracy level of PTP, i.e. sub microsecond time synchronization. An NTP/PTP combo can only protect your time to the accuracy level of NTP. It is not an alternative to what we propose with this draft.

NTS4UPTP does *not* maintain sub-microsecond precision under
adversarial conditions. You are making an impossible claim. I can't
yet tell you exactly where your error in reasoning is, because you
haven't specified the client behavior in enough detail to give me a
stationary target to pick apart. If you'd care to explain exhaustively
what checks and calculations you expect the client to perform, and
what better-than-half-RTT bounds you claim to be achieving, I'll
happily reciprocate with an equally detailed protocol trace that
illustrates how an adversary can mount a delay attack in order to feed
the client time that passes your checks but falls outside your
asserted bounds.

> > If you want to change my mind about this, I suggest you try convincing
> > me that PTP has functions that are auxiliary to time synchronization
> > that still need securing. Can an attacker do harm to an unsecured PTP
> > deployment in ways other than just desynchronizing clocks? DDoS
> > amplification is one example, but that can be solved in a much
> > lighter-weight fashion requiring little or no cryptography.
> I doubt that this is possible with unicast PTP. I kindly ask you to explain how you want to achieve that without a major redesign of the protocol, at which point it would not be PTP anymore.

That's easy. You just need to require the client to prove that it's
actually able to receive traffic at its claimed address before you
send any significant traffic in that direction. You can do this by
sending the client a random or pseudorandom token that it's required
to echo back before you'll send it anything else, and periodically
repeating this challenge to prove that it's still there. You can do
this with no cryptography at all, or with just a little bit by having
the token be a MAC over the client's network address and a timestamp,
computing using a key known only to the server. The advantage of
constructing it this way is that the server doesn't have to hold any
state related to the client until it has already passed the challenge,
because it can recompute the challenge token rather than having to
store it.