MULTI-MESSAGE MULTI-USER SIGNATURE AGGREGATION

Description

BACKGROUND OF THE INVENTION

The present invention relates generally to document identification over computer networks or other types of communication systems and, more particularly, to a scheme for multi-message multi-user signature aggregation.

In general, traditional cryptographic schemes providing encryption, key encapsulation, and signature services are expected to be replaced by quantum-resistant schemes in deployments during the next decade. The threat is so urgent that the US National Institute of Standards and Technology started a standardization competition in 2018 to select one or more so-called Post-Quantum (PQ) schemes. PQ signature schemes are expected to play a vital role in protecting the integrity of data in storage, during transmission, and even during computation.

While techniques such as multi-signatures are useful for compressing multiply signed individual transactions, the bulk of the transactions on Bitcoin™ and other networks are signed by different users. Therefore, new blocks are mostly made up of transactions with separate signatures that are not compressible by existing multi-signature schemes.

Moreover, prior schemes use traditional cryptographic primitives that assume hardness in the traditional non-quantum model. There is an urgent need for PQ signature schemes that allow aggregation.

Compression and aggregation of individual PQ signatures and of public keys remain a challenge.

SUMMARY OF THE INVENTION

The following presents a simplified summary of the innovation in order to provide a basic understanding of some aspects of the invention. This summary is not an extensive overview of the invention. It is intended to neither identify key or critical elements of the invention nor delineate the scope of the invention. Its sole purpose is to present some concepts of the invention in a simplified form as a prelude to the more detailed description that is presented later.

In general, in one aspect, the invention features a method for signing and subsequently verifying a collection of digital messages including in at least one processor-based subsystem, selecting parameters that include two rings Ring1 and Ring2 and a module Mod, a ring homomorphism RHom from Ring1 to Ring2, a linear transformation THom from Ring2 to Mod, one or more range-defining bounds, and one or more formatted hash functions, for each User_i selecting a private key PrivKey_i that includes an element f_i in the Ring1 satisfying a first set of predetermined conditions and selecting an associated public key PubKey_i that includes the value Rhom(f_i), for each User_i selecting a digital document Doc_i and an element Rand_i in Ring1 satisfying a second set of predetermined conditions, and computing a signature Sig_i that includes elements C_i and Z_i in Ring1, wherein C_i is the output of a function whose input includes one or more quantities derived from THom(RHom(Rand_i)), Doc_i, and PubKey_i, and wherein the element Z_i is the output of a function whose input includes PrivKey_i, Rand_i, and C_i, and wherein Z_i satisfies a third set of predetermined conditions, aggregating a collection of signatures Sig_1, . . . , Sig_K on documents Doc_1, . . . , Doc_K to form an aggregate signature AggSig that includes quantities Z, Y, Y_1, . . . , Y_K, wherein the element Y is in Ring2 and is computed as the output of a function whose input includes RHom(Rand_1), . . . , RHom(Rand_K), wherein the elements Y_1, . . . , Y_K are in Mod and wherein each Y_i is computed as the output of a function whose input includes THom(RHom(Rand_i)), and wherein the element Z is in Ring1 and is computed as the output of a function whose input includes C_1, . . . , C_K and Z_1, . . . , Z_K, and verifying the validity of the aggregate signature AggSig on the documents Doc_1, . . . , Doc_K for the public keys PubKey_1, . . . , PubKey_K by a process that includes verifying that the quantities Z, Y, Y_1, . . . , Y_K satisfy a fourth set of predetermined conditions.

These and other features and advantages will be apparent from a reading of the following detailed description and a review of the associated drawings. It is to be understood that both the foregoing general description and the following detailed description are explanatory only and are not restrictive of aspects as claimed.

BRIEF DESCRIPTION OF THE DRAWINGS

These and other features, aspects, and advantages of the present invention will become better understood with reference to the following description, appended claims, and accompanying drawings where:

FIG. 1 is a block diagram of an exemplary system that can be used in practicing embodiments of the present invention.

DETAILED DESCRIPTION

The subject innovation is now described with reference to the drawings, wherein like reference numerals are used to refer to like elements throughout. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It may be evident, however, that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to facilitate describing the present invention.

