Use Tink utility to turn BigInteger to bytes.

Replace the custom implementation of positive BigInteger conversion to a
padded byte array with the utility provided by Tink.

Author: AndrewScull

src/com/google/cose/Ec2SigningKey.java

@@ -28,18 +28,17 @@
 import com.google.cose.utils.Headers;
 import com.google.crypto.tink.subtle.EcdsaSignJce;
 import com.google.crypto.tink.subtle.EcdsaVerifyJce;
+import com.google.crypto.tink.subtle.EllipticCurves;
+import com.google.crypto.tink.subtle.EllipticCurves.CurveType;
 import com.google.crypto.tink.subtle.EllipticCurves.EcdsaEncoding;
 import com.google.crypto.tink.subtle.Enums.HashType;
+import com.google.crypto.tink.subtle.SubtleUtil;
 import java.math.BigInteger;
 import java.security.GeneralSecurityException;
-import java.security.InvalidAlgorithmParameterException;
 import java.security.KeyPair;
-import java.security.KeyPairGenerator;
-import java.security.NoSuchAlgorithmException;
 import java.security.PublicKey;
 import java.security.interfaces.ECPrivateKey;
 import java.security.interfaces.ECPublicKey;
-import java.security.spec.ECGenParameterSpec;
 import java.security.spec.ECPoint;
 
 /** Implements EC2 COSE_Key spec for signing purposes. */
@@ -119,69 +118,42 @@ public ECPublicKey getPublicKey() {
     return (ECPublicKey) this.keyPair.getPublic();
   }
 
-  // Big endian: Do not reuse for little endian encodings
-  private static byte[] arrayFromBigNum(BigInteger num, int keySize)
-      throws IllegalArgumentException {
-    // Roundup arithmetic from bits to bytes.
-    byte[] keyBytes = new byte[(keySize + 7) / 8];
-    byte[] keyBytes2 = num.toByteArray();
-    if (keyBytes.length == keyBytes2.length) {
-      return keyBytes2;
-    }
-    if (keyBytes2.length > keyBytes.length) {
-      // There should be no more than one padding(0) byte, invalid key otherwise.
-      if (keyBytes2.length - keyBytes.length > 1 && keyBytes2[0] != 0) {
-        throw new IllegalArgumentException();
-      }
-      System.arraycopy(keyBytes2, keyBytes2.length - keyBytes.length, keyBytes, 0, keyBytes.length);
-    } else {
-      System.arraycopy(
-          keyBytes2, 0, keyBytes, keyBytes.length - keyBytes2.length, keyBytes2.length);
-    }
-    return keyBytes;
-  }
-
   /**
    * Generates a COSE formatted Ec2 signing key given a specific algorithm. The selected key size is
    * chosen based on section 6.2.1 of RFC 5656
    */
   public static Ec2SigningKey generateKey(Algorithm algorithm) throws CborException, CoseException {
-    KeyPair keyPair;
-    int keySize;
     int header;
-    String curveName;
-
+    CurveType curveType;
     switch (algorithm) {
       case SIGNING_ALGORITHM_ECDSA_SHA_256:
-        curveName = "secp256r1";
-        keySize = 256;
+        curveType = CurveType.NIST_P256;
         header = Headers.CURVE_EC2_P256;
         break;
 
       case SIGNING_ALGORITHM_ECDSA_SHA_384:
-        curveName = "secp384r1";
-        keySize = 384;
+        curveType = CurveType.NIST_P384;
         header = Headers.CURVE_EC2_P384;
         break;
 
       case SIGNING_ALGORITHM_ECDSA_SHA_512:
-        curveName = "secp521r1";
-        keySize = 521;
+        curveType = CurveType.NIST_P521;
         header = Headers.CURVE_EC2_P521;
         break;
 
       default:
         throw new CoseException("Unsupported algorithm curve: " + algorithm.getJavaAlgorithmId());
     }
+
+    KeyPair keyPair;
     try {
-      ECGenParameterSpec paramSpec = new ECGenParameterSpec(curveName);
-      KeyPairGenerator gen = KeyPairGenerator.getInstance("EC");
-      gen.initialize(paramSpec);
-      keyPair = gen.genKeyPair();
+      keyPair = EllipticCurves.generateKeyPair(curveType);
 
       ECPoint pubPoint = ((ECPublicKey) keyPair.getPublic()).getW();
-      byte[] x = arrayFromBigNum(pubPoint.getAffineX(), keySize);
-      byte[] y = arrayFromBigNum(pubPoint.getAffineY(), keySize);
+      int keySize =
+          EllipticCurves.fieldSizeInBytes(EllipticCurves.getCurveSpec(curveType).getCurve());
+      byte[] x = SubtleUtil.integer2Bytes(pubPoint.getAffineX(), keySize);
+      byte[] y = SubtleUtil.integer2Bytes(pubPoint.getAffineY(), keySize);
 
       byte[] privEncodedKey = keyPair.getPrivate().getEncoded();
 
@@ -193,10 +165,8 @@ public static Ec2SigningKey generateKey(Algorithm algorithm) throws CborExceptio
           .withCurve(header)
           .withAlgorithm(algorithm)
           .build();
-    } catch (NoSuchAlgorithmException e) {
-      throw new CoseException("No provider for algorithm: " + algorithm.getJavaAlgorithmId(), e);
-    } catch (InvalidAlgorithmParameterException e) {
-      throw new CoseException("The curve is not supported: " + algorithm.getJavaAlgorithmId(), e);
+    } catch (GeneralSecurityException e) {
+      throw new CoseException("Failed generating key.", e);
     } catch (IllegalArgumentException e) {
       throw new CoseException(
           "Invalid Coordinates generated for: " + algorithm.getJavaAlgorithmId(), e);