On 8/10/2017 6:46 PM, Michael StJohns wrote:
On 8/10/2017 7:36 PM, Xuelei Fan wrote:
Hi Michael,
Good points! See comments inlines.
On 8/10/2017 3:20 PM, Michael StJohns wrote:
Instead of converting, I was thinking about mapping. E.g. Montgomery
A and B matches the A and B of the curve. But the "x" of the
Montgomery point is just the "x" of the ECPoint with the "y" left as
null. For Edwards, it looks like you would map "d" to A. For [3] I'd
map "r" to A. I'd leave B as null for both- no reason to throw an
unsupported exception as the code generally has a clue about what
types of keys they're dealing with (or we provide a marker so they
can figure it out).
The conversion in and out for points is a conversion from little
endian to big endian and vice versa, but that only has to be done if
you're importing or exporting a parameter set and that's an
implementation issue not an API issue.
Basically, all the math is BigIntegers under the hood. The
curve25519 RFC specifies an implementation that's little endian, but
the actual math is just math and things like the public key is really
just a BigInteger.
Old code would just continue to work - since it would not be using
the new curves. New code would have to look for the curve type
marker (e.g. the ECField) if there was the possibility of confusion.
I understand your points. The mapping may be confusing to application
developers, but no problem for new codes if following the new coding
guideline. I'm not very sure of the old code, for similar reason to
use the converting solution.
For example, an Edwards curve form of the SubjectPublicKeyInfo field
in a X.509 cert is parsed as X509EncodedKeySpec, and "EC" KeyFactory
is used to generate the ECPublicKey. The algorithm name of the
ECPublicKey instance is "EC", and the parameter is an instance of
ECParameterSpec. Somehow, the ECPublicKey leave the key generation
environment, and the curve OID is unknown in the new environment. Then
the public could be used improperly. In the past, it's fine as the
only supported form is Weierstrass form, there is no need to tell the
curve forms in a crypto implementation. However, when a new form is
introduces, identify the EC form of a key is an essential part for the
following crypto operations. Old providers or codes may not be able to
tell the form, as may result in compatibility issues.
I don't think any of this is an issue. An X509EncodedKeySpec for
either type of key has a id-ecPublicKey OID identifying it (embedded in
the SubjectPublicKeyInfo encoding). In the key body, there's the
EcpkParameters structure which is a 'namedCurve' which consists of an
OID. The curve OIDs for 25519 and 447 are different than any of the
Weiserstrass keys. When the KeyFactory factory implementation reads
the byte stream its going to build a JCA ECPublicKey that matches the
OID AND that's a concrete ECPublicKey class of the key factory provider.
If the factory implementation doesn't understand the oid, then the
provider throws an error. I forget which one.
> The concrete class for the ECPublic key is specific to the provider.
Some providers may support the new key forms, some may not. There's no
guarantee (and there never has been a guarantee) that an ECPublic key
from one provider can be used with another provider (e.g. PKCS11
provider vs a software provider) - you have to convert the key into a
keyspec and then run the factory method on it.
I'm not sure of it. JDK is a multiple providers framework. A key
generated in one provider may work in another provider, as if the
conversion of the key works. It's not rare that the public key is
parsed by one provider, and used in another provider. For some cases,
we don't have conversion problem in the past as the key spec is clear.
But for some other cases, we do have problems. But if a case works in
the past, we don't want to break it; otherwise, it might be a kind of
compatibility issues.
As we discussed, there are multiple forms of EC curves. EC curves form
is an essential part of a EC key for following operation. As if the EC
curves form is unknown, there are potential problems. When a old
provider try to use a new provider generated keys for a new forms,
problems happens. This actually can be avoid if the old provider does
not support this algorithm. The "EC" name is too general to accept new
forms.
So I don't think there's anything we have to worry about here - no
violation of the API contract as far as I can tell.
(As a more complete example - consider what happens when you have an F2M
EC provider and an Fp EC provider both generating public keys and
encoding them. Neither provider can decode the other's encoded key
because they don't have the OIDs and the parameter sets).
If we define all of the forms at the same time, a provider would follow
the specs, and no compatibility issues. However, if we add something
new later, and if the old one does not compatible with the new one,
compatibility issues come.
For example,
// Provider A supports KeyFactory
KeyFactory kf = KeyFactory.getInstance("EC");
ECPublicKey pubECKey = ... // use the KF above, new form key.
// Provider A and B support "EC" signature, but B has the priority.
// Provider B is an old provider.
Signature sign = Signature.getInstacne("EC"); // Use provider B.
sign.initVerify(pubECkey); // the verification would fail
Suppose provider A and B are all good providers, the code above runs
into problems. The above code works with two old providers, and works
with two new providers, but may not work if mixing old and new
providers. However, it is expected to work as one of the providers
support the required features.
Xuelei