Post-Quantum (PQ) signature schemes are known for large key and signature sizes, which may inhibit their deployment in real world applications. The present invention is a PQ signature scheme MMSAT that is a scheme capable of aggregating and compressing unrelated messages signed individually by different parties. The present invention extends the notion of multi-signatures, which are signatures that support aggregation of signatures on a single message signed by multiple parties. Multi-signatures are especially useful in Blockchain applications, where a transaction may be signed by multiple users. The present invention achieves significant gains in bandwidth and storage requirements by allowing aggregation and compression of multi-key and multi-message transactions. The present invention is derived by extending the PASS_RSscheme, so the security of the scheme relies on the hardness of the Vandermonde-SIS problem. When aggregated and compressed, a signature includes two parts. The first part is a post-quantum size signature that grows very slowly, scaling by on the order of log K bits for K signatures. The second part scales linearly with K, but bears only a short fixed cost of 2λ bits per signature, where λ represents the security parameter. Even for a modest number of signatures, the overhead of MMSAT is in line with that of traditional signature schemes such as the Elliptic Curve Digital Signature Algorithm (ECDSA). The present invention additionally includes a variant MMSATK of MMSAT that is capable of aggregating and compressing the public keys used by different parties.

Referring now to FIG. 1, an exemplary system 10 that can be used in practicing embodiments of the invention includes two processor-based subsystems 105 and 155 that are in communication over a channel 50, which may be, for example, any wired or wireless communication channel such as a telephone or internet communication channel in, for example, a cloud-based system. In the example hereof, the channel can be considered a secure or an insecure channel. The subsystem 105 includes processor 110 and the subsystem 155 includes processor 160. The subsystems may typically include mobile devices, computers, or terminals. When programmed in the manner to be described, the processors 110 and 160 and their associated circuits may be used to implement an embodiment of the present invention and to practice an embodiment of the method of the invention. The processors 110 and 160 may each be any suitable processor, for example, an electronic digital processor or microprocessor. It should be understood that any general purpose or special purpose processor, or other machine or circuitry that can perform the functions described herein, electronically, optically, or by other means, can be utilized. The subsystem 105 typically includes memories 123, clock and timing circuitry 121, input/output functions 118 and display 125. Inputs can include a touchscreen/keyboard input as represented at 103. Communication is via transceiver 135, which may include any suitable device for communicating signals.

The subsystem 155 in this illustrative embodiment can have a similar configuration to that of subsystem 105. The processor 160 has associated input/output circuitry 164, memories 168, clock and timing circuitry 173, and a display 176. Inputs include a touchscreen/keyboard 155. Communication of subsystem 155 with the outside world is via transceiver 162.

The present invention is a PQ signature scheme, referred to herein as “MMSAT,” which supports aggregation across unrelated signatures signed by different users. An aggregated MMSAT signature has size roughly equal to a single PQ signature plus 2λ-bits per signature aggregated. From a practical perspective, even for a modest number of signatures (e.g., a few hundred), the aggregate signature size of MMSAT represents an improvement over traditional signature schemes such as elliptic curve-based signatures (ECDSA), e.g. it is 19-times smaller than Bimodal Lattice Signature Scheme (BLISS) and 1.9 times smaller than ECDSA for 1000 signatures at 128-bit security.

The present invention uses an ∞-norm analysis to give improved estimates for the forgery probability from lattice reduction, leading to optimized parameters.

The present invention is a method and system for multiple users to sign multiple documents, for those signatures to be aggregated and compressed based on ring homomorphisms and linear transformations, and for the users' public keys to be aggregated and compressed based on ring homomorphisms and linear transformations. The ring homomorphism may utilize two rings Ring1 and Ring2 and a module Mod, a ring homomorphism RHom: Ring1-->Ring2, and a linear transformation THom: Ring2-->Mod. The private keys can include elements f lying in a specified subset of Ring1, the public keys can include the value RHom(f) in Ring2, the individual signatures in accordance with the invention may include quantities computed from the individual documents and individual private and public keys via specified formatted hash functions and algebraic operations in the ring Ring1 and applications of the maps RHom and THom, and the aggregated and compressed signature on the collection of documents may include quantities computed from the individual signatures, the individual documents, and the individual public keys via specified formatted hash functions and algebraic operations in the rings Ring1 and Ring2 and applications of the maps RHom and THom.

Table 1, shown below, lists public parameters used variously by PASS_RSand MMSAT and MMSATK.

TABLE 1

Public parameters for PASS_RS, MMSAT, and MMSATK

N
a prime (dimension parameter)

