Hi Rob,
> Geoff
> proposed something like this back in 2007, although his proposed
> mechanism was a bit more complicated than I think we'd really need for
> this threat.
I dug out the original exchange from 3 June 2007 and I think you were
proposing some complications to the mechanism at the time....
"1) RobK is correct that the msg_ref checking algorithm as now
specified is more complicated than it needs to be. This is at
least partly my fault, for not having backed us fully out of an
interim conversation in which we were thinking about just using CMS
timestamps for replay protection and dropping msg_ref entirely."
and on the 5th June:
"1) On the replay protection thing: Randy and I have been talking to
Steve Bellovin, and while we haven't quite converged yet it looks
like the simplest answer is to follow RobK's earlier suggestion:
just make the msg_ref a monotonically increasing integer, no CMS
timestamp required, no reset mechanism required, done, full stop.
The likely implementation would be to generate the msg_ref value
from a clock on the sender side, eg, nanoseconds since epoch, but
it really doesn't matter so long as it's monotonically increasing.
The CMS timestamp doesn't isn't fine enough for this, and combining
CMS timestamp with an additional value has timing screws, so let's
just keep this simple and go with the counter."
Steve Bellovin's comments at the time (6th June) were:
"The whole point of something that's purely clock-driven is to avoid the
need for non-volatile client state. We're talking about secured
objects, rather than secured transmission, which means that things like
nonces are very much harder to use. (Exception: we probably could use
hash chains, though I haven't worked this out in detail. Apart from
complexity, see your local IPR lawyer.)
"The point where I currently disagree with Rob and Randy is on the
granularity of the timer. Whatever granularity is chosen bounds the
maximum signing rate. Thus, if you use a 1-second clock, you can't
sign more than 1 object/sec. (Well, you can cheat and "borrow" from
future seconds, up to the actual clock skew, but that does cut your
margin.) If we go with a nanosecond timer, we're limited to 10^9
objects/sec, ever. I'm not convinced we can predict the future well
enough to know that that's reasonable, so I've suggested that the spec
support fractional seconds -- we can always extend the number of
significant digits to the right of the radix point without a protocol
change.
"That said, I think that a fixed-granularity timer is fine if someone
will do the quantitative analysis to show what the bound should be. I
don't know the subject area quite well enough to do that, I suspect."
I haven't looked further to see where it got to but the high order bits
for me from from that exchange appears to be that there is a timer
granularity issue that appears to affect the maximum message rate.
Geoff
_______________________________________________
sidr mailing list
[email protected]
https://www.ietf.org/mailman/listinfo/sidr