コード例 #1
0
        private bool FastAggregateVerifyData(IList <byte[]>?publicKeyList, ReadOnlySpan <byte> publicKeysSpan, ReadOnlySpan <byte> data,
                                             ReadOnlySpan <byte> aggregateSignature)
        {
            // This is independent of the keys set, although other parameters (type of curve, variant, scheme, etc) are relevant.

            if (aggregateSignature.Length != SignatureLength)
            {
                throw new ArgumentOutOfRangeException(nameof(aggregateSignature), aggregateSignature.Length,
                                                      $"Signature must be {SignatureLength} bytes long.");
            }

            EnsureInitialised();

            var publicKeyCount = publicKeyList?.Count ?? publicKeysSpan.Length / PublicKeyLength;

            var blsPublicKeys = new Bls384Interop.BlsPublicKey[publicKeyCount];

            if (publicKeyList == null)
            {
                if (publicKeysSpan.Length % PublicKeyLength != 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(publicKeysSpan), publicKeysSpan.Length,
                                                          $"Public key data must be a multiple of the public key length {PublicKeyLength}.");
                }
            }

            var publicKeysIndex = 0;

            for (var blsPublicKeyIndex = 0; blsPublicKeyIndex < publicKeyCount; blsPublicKeyIndex++)
            {
                var publicKey = (publicKeyList != null)
                    ? publicKeyList[blsPublicKeyIndex]
                    : publicKeysSpan.Slice(publicKeysIndex, PublicKeyLength);

                int publicKeyBytesRead;
                unsafe
                {
                    fixed(byte *publicKeyPtr = publicKey)
                    {
                        publicKeyBytesRead = Bls384Interop.PublicKeyDeserialize(
                            ref blsPublicKeys[blsPublicKeyIndex],
                            publicKeyPtr, PublicKeyLength);
                    }
                }

                if (publicKeyBytesRead != PublicKeyLength)
                {
                    throw new Exception(
                              $"Error deserializing BLS public key {blsPublicKeyIndex}, length: {publicKeyBytesRead}");
                }

                publicKeysIndex += PublicKeyLength;
            }

            var aggregateBlsSignature = default(Bls384Interop.BlsSignature);
            int signatureBytesRead;

            unsafe
            {
                fixed(byte *signaturePtr = aggregateSignature)
                {
                    signatureBytesRead =
                        Bls384Interop.SignatureDeserialize(ref aggregateBlsSignature, signaturePtr, SignatureLength);
                }
            }

            if (signatureBytesRead != aggregateSignature.Length)
            {
                throw new Exception($"Error deserializing BLS signature, length: {signatureBytesRead}");
            }

            int result;

            unsafe
            {
                fixed(byte *dataPtr = data)
                {
                    result = Bls384Interop.FastAggregateVerify(ref aggregateBlsSignature, blsPublicKeys, publicKeyCount,
                                                               dataPtr, data.Length);
                }
            }

            return(result == 1);
        }