q
a prime satisfying q ≡ 1 (mod N) (modulus parameter)

g
a primitive N^throot of unity in Z_q

R_q
the ring Z_q[x]/(x^N− 1), often identified with Z_q^Nwith

multiplication *

*
multiplication in R_q, convolution product in Z_q^N

⊙
coordinate-by-coordinate multiplication in R_q≅ Z_q^N

λ
bit security parameter

custom-character

space of message digests μ ∈ custom-character

Ω
a subset of {g^j:1 ≤ j ≤ N − 1}

t
=|Ω|, the number of elements in Ω

B_t
≈t/N, parameter used to select t

text missing or illegible when filed

dimension parameter for signature compression map T,

satisfies text missing or illegible when filed

≥

t′

 \begin{matrix} dimension parameter for key compression, \\ satisfies q^{t^{'}} \geq ? and (\begin{matrix} t \\ t^{'} \end{matrix}) \geq ? \end{matrix}

k
L^∞-norm bound for commitment polynomial y

b
L^∞-norm bound for rejection sampling is k − b

K
number of individual signatures contained in an aggregate

signature

B_k, B_q
multipliers used for L¹-norm bounds for aggregate signature,

related by B{square root over (K)}(k − b) ≈ B_qq.

d_e
the number of 1's and −1's in a challenge polynomial, d_e≤ b/2

d_f
the number of 1's and −1's in a private key

T
a Z_q-linear map T:Z_q^t→ Z_q text missing or illegible when filed

used for compression

Hash_C
a hash/encoder function {0, 1} text missing or illegible when filed

→

(d_e)

Hash_B
a hash/encoder function {0, 1} text missing or illegible when filed

→ {−1, 1}

Hash_Ω
a hash/encoder function {0, 1} text missing or illegible when filed

→ {subsets of Ω containing

t′ elements}

text missing or illegible when filed

indicates data missing or illegible when filed

In Table 2, an exemplary sign algorithm for individual signatures is shown.

TABLE 2

Sign Algorithm for PASS_RSand MMSAT and MMSATK.

The input to Hash_Cdepends on the particular scheme

Algorithm 1 Sign

Input: (μ, f, Scheme)

1:
repeat

2:

y \overset{?}{\leftarrow} ℬ^{\infty} (k)

3:
c ← Hash_C(Scheme, μ)

4:
z ← f * c + y

5:

until z \in ℬ^{\infty} (k - b)

Output: (ŷ|_Ω, z, μ)

? indicates text missing or illegible when filed

In Table 3, an exemplary verification algorithm for individual signatures is shown.

TABLE 3

Verify Algorithm for PASS_RSand MMSATK. The

input to Hash_Cdepends on the particular scheme

Algorithm 2 Verify

Input: (ŷ|_Ω, z, μ, {circumflex over (f)}|_Ω, Scheme)

1:
c ← Hash_C(Scheme, μ)

2:
Z ← {circumflex over (f)}|_Ω ⊙ ĉ|_Ω + ŷ|_Ω

3:
if z ϵ B^∞ (k − b) and Z = {circumflex over (z)}|_Ω then

4:
result ← valid

5:
else

6:
result ← invalid

7:
end if

Output: result

In Table 4, an exemplary MMSAT aggregate signature algorithm is shown.

TABLE 4

MMSAT: Aggregate Signature Algorithm

with Signature Compression

Algorithm 3 Aggregate

Input: ( custom-character

|_Ω, z_i, μ_i, custom-character

|_Ω)_iϵ[K]

1:
for i := 1 to K step 1 do

2:
c_i← Hash_C(T(ŷ|_Ω), μ_i, custom-character

|_Ω)

3:
end for

4:
β ← Hash_B(c₁,..., c_K)

5:
z ← β₁z₁+ ... + β_Kz_K

6:
Y ← β₁ custom-character

|_Ω + ... + β_K custom-character

|_Ω

7:
if ||z||_∞ ≤ B_k{square root over (K)}(k − b) then

8:
result ← success

9:
else

10:
result ← failture

11:
end if

Output: (z, Y, μ_i, T( custom-character

|_Ω))_iϵ[K], result

In Table 5, an exemplary MMSAT verify aggregate signature algorithm is shown.

TABLE 5

MMSAT: Aggregate Signature Verification Algorithm

Algorithm 4 VerifyAggregate

Input: (z, Y, μ_i, T(ŷ_i|_Ω), {circumflex over (f)}_i|_Ω)_i∈[K]

