Skip to content

Commit 8923fb1

Browse files
KorbikKorbik
authored
Merge pull request #116 from Korbik/java_checkstyle_google_format_migration
Java checkstyle google format migration
2 parents 5950134 + 99ae668 commit 8923fb1

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

74 files changed

+13326
-11876
lines changed

Diff for: ‎src/main/java/org/biscuitsec/biscuit/crypto/BlockSignatureBuffer.java

+38-24
Original file line numberDiff line numberDiff line change
@@ -1,33 +1,47 @@
11
package org.biscuitsec.biscuit.crypto;
22

3-
import org.biscuitsec.biscuit.token.format.ExternalSignature;
4-
53
import java.nio.ByteBuffer;
64
import java.nio.ByteOrder;
75
import java.util.Optional;
6+
import org.biscuitsec.biscuit.token.format.ExternalSignature;
7+
8+
public final class BlockSignatureBuffer {
9+
public static final int HEADER_SIZE = 4;
10+
11+
private BlockSignatureBuffer() {}
812

9-
public class BlockSignatureBuffer {
10-
public static byte[] getBufferSignature(PublicKey nextPubKey, byte[] data) {
11-
return getBufferSignature(nextPubKey, data, Optional.empty());
12-
}
13+
public static byte[] getBufferSignature(PublicKey nextPubKey, byte[] data) {
14+
return getBufferSignature(nextPubKey, data, Optional.empty());
15+
}
1316

14-
public static byte[] getBufferSignature(PublicKey nextPubKey, byte[] data, Optional<ExternalSignature> externalSignature) {
15-
var buffer = ByteBuffer.allocate(4 + data.length + nextPubKey.toBytes().length + externalSignature.map((a) -> a.signature.length).orElse(0)).order(ByteOrder.LITTLE_ENDIAN);
16-
buffer.put(data);
17-
externalSignature.ifPresent(signature -> buffer.put(signature.signature));
18-
buffer.putInt(nextPubKey.algorithm.getNumber());
19-
buffer.put(nextPubKey.toBytes());
20-
buffer.flip();
21-
return buffer.array();
22-
}
17+
public static byte[] getBufferSignature(
18+
PublicKey nextPubKey, byte[] data, Optional<ExternalSignature> externalSignature) {
19+
var buffer =
20+
ByteBuffer.allocate(
21+
HEADER_SIZE
22+
+ data.length
23+
+ nextPubKey.toBytes().length
24+
+ externalSignature.map((a) -> a.getSignature().length).orElse(0))
25+
.order(ByteOrder.LITTLE_ENDIAN);
26+
buffer.put(data);
27+
externalSignature.ifPresent(signature -> buffer.put(signature.getSignature()));
28+
buffer.putInt(nextPubKey.getAlgorithm().getNumber());
29+
buffer.put(nextPubKey.toBytes());
30+
buffer.flip();
31+
return buffer.array();
32+
}
2333

24-
public static byte[] getBufferSealedSignature(PublicKey nextPubKey, byte[] data, byte[] blockSignature) {
25-
var buffer = ByteBuffer.allocate(4 + data.length + nextPubKey.toBytes().length + blockSignature.length).order(ByteOrder.LITTLE_ENDIAN);
26-
buffer.put(data);
27-
buffer.putInt(nextPubKey.algorithm.getNumber());
28-
buffer.put(nextPubKey.toBytes());
29-
buffer.put(blockSignature);
30-
buffer.flip();
31-
return buffer.array();
32-
}
34+
public static byte[] getBufferSealedSignature(
35+
PublicKey nextPubKey, byte[] data, byte[] blockSignature) {
36+
var buffer =
37+
ByteBuffer.allocate(
38+
HEADER_SIZE + data.length + nextPubKey.toBytes().length + blockSignature.length)
39+
.order(ByteOrder.LITTLE_ENDIAN);
40+
buffer.put(data);
41+
buffer.putInt(nextPubKey.getAlgorithm().getNumber());
42+
buffer.put(nextPubKey.toBytes());
43+
buffer.put(blockSignature);
44+
buffer.flip();
45+
return buffer.array();
46+
}
3347
}

Diff for: ‎src/main/java/org/biscuitsec/biscuit/crypto/Ed25519KeyPair.java

+59-58
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,12 @@
11
package org.biscuitsec.biscuit.crypto;
22

33
import biscuit.format.schema.Schema;
4+
import java.security.InvalidKeyException;
5+
import java.security.MessageDigest;
6+
import java.security.NoSuchAlgorithmException;
7+
import java.security.SecureRandom;
8+
import java.security.Signature;
9+
import java.security.SignatureException;
410
import net.i2p.crypto.eddsa.EdDSAEngine;
511
import net.i2p.crypto.eddsa.EdDSAPrivateKey;
612
import net.i2p.crypto.eddsa.EdDSAPublicKey;
@@ -10,80 +16,75 @@
1016
import net.i2p.crypto.eddsa.spec.EdDSAPublicKeySpec;
1117
import org.biscuitsec.biscuit.token.builder.Utils;
1218

13-
import java.security.InvalidKeyException;
14-
import java.security.MessageDigest;
15-
import java.security.NoSuchAlgorithmException;
16-
import java.security.SecureRandom;
17-
import java.security.Signature;
18-
import java.security.SignatureException;
19-
2019
final class Ed25519KeyPair extends KeyPair {
20+
private static final int BUFFER_SIZE = 32;
2121

22-
static final int SIGNATURE_LENGTH = 64;
23-
24-
private final EdDSAPrivateKey privateKey;
25-
private final EdDSAPublicKey publicKey;
22+
public static final int SIGNATURE_LENGTH = 64;
2623

27-
private static final EdDSANamedCurveSpec ed25519 = EdDSANamedCurveTable.getByName(EdDSANamedCurveTable.ED_25519);
24+
private final EdDSAPrivateKey privateKey;
25+
private final EdDSAPublicKey publicKey;
2826

29-
public Ed25519KeyPair(byte[] bytes) {
30-
EdDSAPrivateKeySpec privKeySpec = new EdDSAPrivateKeySpec(bytes, ed25519);
31-
EdDSAPrivateKey privKey = new EdDSAPrivateKey(privKeySpec);
27+
private static final EdDSANamedCurveSpec ED_25519 =
28+
EdDSANamedCurveTable.getByName(EdDSANamedCurveTable.ED_25519);
3229

33-
EdDSAPublicKeySpec pubKeySpec = new EdDSAPublicKeySpec(privKey.getA(), ed25519);
34-
EdDSAPublicKey pubKey = new EdDSAPublicKey(pubKeySpec);
30+
Ed25519KeyPair(byte[] bytes) {
31+
EdDSAPrivateKeySpec privKeySpec = new EdDSAPrivateKeySpec(bytes, ED_25519);
32+
EdDSAPrivateKey privKey = new EdDSAPrivateKey(privKeySpec);
3533

36-
this.privateKey = privKey;
37-
this.publicKey = pubKey;
38-
}
34+
EdDSAPublicKeySpec pubKeySpec = new EdDSAPublicKeySpec(privKey.getA(), ED_25519);
35+
EdDSAPublicKey pubKey = new EdDSAPublicKey(pubKeySpec);
3936

40-
public Ed25519KeyPair(SecureRandom rng) {
41-
byte[] b = new byte[32];
42-
rng.nextBytes(b);
37+
this.privateKey = privKey;
38+
this.publicKey = pubKey;
39+
}
4340

44-
EdDSAPrivateKeySpec privKeySpec = new EdDSAPrivateKeySpec(b, ed25519);
45-
EdDSAPrivateKey privKey = new EdDSAPrivateKey(privKeySpec);
41+
Ed25519KeyPair(SecureRandom rng) {
42+
byte[] b = new byte[BUFFER_SIZE];
43+
rng.nextBytes(b);
4644

47-
EdDSAPublicKeySpec pubKeySpec = new EdDSAPublicKeySpec(privKey.getA(), ed25519);
48-
EdDSAPublicKey pubKey = new EdDSAPublicKey(pubKeySpec);
45+
EdDSAPrivateKeySpec privKeySpec = new EdDSAPrivateKeySpec(b, ED_25519);
46+
EdDSAPrivateKey privKey = new EdDSAPrivateKey(privKeySpec);
4947

50-
this.privateKey = privKey;
51-
this.publicKey = pubKey;
52-
}
48+
EdDSAPublicKeySpec pubKeySpec = new EdDSAPublicKeySpec(privKey.getA(), ED_25519);
49+
EdDSAPublicKey pubKey = new EdDSAPublicKey(pubKeySpec);
5350

54-
public Ed25519KeyPair(String hex) {
55-
this(Utils.hexStringToByteArray(hex));
56-
}
51+
this.privateKey = privKey;
52+
this.publicKey = pubKey;
53+
}
5754

58-
public static java.security.PublicKey decode(byte[] data) {
59-
return new EdDSAPublicKey(new EdDSAPublicKeySpec(data, ed25519));
60-
}
55+
Ed25519KeyPair(String hex) {
56+
this(Utils.hexStringToByteArray(hex));
57+
}
6158

62-
public static Signature getSignature() throws NoSuchAlgorithmException {
63-
return new EdDSAEngine(MessageDigest.getInstance(ed25519.getHashAlgorithm()));
64-
}
59+
public static java.security.PublicKey decode(byte[] data) {
60+
return new EdDSAPublicKey(new EdDSAPublicKeySpec(data, ED_25519));
61+
}
6562

66-
@Override
67-
public byte[] sign(byte[] data) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
68-
Signature sgr = KeyPair.generateSignature(Schema.PublicKey.Algorithm.Ed25519);
69-
sgr.initSign(privateKey);
70-
sgr.update(data);
71-
return sgr.sign();
72-
}
63+
public static Signature getSignature() throws NoSuchAlgorithmException {
64+
return new EdDSAEngine(MessageDigest.getInstance(ED_25519.getHashAlgorithm()));
65+
}
7366

74-
@Override
75-
public byte[] toBytes() {
76-
return privateKey.getSeed();
77-
}
67+
@Override
68+
public byte[] sign(byte[] data)
69+
throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
70+
Signature sgr = KeyPair.generateSignature(Schema.PublicKey.Algorithm.Ed25519);
71+
sgr.initSign(privateKey);
72+
sgr.update(data);
73+
return sgr.sign();
74+
}
7875

