Make Java implementation more idiomatic

README.md

@@ -11,7 +11,7 @@ This API implements [Biscuit 2.0](https://www.biscuitsec.org/blog/biscuit-2-0/).
 
 ## Usage
 
-```java
+```xml
 <!-- https://mvnrepository.com/artifact/org.biscuitsec/biscuit -->
 <dependency>
     <groupId>org.biscuitsec</groupId>
@@ -25,7 +25,7 @@ This API implements [Biscuit 2.0](https://www.biscuitsec.org/blog/biscuit-2-0/).
 ### Requirements
 
 * JDK v11
-* the Protobuf compiler command `protoc` v3+ is required in `$PATH`.
+* The Protobuf compiler binary `protoc` v3+ is required in `$PATH`.
 
 ### Build
 

src/main/java/org/biscuitsec/biscuit/crypto/KeyDelegate.java

@@ -10,5 +10,5 @@
  * Tokens can carry a root key id, that can be used to indicate which key will verify it.
  */
 public interface KeyDelegate {
-    public Option<PublicKey> root_key(Option<Integer> key_id);
+    Option<PublicKey> rootKey(Option<Integer> keyId);
 }

src/main/java/org/biscuitsec/biscuit/crypto/KeyPair.java

@@ -4,10 +4,13 @@
 import biscuit.format.schema.Schema;
 import biscuit.format.schema.Schema.PublicKey.Algorithm;
 import net.i2p.crypto.eddsa.EdDSAEngine;
-import org.biscuitsec.biscuit.token.builder.Utils;
 import net.i2p.crypto.eddsa.EdDSAPrivateKey;
 import net.i2p.crypto.eddsa.EdDSAPublicKey;
-import net.i2p.crypto.eddsa.spec.*;
+import net.i2p.crypto.eddsa.spec.EdDSANamedCurveSpec;
+import net.i2p.crypto.eddsa.spec.EdDSANamedCurveTable;
+import net.i2p.crypto.eddsa.spec.EdDSAPrivateKeySpec;
+import net.i2p.crypto.eddsa.spec.EdDSAPublicKeySpec;
+import org.biscuitsec.biscuit.token.builder.Utils;
 
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
@@ -18,12 +21,9 @@
  * Private and public key
  */
 public final class KeyPair {
-    public final EdDSAPrivateKey private_key;
-    public final EdDSAPublicKey public_key;
+    public final EdDSAPrivateKey privateKey;
+    public final EdDSAPublicKey publicKey;
 
-    private static final int ED25519_PUBLIC_KEYSIZE = 32;
-    private static final int ED25519_PRIVATE_KEYSIZE = 64;
-    private static final int ED25519_SEED_SIZE = 32;
     public static final EdDSANamedCurveSpec ed25519 = EdDSANamedCurveTable.getByName(EdDSANamedCurveTable.ED_25519);
 
     public KeyPair() {
@@ -40,8 +40,8 @@ public KeyPair(final SecureRandom rng) {
         EdDSAPublicKeySpec pubKeySpec = new EdDSAPublicKeySpec(privKey.getA(), ed25519);
         EdDSAPublicKey pubKey = new EdDSAPublicKey(pubKeySpec);
 
-        this.private_key = privKey;
-        this.public_key = pubKey;
+        this.privateKey = privKey;
+        this.publicKey = pubKey;
     }
 
     public static KeyPair generate(Algorithm algorithm) {
@@ -65,7 +65,7 @@ public static Signature generateSignature(Algorithm algorithm) throws NoSuchAlgo
     }
 
     public byte[] toBytes() {
-        return this.private_key.getSeed();
+        return this.privateKey.getSeed();
     }
 
     public KeyPair(byte[] b) {
@@ -75,8 +75,8 @@ public KeyPair(byte[] b) {
         EdDSAPublicKeySpec pubKeySpec = new EdDSAPublicKeySpec(privKey.getA(), ed25519);
         EdDSAPublicKey pubKey = new EdDSAPublicKey(pubKeySpec);
 
-        this.private_key = privKey;
-        this.public_key = pubKey;
+        this.privateKey = privKey;
+        this.publicKey = pubKey;
     }
 
     public String toHex() {
@@ -92,15 +92,15 @@ public KeyPair(String hex) {
         EdDSAPublicKeySpec pubKeySpec = new EdDSAPublicKeySpec(privKey.getA(), ed25519);
         EdDSAPublicKey pubKey = new EdDSAPublicKey(pubKeySpec);
 
-        this.private_key = privKey;
-        this.public_key = pubKey;
+        this.privateKey = privKey;
+        this.publicKey = pubKey;
     }
 
     public static Signature getSignature() throws NoSuchAlgorithmException {
         return new EdDSAEngine(MessageDigest.getInstance(ed25519.getHashAlgorithm()));
     }
 
-    public PublicKey public_key() {
-        return new PublicKey(Schema.PublicKey.Algorithm.Ed25519, this.public_key);
+    public PublicKey publicKey() {
+        return new PublicKey(Schema.PublicKey.Algorithm.Ed25519, this.publicKey);
     }
 }

src/main/java/org/biscuitsec/biscuit/crypto/PublicKey.java

@@ -15,8 +15,8 @@ public class PublicKey {
     public final EdDSAPublicKey key;
     public final Algorithm algorithm;
 
-    public PublicKey(Algorithm algorithm, EdDSAPublicKey public_key) {
-        this.key = public_key;
+    public PublicKey(Algorithm algorithm, EdDSAPublicKey publicKey) {
+        this.key = publicKey;
         this.algorithm = algorithm;
     }
 

src/main/java/org/biscuitsec/biscuit/crypto/Token.java

@@ -1,100 +1,106 @@
 package org.biscuitsec.biscuit.crypto;
 
-import org.biscuitsec.biscuit.error.Error;
 import io.vavr.control.Either;
 import net.i2p.crypto.eddsa.EdDSAEngine;
+import org.biscuitsec.biscuit.error.Error;
+import org.biscuitsec.biscuit.error.Error.FormatError.Signature.InvalidSignature;
 
 import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
 import java.security.*;
 import java.util.ArrayList;
 
 import static io.vavr.API.Left;
 import static io.vavr.API.Right;
+import static java.nio.ByteOrder.LITTLE_ENDIAN;
 
-class Token {
+final class Token {
     public final ArrayList<byte[]> blocks;
     public final ArrayList<PublicKey> keys;
     public final ArrayList<byte[]> signatures;
     public final KeyPair next;
 
-    public Token(KeyPair rootKeyPair, byte[] message, KeyPair next) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
+    public Token(KeyPair rootKeyPair, byte[] message, KeyPair next)
+            throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
         Signature sgr = new EdDSAEngine(MessageDigest.getInstance(KeyPair.ed25519.getHashAlgorithm()));
-        ByteBuffer algo_buf = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN);
-        algo_buf.putInt(Integer.valueOf(next.public_key().algorithm.getNumber()));
-        algo_buf.flip();
-        sgr.initSign(rootKeyPair.private_key);
+        ByteBuffer algoBuf = ByteBuffer.allocate(4).order(LITTLE_ENDIAN);
+        algoBuf.putInt(next.publicKey().algorithm.getNumber());
+        algoBuf.flip();
+        sgr.initSign(rootKeyPair.privateKey);
         sgr.update(message);
-        sgr.update(algo_buf);
-        sgr.update(next.public_key().toBytes());
+        sgr.update(algoBuf);
+        sgr.update(next.publicKey().toBytes());
 
         byte[] signature = sgr.sign();
 
         this.blocks = new ArrayList<>();
         this.blocks.add(message);
         this.keys = new ArrayList<>();
-        this.keys.add(next.public_key());
+        this.keys.add(next.publicKey());
         this.signatures = new ArrayList<>();
         this.signatures.add(signature);
         this.next = next;
     }
 
-    public Token(final ArrayList<byte[]> blocks, final ArrayList<PublicKey> keys, final ArrayList<byte[]> signatures,
+    public Token(final ArrayList<byte[]> blocks,
+                 final ArrayList<PublicKey> keys,
+                 final ArrayList<byte[]> signatures,
                  final KeyPair next) {
         this.signatures = signatures;
         this.blocks = blocks;
         this.keys = keys;
         this.next = next;
     }
 
-    public Token append(KeyPair keyPair, byte[] message) throws NoSuchAlgorithmException, SignatureException, InvalidKeyException {
+    public Token append(KeyPair keyPair, byte[] message)
+            throws NoSuchAlgorithmException, SignatureException, InvalidKeyException {
         Signature sgr = new EdDSAEngine(MessageDigest.getInstance(KeyPair.ed25519.getHashAlgorithm()));
-        sgr.initSign(this.next.private_key);
-        ByteBuffer algo_buf = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN);
-        algo_buf.putInt(Integer.valueOf(next.public_key().algorithm.getNumber()));
-        algo_buf.flip();
+        sgr.initSign(this.next.privateKey);
+        ByteBuffer algoBuf = ByteBuffer.allocate(4).order(LITTLE_ENDIAN);
+        algoBuf.putInt(next.publicKey().algorithm.getNumber());
+        algoBuf.flip();
         sgr.update(message);
-        sgr.update(algo_buf);
-        sgr.update(keyPair.public_key().toBytes());
+        sgr.update(algoBuf);
+        sgr.update(keyPair.publicKey().toBytes());
 
         byte[] signature = sgr.sign();
 
         Token token = new Token(this.blocks, this.keys, this.signatures, keyPair);
         token.blocks.add(message);
         token.signatures.add(signature);
-        token.keys.add(keyPair.public_key());
+        token.keys.add(keyPair.publicKey());
 
         return token;
     }
 
     // FIXME: rust version returns a Result<(), error::Signature>
-    public Either<Error, Void> verify(PublicKey root) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
-        PublicKey current_key = root;
-        for(int i = 0; i < this.blocks.size(); i++) {
+    public Either<Error, Void> verify(PublicKey root)
+            throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
+        PublicKey currentKey = root;
+        for (int i = 0; i < this.blocks.size(); i++) {
             byte[] block = this.blocks.get(i);
-            PublicKey next_key  = this.keys.get(i);
+            PublicKey nextKey = this.keys.get(i);
             byte[] signature = this.signatures.get(i);
 
             Signature sgr = new EdDSAEngine(MessageDigest.getInstance(KeyPair.ed25519.getHashAlgorithm()));
-            ByteBuffer algo_buf = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN);
-            algo_buf.putInt(Integer.valueOf(next.public_key().algorithm.getNumber()));
-            algo_buf.flip();
-            sgr.initVerify(current_key.key);
+            ByteBuffer algoBuf = ByteBuffer.allocate(4).order(LITTLE_ENDIAN);
+            algoBuf.putInt(next.publicKey().algorithm.getNumber());
+            algoBuf.flip();
+            sgr.initVerify(currentKey.key);
             sgr.update(block);
-            sgr.update(algo_buf);
-            sgr.update(next_key.toBytes());
+            sgr.update(algoBuf);
+            sgr.update(nextKey.toBytes());
 
             if (sgr.verify(signature)) {
-                current_key = next_key;
+                currentKey = nextKey;
             } else {
-                return Left(new Error.FormatError.Signature.InvalidSignature("signature error: Verification equation was not satisfied"));
+                return Left(new InvalidSignature("signature error: Verification equation was not satisfied"));
             }
         }
 
-        if(this.next.public_key == current_key.key) {
+        if (this.next.publicKey == currentKey.key) {
             return Right(null);
         } else {
-            return Left(new Error.FormatError.Signature.InvalidSignature("signature error: Verification equation was not satisfied"));
+            return Left(new InvalidSignature("signature error: Verification equation was not satisfied"));
         }
     }
 }

src/main/java/org/biscuitsec/biscuit/crypto/TokenSignature.java

@@ -20,7 +20,7 @@ public TokenSignature(final SecureRandom rng, KeyPair keypair, byte[] message) {
         ArrayList<RistrettoElement> l = new ArrayList<>();
         l.add(A);
         Scalar d = hash_points(l);
-        Scalar e = hash_message(keypair.public_key, message);
+        Scalar e = hash_message(keypair.publicKey, message);
 
         Scalar z = r.multiply(d).subtract(e.multiply(keypair.private_key));
 
@@ -43,7 +43,7 @@ public TokenSignature sign(final SecureRandom rng, KeyPair keypair, byte[] messa
         ArrayList<RistrettoElement> l = new ArrayList<>();
         l.add(A);
         Scalar d = hash_points(l);
-        Scalar e = hash_message(keypair.public_key, message);
+        Scalar e = hash_message(keypair.publicKey, message);
 
         Scalar z = r.multiply(d).subtract(e.multiply(keypair.private_key));
 

src/main/java/org/biscuitsec/biscuit/datalog/Check.java

@@ -1,8 +1,8 @@
 package org.biscuitsec.biscuit.datalog;
 
 import biscuit.format.schema.Schema;
-import org.biscuitsec.biscuit.error.Error;
 import io.vavr.control.Either;
+import org.biscuitsec.biscuit.error.Error;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -45,8 +45,8 @@ public Schema.CheckV2 serialize() {
                 break;
         }
 
-        for(int i = 0; i < this.queries.size(); i++) {
-            b.addQueries(this.queries.get(i).serialize());
+        for (Rule query : this.queries) {
+            b.addQueries(query.serialize());
         }
 
         return b.build();
@@ -57,20 +57,18 @@ static public Either<Error.FormatError, Check> deserializeV2(Schema.CheckV2 chec
 
         Kind kind;
         switch (check.getKind()) {
-            case One:
-                kind = Kind.One;
-                break;
             case All:
                 kind = Kind.All;
                 break;
+            case One:
             default:
                 kind = Kind.One;
                 break;
         }
 
-        for (Schema.RuleV2 query: check.getQueriesList()) {
+        for (Schema.RuleV2 query : check.getQueriesList()) {
             Either<Error.FormatError, Rule> res = Rule.deserializeV2(query);
-            if(res.isLeft()) {
+            if (res.isLeft()) {
                 Error.FormatError e = res.getLeft();
                 return Left(e);
             } else {