1:
for i := 1 to K step 1 do

2:
c_i← Hash_C(T(ŷ_i|_Ω), μ_i, {circumflex over (f)}_i|_Ω)

3:
end for

4:
β ← Hash_B(c₁, . . . , c_K)

5:

Z \leftarrow (\sum_{i = 1}^{K} β_{i} ({\hat{f_{i} │}}_{Ω} ⊙ \hat{c_{i}} │_{Ω})) + Y

W \leftarrow (\sum_{i = 1}^{K} β_{i} T (\hat{y_{i}} │_{Ω}))

7:
if ∥z∥_∞ ≤ B_k{square root over (K)}(k − b) and

c₁, . . . , c_Kare distinct and

T(Y) = W and Z = {circumflex over (z)}|_Ω then

8:
result ← valid

9:
else

10:
result ← invalid

11:
end if

Output: result

In Table 6, an exemplary MMSAT sign algorithm with public key compression is illustrated.

TABLE 6

MMSATK: Aggregate Signature Algorithm

with Public Key Compression

Algorithms 5 Aggregate

Input: ( custom-character

|_Ω, z_i, μ_i, custom-character

|_Ω)_iϵ[K]

1:
for i := 1 to K step 1 do

2:
Y_i← T( custom-character

|_Ω)

3:
F_i← T( custom-character

|_Ω)

4:
c_i← Hash_C(Y_i, μ_i, F_i)

5:
end for

6:
β ← Hash_B(ci,...,c_K)

7:
z ← β₁z₁+ ... + β_Kz_K

8:
Y ← β₁ custom-character

|_Ω + ... + β_K custom-character

|_Ω

9:
Ω′ ← Hash_Ω(z, y, c₁,..., c_K)

10:
for i := 1 to K step 1 do

11:
F_i′ ← custom-character

|_Ω′

12:
Y_i′ ← custom-character

|_Ω′

13:
end for

14:
if ||z||_∞ ≤ B_k{square root over (K)}(k − b) then

15:
result ← success

16:
else

17:
result ← failture

18:
end if

Output: (z, Y, μ_i, Y_i, Y_i′, F_i, F_i′)_iϵ[K],

result

In Table 7, an exemplary MMSAT verify individual signature with compressed public key algorithm is shown.

TABLE 7

MMSATK: Aggregate

Verification Algorithm with Compressed Public Key

Algorithm 6 VerifyAggregate

Input: (z, Y, μ_i, Y_i, Y_i′, F_i, F_i′,)_i∈[K]

1:
for i := 1 to K step 1 do

2:
c_i← Hash_C(Y_i, μ_i, F_i)

3:
end for

4:
β ← Hash_B(c₁, . . . , c_K)

5:
Ω′ ← Hash_Ω(z, Y, c₁, . . . , c_K)

6:

Z^{'} \leftarrow (\sum_{i = 1}^{K} β_{i} (F_{i}^{'} ⊙ \hat{c_{i}} │_{Ω^{'}})) + {Y │}_{Ω^{'}}

W^{'} \leftarrow \sum_{i = 1}^{K} β_{i} Y_{i}^{'}

8:
if ∥z∥_∞ ≤ B_k{square root over (K)}(k − b) and

c₁, . . . , c_Kare distinct and Z′ =

{circumflex over (z)}|_Ω′ and W′ = Y|_Ω′ then

9:
result ← valid

10:
else

11:
result ← invalid

12:
end if

Output: result

It would be appreciated by those skilled in the art that various changes and modifications can be made to the illustrated embodiments without departing from the spirit of the present invention. All such modifications and changes are intended to be within the scope of the present invention except as limited by the scope of the appended claims.

Claims

