118 lines
5.4 KiB
Java
118 lines
5.4 KiB
Java
package info.FrostFS.sdk.tools;
|
|
|
|
import com.google.protobuf.Message;
|
|
import frostFS.session.Types;
|
|
import info.FrostFS.sdk.mappers.StatusMapper;
|
|
import org.apache.commons.codec.digest.DigestUtils;
|
|
import org.bouncycastle.asn1.sec.SECNamedCurves;
|
|
import org.bouncycastle.asn1.sec.SECObjectIdentifiers;
|
|
import org.bouncycastle.crypto.params.ECDomainParameters;
|
|
import org.bouncycastle.crypto.params.ECPublicKeyParameters;
|
|
import org.bouncycastle.crypto.signers.ECDSASigner;
|
|
import org.bouncycastle.crypto.signers.HMacDSAKCalculator;
|
|
|
|
import java.math.BigInteger;
|
|
import java.security.PublicKey;
|
|
import java.security.Signature;
|
|
import java.util.Arrays;
|
|
|
|
import static info.FrostFS.sdk.KeyExtension.getPublicKeyFromBytes;
|
|
import static info.FrostFS.sdk.constants.CryptoConst.SIGNATURE_ALGORITHM;
|
|
import static info.FrostFS.sdk.constants.FieldConst.*;
|
|
import static info.FrostFS.sdk.tools.MessageHelper.getField;
|
|
import static java.util.Objects.isNull;
|
|
import static org.bouncycastle.crypto.util.DigestFactory.createSHA256;
|
|
import static org.bouncycastle.util.BigIntegers.fromUnsignedByteArray;
|
|
|
|
public class Verifier {
|
|
public static final String ERROR_WRONG_SIG_SIZE_TEMPLATE = "Wrong signature size. Expected length=%s, actual=%s";
|
|
public static final String ERROR_INVALID_RESPONSE = "Invalid response";
|
|
public static final int RFC6979_SIG_SIZE = 64;
|
|
|
|
public static boolean verifyRFC6979(frostFS.refs.Types.SignatureRFC6979 signature, Message data) {
|
|
return verifyRFC6979(signature.getKey().toByteArray(), data.toByteArray(), signature.getSign().toByteArray());
|
|
}
|
|
|
|
public static boolean verifyRFC6979(byte[] publicKey, byte[] data, byte[] sig) {
|
|
if (isNull(publicKey) || isNull(data) || isNull(sig)) return false;
|
|
|
|
var rs = decodeSignature(sig);
|
|
var digest = createSHA256();
|
|
var signer = new ECDSASigner(new HMacDSAKCalculator(digest));
|
|
var secp256R1 = SECNamedCurves.getByOID(SECObjectIdentifiers.secp256r1);
|
|
var ecParameters = new ECDomainParameters(secp256R1.getCurve(), secp256R1.getG(), secp256R1.getN());
|
|
var ecPublicKey = new ECPublicKeyParameters(secp256R1.getCurve().decodePoint(publicKey), ecParameters);
|
|
var hash = new byte[digest.getDigestSize()];
|
|
digest.update(data, 0, data.length);
|
|
digest.doFinal(hash, 0);
|
|
signer.init(false, ecPublicKey);
|
|
return signer.verifySignature(hash, rs[0], rs[1]);
|
|
}
|
|
|
|
private static BigInteger[] decodeSignature(byte[] sig) {
|
|
if (sig.length != RFC6979_SIG_SIZE) {
|
|
throw new IllegalArgumentException(
|
|
String.format(ERROR_WRONG_SIG_SIZE_TEMPLATE, RFC6979_SIG_SIZE, sig.length)
|
|
);
|
|
}
|
|
|
|
var rs = new BigInteger[2];
|
|
|
|
rs[0] = fromUnsignedByteArray(Arrays.copyOfRange(sig, 0, (RFC6979_SIG_SIZE / 2) - 1));
|
|
rs[1] = fromUnsignedByteArray(Arrays.copyOfRange(sig, RFC6979_SIG_SIZE / 2, RFC6979_SIG_SIZE - 1));
|
|
return rs;
|
|
}
|
|
|
|
public static void checkResponse(Message response) {
|
|
if (!verify(response)) {
|
|
throw new IllegalArgumentException(ERROR_INVALID_RESPONSE);
|
|
}
|
|
|
|
var metaHeader = (Types.ResponseMetaHeader) getField(response, META_HEADER_FIELD_NAME);
|
|
var status = StatusMapper.toModel(metaHeader.getStatus());
|
|
if (!status.isSuccess()) {
|
|
throw new IllegalArgumentException(status.toString());
|
|
}
|
|
}
|
|
|
|
public static boolean verify(Message response) {
|
|
var body = getField(response, BODY_FIELD_NAME);
|
|
var metaHeader = (Types.ResponseMetaHeader) getField(response, META_HEADER_FIELD_NAME);
|
|
var verifyHeader = (Types.ResponseVerificationHeader) getField(response, VERIFY_HEADER_FIELD_NAME);
|
|
|
|
return verifyMatryoshkaLevel(body, metaHeader, verifyHeader);
|
|
}
|
|
|
|
public static boolean verifyMatryoshkaLevel(Message data,
|
|
frostFS.session.Types.ResponseMetaHeader meta,
|
|
frostFS.session.Types.ResponseVerificationHeader verification) {
|
|
if (!verifyMessagePart(verification.getMetaSignature(), meta)) return false;
|
|
var origin = verification.getOrigin();
|
|
if (!verifyMessagePart(verification.getOriginSignature(), origin)) return false;
|
|
if (origin.getSerializedSize() == 0) {
|
|
return verifyMessagePart(verification.getBodySignature(), data);
|
|
}
|
|
return verification.getBodySignature().getSerializedSize() == 0
|
|
&& verifyMatryoshkaLevel(data, meta.getOrigin(), origin);
|
|
}
|
|
|
|
public static boolean verifyMessagePart(frostFS.refs.Types.Signature sig, Message data) {
|
|
if (sig.getSerializedSize() == 0 || sig.getKey().isEmpty() || sig.getSign().isEmpty()) return false;
|
|
|
|
var publicKey = getPublicKeyFromBytes(sig.getKey().toByteArray());
|
|
|
|
var data2Verify = data.getSerializedSize() == 0 ? new byte[]{} : data.toByteArray();
|
|
return verifyData(publicKey, data2Verify, sig.getSign().toByteArray());
|
|
}
|
|
|
|
public static boolean verifyData(PublicKey publicKey, byte[] data, byte[] sig) {
|
|
try {
|
|
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
|
|
signature.initVerify(publicKey);
|
|
signature.update(DigestUtils.sha512(data));
|
|
return signature.verify(Arrays.copyOfRange(sig, 1, sig.length));
|
|
} catch (Exception exp) {
|
|
throw new RuntimeException(exp);
|
|
}
|
|
}
|
|
}
|