private bool adaptorVerify(byte[] adaptorSig, byte[] pubkey, byte[] msg, byte[] adaptor, byte[] adaptorProof) { Assert.True(SecpECDSAAdaptorSignature.TryCreate(adaptorSig, out var adaptorSigObj)); Assert.True(Context.Instance.TryCreatePubKey(pubkey, out var pubkeyObj)); Assert.True(Context.Instance.TryCreatePubKey(adaptor, out var adaptorObj)); Assert.True(SecpECDSAAdaptorProof.TryCreate(adaptorProof, out var adaptorProofObj)); return(pubkeyObj.SigVerify(adaptorSigObj, adaptorProofObj, msg, adaptorObj)); }
public static AdaptorSignature ParseFromTLV(TLVReader reader) { Span <byte> output = stackalloc byte[65 + 97]; reader.ReadBytes(output); if (!SecpECDSAAdaptorSignature.TryCreate(output.Slice(0, 65), out var sig)) { throw new FormatException("Invalid adaptor signature"); } if (!SecpECDSAAdaptorProof.TryCreate(output.Slice(65), out var proof)) { throw new FormatException("Invalid adaptor proof"); } return(new AdaptorSignature(sig, proof)); }
public static bool TryParse(string str, out AdaptorSignature?result) { if (str == null) { throw new ArgumentNullException(nameof(str)); } var bytes = Encoders.Hex.DecodeData(str); if (bytes.Length == 65 + 97 && SecpECDSAAdaptorSignature.TryCreate(bytes.AsSpan().Slice(0, 65), out var sig) && SecpECDSAAdaptorProof.TryCreate(bytes.AsSpan().Slice(65), out var proof) && sig is SecpECDSAAdaptorSignature && proof is SecpECDSAAdaptorProof) { result = new AdaptorSignature(sig, proof); return(true); } result = null; return(false); }
void adaptor_tests_core() { var secKey = Context.Instance.CreateECPrivKey(rand_scalar()); Span <byte> msg = stackalloc byte[32]; Random.Generate(msg); var adaptor_secret = Context.Instance.CreateECPrivKey(rand_scalar()); var pubkey = secKey.CreatePubKey(); var adaptor = adaptor_secret.CreatePubKey(); Assert.True(secKey.TrySignAdaptor(msg, adaptor, out var adaptor_sig, out var adaptor_proof)); { /* Test adaptor_sig_serialize roundtrip */ Span <byte> adaptor_sig_tmp = stackalloc byte[65]; Span <byte> adaptor_sig_tmp2 = stackalloc byte[65]; adaptor_sig.WriteToSpan(adaptor_sig_tmp); Assert.True(SecpECDSAAdaptorSignature.TryCreate(adaptor_sig_tmp, out var adaptor_sig2)); adaptor_sig2.WriteToSpan(adaptor_sig_tmp2); Assert.True(adaptor_sig_tmp.SequenceEqual(adaptor_sig_tmp2)); } ///* Test adaptor_sig_verify */ Assert.True(pubkey.SigVerify(adaptor_sig, adaptor_proof, msg, adaptor)); { Span <byte> adaptor_sig_tmp = stackalloc byte[65]; adaptor_sig.WriteToSpan(adaptor_sig_tmp); rand_flip_bit(adaptor_sig_tmp); if (SecpECDSAAdaptorSignature.TryCreate(adaptor_sig_tmp, out var sigg)) { Assert.False(pubkey.SigVerify(sigg, adaptor_proof, msg, adaptor)); } } Assert.False(adaptor.SigVerify(adaptor_sig, adaptor_proof, msg, adaptor)); { Span <byte> msg_tmp = stackalloc byte[32]; msg.CopyTo(msg_tmp); rand_flip_bit(msg_tmp); Assert.False(pubkey.SigVerify(adaptor_sig, adaptor_proof, msg_tmp, adaptor)); } Assert.False(pubkey.SigVerify(adaptor_sig, adaptor_proof, msg, pubkey)); { Span <byte> adaptor_proof_tmp = stackalloc byte[97]; adaptor_proof.WriteToSpan(adaptor_proof_tmp); rand_flip_bit(adaptor_proof_tmp); if (SecpECDSAAdaptorProof.TryCreate(adaptor_proof_tmp, out var proof)) { Assert.False(pubkey.SigVerify(adaptor_sig, proof, msg, adaptor)); } } var sig = adaptor_sig.AdaptECDSA(adaptor_secret); ///* Test adaptor_adapt */ Assert.True(pubkey.SigVerify(sig, msg)); { /* Test adaptor_extract_secret */ Assert.True(adaptor_sig.TryExtractSecret(sig, adaptor, out var adaptor_secret2)); Assert.Equal(adaptor_secret, adaptor_secret2); } }