1. A method for signing and subsequently verifying a collection of digital messages comprising: in at least one processor-based subsystem, selecting parameters that include two rings Ring1 and Ring2 and a module Mod, a ring homomorphism RHom from Ring1 to Ring2, a linear transformation THom from Ring2 to Mod, one or more range-defining bounds, and one or more formatted hash functions;for each User_i selecting a private key PrivKey_i that includes an element f_i in the Ring1 satisfying a first set of predetermined conditions and selecting an associated public key PubKey_i that includes the value RHom(f_i);for each User_i selecting a digital document Doc_i and an element Rand_i in Ring1 satisfying a second set of predetermined conditions, and computing a signature Sig_i that includes elements C_i and Z_i in Ring1,wherein C_i is the output of a function whose input includes one or more quantities derived from THom(RHom(Rand_i)), Doc_i, and PubKey_i, and wherein the element Z_i is the output of a function whose input includes PrivKey_i, Rand_i, and C_i, and wherein Z_i satisfies a third set of predetermined conditions;aggregating a collection of signatures Sig_1, . . . , Sig_K on documents Doc_1, . . . , Doc_K to form an aggregate signature AggSig that includes quantities Z, Y, Y_1, . . . , Y_K, wherein the element Y is in Ring2 and is computed as the output of a function whose input includes RHom(Rand_1), . . . , RHom(Rand_K), wherein the elements Y_1, . . . , Y_K are in Mod and wherein each Y_i is computed as the output of a function whose input includes THom(RHom(Rand_i)), and wherein the element Z is in Ring1 and is computed as the output of a function whose input includes C_1, . . . , C_K and Z_1, . . . , Z_K; andverifying the validity of the aggregate signature AggSig on the documents Doc_1, . . . , Doc_K for the public keys PubKey_1, . . . , PubKey_K by a process that includes verifying that the quantities Z, Y, Y_1, . . . , Y_K satisfy a fourth set of predetermined conditions.
2. The method of claim 1 wherein Ring1 is equipped with one or more functions that measure a size of the elements of Ring1.
3. The method of claim 2 wherein the first set of predetermined conditions includes the condition that the size of the ring element f_i using the first size measure is less than the first range-defining bound.
4. The method of claim 2 wherein the second set of predetermined conditions includes the condition that the size of the ring element Rand_i using the second size measure is less than the second range-defining bound.
5. The method of claim 2 wherein the third set of predetermined conditions includes the condition that the size of the ring element Z_i using the third size measure is less than the third range-defining bound.
6. The method of claim 2 wherein the fourth set of predetermined conditions includes the condition that the size of the ring element Z using the fourth size measure is less than the fourth range-defining bound.
7. The method of claim 1 wherein the quantity C_i is computed as the output of the first formatted hash function evaluated at a list of inputs that includes THom(RHom(Rand_i)), Doc_i, and PubKey_i.
8. The method of claim 1 wherein the quantity Z_i is computed using the sum of Rand_i and the product of PrivKey_i and C_i in Ring1.
9. The method of claim 1 wherein linear functions L1, L2, L3 are determined using the output of the second formatted hash function evaluated at quantities that include C_1, . . . , C_K, wherein L1 is a linear function from Ring1 to Ring1, wherein L2 is a linear function from Ring2 to Ring2, wherein L3 is a linear function from Mod to Mod, wherein RHom composed with L1 equals L2 composed with RHom, and wherein THom composed with L2 equals L3 composed with THom.
10. The method of claim 9 wherein the functions L1, L2 and L3 are linear forms with small non-zero integer coefficients.
11. The method of claim 9 wherein the quantity Z is computed using the output of the function L1 evaluated at Z_1, . . . , Z_K.
12. The method of claim 9 wherein the quantity Y is computed using the output of the function L2 evaluated at RHom (Rand_1), . . . , RHom(Rand_K).
13. The method of claim 9 wherein the fourth set of predetermined conditions includes the condition that RHom(Z) is equal to Y plus L2 evaluated at RHom(f_1)*RHom(D_1), . . . , RHom(f_K)*Rhom(D_K), wherein the quantity D_i is computed as the output of the first formatted hash function evaluated at a list of inputs that includes Y_i, Doc_i, and PubKey_i.
14. The method of claim 9 wherein the fourth set of predetermined conditions includes the condition that THom(Y) is equal to L3 evaluated at Y_1, . . . , Y_K.
15. The method of claim 1 wherein the fourth set of predetermined conditions includes the condition that the quantities D_1, . . . , D_K are distinct, wherein the quantity D_i is computed as the output of the first formatted hash function evaluated at a list of inputs that includes Y_i, Doc_i, and PubKey_i.
16. The method of claim 1 wherein F_q is a finite field and Ring1 and Ring2 are finite F_q-algebras and M is a finite F_q-vector space and RHom is an F_q-algebra homomorphism and THom is an F_q-linear transformation.
17. The method of claim 16 wherein multiplication in Ring1 is convolution product and multiplication in Ring2 is coordinate-by-coordinate product, and RHom is a finite Fourier transform following by a projection onto one or more coordinates.
18. The method of claim 16 wherein the dimensions of Ring1 and Ring2 as vector spaces over F_q are prime.
19. The method of claim 16 wherein the size measures on Ring1 are computed using the values of specified F_q-coordinates centered into the range from −q/2 to q/2.
20. The method of claim 16 wherein the coefficients of the linear transformation THom satisfy the fifth range-defining bound.
21. The method of claim 1 wherein the digital document Doc_i is selected as the output of the third formatted hash function evaluated at an unencrypted and unhashed digital document UEDoc_i.
22. The method of claim 1 wherein the element Z in Ring1 is computed as the output of a function whose input additionally includes Doc_1, . . . , Doc_K.
23. The method of claim 9 wherein the input to the second formatted hash function additionally includes some or all of the quantities Y_1, . . . , Y_K, Doc_1, . . . , Doc_K, PubKey_1, . . . , PubKey_K.
24. The method of claim 1 wherein the module M is equal to the ring Ring2 and the linear transformation THom is the identity map.
25. The method of claim 5 wherein the third range-defining bound is chosen so that a list of signatures signed by one private key is indistinguishable from a list of signatures signed by a second private key.
26. The method of claim 1 wherein the parameters additionally include a ring Ring2′, a function whose input includes elements Z, C_1, . . . , C_K of Ring1 and an element Y of Mod and whose output is a homomorphism PHom from Ring2 to Ring2′, and a linear function L2′ from Ring2′ to Ring2′ such that PHom composed with L2′ is equal to L2 composed with PHom, and wherein the aggregate signature AggSig additionally includes elements Y_1′, . . . , Y_K′, F_1, . . . F_K, F_1′, . . . , F_K′, wherein Y_1′, . . . , Y_K′ are in Ring2′ and wherein each Y_i′ is computed as the output of a function whose input includes PHom (Z, C_1, . . . , C_K, Y; RHom(Rand_i)), and wherein the elements F_1, . . . , F_K are in Mod and wherein each F_i is computed as the output of a function whose input includes THom(RHom(f_i)), and wherein the elements F_1′, . . . , F_K′ are in Ring2′ and wherein each F_i′ is computed as the output of a function whose input includes PHom (Z, C_1, . . . , C_K, Y; RHom(f_i)), and wherein the process of verifying the validity of the aggregate signature AggSig on the documents Doc_1, . . . , Doc_K for the public keys PubKey_1, . . . , PubKey_K includes verifying that the quantities Z, Y, Y_1, . . . , Y_K, Y_1′, . . . , Y_K′, F_1, . . . F_K, F_1′, . . . , F_K′ verify a fifth set of predetermined conditions.
27. The method of claim 1 wherein the quantity C_i is computed as the output of the first formatted hash function evaluated at a list of inputs that includes THom(RHom(Rand_i)), Doc_i, and THom(RHom(f_i)).
28. The method of claim 26 wherein the fifth set of predetermined conditions includes the condition that PHom(RHom(Z)) is equal to PHomZ (Y) plus L2′ evaluated at F_1′*PHom(RHom(D_1)), . . . , F_K′*PHom(RHom(D_K)), wherein the quantity D_i is computed as the output of the first formatted hash function evaluated at a list of inputs that includes Y_i, Doc_i, and F_i.
29. The method of claim 26 wherein the fifth set of predetermined conditions includes the condition that PHom(Y) is equal to L2′ evaluated at Y_1′, . . . , Y_K′.
30. The method of claim 26 wherein the coefficients of the linear transformation PHom satisfy the sixth range-defining bound.

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of U.S. Ser. No. 62/900,246, filed Sep. 13, 2019, and U.S. Ser. No. 63/015,212, filed Apr. 24, 2019.

STATEMENT REGARDING GOVERNMENT INTEREST

This invention was made with government support under Grant No. CNS-1561709 and Grant No. CNS-1561536 awarded by the National Science Foundation. The government has certain rights in the invention.

PCT Information

Filing Document	Filing Date	Country	Kind
PCT/US20/50378	9/11/2020	WO

Provisional Applications (2)

	Number	Date	Country
	62900246	Sep 2019	US
	63015212	Apr 2020	US

MULTI-MESSAGE MULTI-USER SIGNATURE AGGREGATION

Information

Publication Number

Date Filed

Date Published

Inventors

Original Assignees

CPC