79-
@Override
80-
public String toHex() {
81-
return Utils.byteArrayToHexString(toBytes());
82-
}
76+
@Override
77+
public byte[] toBytes() {
78+
return privateKey.getSeed();
79+
}
8380

84-
@Override
85-
public PublicKey public_key() {
86-
return new PublicKey(Schema.PublicKey.Algorithm.Ed25519, this.publicKey);
87-
}
81+
@Override
82+
public String toHex() {
83+
return Utils.byteArrayToHexString(toBytes());
84+
}
8885

86+
@Override
87+
public PublicKey getPublicKey() {
88+
return new PublicKey(Schema.PublicKey.Algorithm.Ed25519, this.publicKey);
89+
}
8990
}

Diff for: ‎src/main/java/org/biscuitsec/biscuit/crypto/KeyDelegate.java

+3-4
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,12 @@
22

33
import io.vavr.control.Option;
44

5-
65
/**
76
* Used to find the key associated with a key id
87
*
9-
* When the root key is changed, it might happen that multiple root keys are in use at the same time.
10-
* Tokens can carry a root key id, that can be used to indicate which key will verify it.
8+
* <p>When the root key is changed, it might happen that multiple root keys are in use at the same
9+
* time. Tokens can carry a root key id, that can be used to indicate which key will verify it.
1110
*/
1211
public interface KeyDelegate {
13-
public Option<PublicKey> root_key(Option<Integer> key_id);
12+
Option<PublicKey> getRootKey(Option<Integer> keyId);
1413
}

Diff for: ‎src/main/java/org/biscuitsec/biscuit/crypto/KeyPair.java

+43-46
Original file line numberDiff line numberDiff line change
@@ -1,69 +1,66 @@
11
package org.biscuitsec.biscuit.crypto;
22

3-
43
import biscuit.format.schema.Schema.PublicKey.Algorithm;
5-
import net.i2p.crypto.eddsa.Utils;
6-
74
import java.security.InvalidKeyException;
85
import java.security.NoSuchAlgorithmException;
96
import java.security.SecureRandom;
107
import java.security.Signature;
118
import java.security.SignatureException;
9+
import net.i2p.crypto.eddsa.Utils;
1210

13-
/**
14-
* Private and public key.
15-
*/
11+
/** Private and public key. */
1612
public abstract class KeyPair implements Signer {
1713

18-
public static KeyPair generate(Algorithm algorithm) {
19-
return generate(algorithm, new SecureRandom());
20-
}
14+
public static KeyPair generate(Algorithm algorithm) {
15+
return generate(algorithm, new SecureRandom());
16+
}
2117

22-
public static KeyPair generate(Algorithm algorithm, String hex) {
23-
return generate(algorithm, Utils.hexToBytes(hex));
24-
}
18+
public static KeyPair generate(Algorithm algorithm, String hex) {
19+
return generate(algorithm, Utils.hexToBytes(hex));
20+
}
2521

26-
public static KeyPair generate(Algorithm algorithm, byte[] bytes) {
27-
if (algorithm == Algorithm.Ed25519) {
28-
return new Ed25519KeyPair(bytes);
29-
} else if (algorithm == Algorithm.SECP256R1) {
30-
return new SECP256R1KeyPair(bytes);
31-
} else {
32-
throw new IllegalArgumentException("Unsupported algorithm");
33-
}
22+
public static KeyPair generate(Algorithm algorithm, byte[] bytes) {
23+
if (algorithm == Algorithm.Ed25519) {
24+
return new Ed25519KeyPair(bytes);
25+
} else if (algorithm == Algorithm.SECP256R1) {
26+
return new SECP256R1KeyPair(bytes);
27+
} else {
28+
throw new IllegalArgumentException("Unsupported algorithm");
3429
}
30+
}
3531

36-
public static KeyPair generate(Algorithm algorithm, SecureRandom rng) {
37-
if (algorithm == Algorithm.Ed25519) {
38-
return new Ed25519KeyPair(rng);
39-
} else if (algorithm == Algorithm.SECP256R1) {
40-
return new SECP256R1KeyPair(rng);
41-
} else {
42-
throw new IllegalArgumentException("Unsupported algorithm");
43-
}
32+
public static KeyPair generate(Algorithm algorithm, SecureRandom rng) {
33+
if (algorithm == Algorithm.Ed25519) {
34+
return new Ed25519KeyPair(rng);
35+
} else if (algorithm == Algorithm.SECP256R1) {
36+
return new SECP256R1KeyPair(rng);
37+
} else {
38+
throw new IllegalArgumentException("Unsupported algorithm");
4439
}
40+
}
4541

46-
public static Signature generateSignature(Algorithm algorithm) throws NoSuchAlgorithmException {
47-
if (algorithm == Algorithm.Ed25519) {
48-
return Ed25519KeyPair.getSignature();
49-
} else if (algorithm == Algorithm.SECP256R1) {
50-
return SECP256R1KeyPair.getSignature();
51-
} else {
52-
throw new NoSuchAlgorithmException("Unsupported algorithm");
53-
}
42+
public static Signature generateSignature(Algorithm algorithm) throws NoSuchAlgorithmException {
43+
if (algorithm == Algorithm.Ed25519) {
44+
return Ed25519KeyPair.getSignature();
45+
} else if (algorithm == Algorithm.SECP256R1) {
46+
return SECP256R1KeyPair.getSignature();
47+
} else {
48+
throw new NoSuchAlgorithmException("Unsupported algorithm");
5449
}
50+
}
5551

56-
public static boolean verify(PublicKey publicKey, byte[] data, byte[] signature) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
57-
Signature sgr = KeyPair.generateSignature(publicKey.algorithm);
58-
sgr.initVerify(publicKey.key);
59-
sgr.update(data);
60-
return sgr.verify(signature);
61-
}
52+
public static boolean verify(PublicKey publicKey, byte[] data, byte[] signature)
53+
throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
54+
Signature sgr = KeyPair.generateSignature(publicKey.getAlgorithm());
55+
sgr.initVerify(publicKey.getKey());
56+
sgr.update(data);
57+
return sgr.verify(signature);
58+
}
6259

63-
public abstract byte[] toBytes();
60+
public abstract byte[] toBytes();
6461

65-
public abstract String toHex();
62+
public abstract String toHex();
6663

67-
@Override
68-
public abstract PublicKey public_key();
64+
@Override
65+
public abstract PublicKey getPublicKey();
6966
}

0 commit comments

Comments
 (0)