WO2020041499A1

WO2020041499A1 - Systems and methods for a butterfly key exchange program

Info

Publication number: WO2020041499A1
Application number: PCT/US2019/047547
Authority: WO
Inventors: Paulo Sergio Licciardi Messeder BARRETO
Original assignee: Lg Electronics, Inc.
Priority date: 2018-08-21
Filing date: 2019-08-21
Publication date: 2020-02-27
Also published as: US11165592B2; EP3841703A1; US20210211306A1; EP3841703A4

Abstract

Embodiments described herein provide an implicit protocol with improved resource and bandwidth efficiency. A post-quantum secure approach for issuing multiple pseudonym certificates from a small piece of information is provided, while traditionally most encryption schemes are vulnerable to post-quantum attacks (e.g., in a traditional SCMS). Long-term security can be improved with the post-quantum protocol.

Description

SYSTEMS AND METHODS FOR A BUTTERFLY KEY EXCHANGE PROGRAM

Inventor: Paulo Barreto CROSS REFEENCE TO RELATED APPLICATIONS

[0001] The present application claims priority to U.S. Provisional Patent Application No. 62/720,866,“IMPLICIT SCHNORR AND THE UNIFIED POST-QUANTUM BUTTERFLY KEY EXCHANGE PROGRAM,” filed on 21 August 2018, which is hereby expressly incorporated herein by reference herein in its entirety.

COPYRIGHT NOTICE

[0002] A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.

TECHNICAL FIELD

[0003] The invention is related to privacy in vehicular communications, in particular for scenarios that use pseudonym certificates to enable secure and privacy-preserving

communications between vehicles.

BACKGROUND

[0004] Vehicular entities usually communicate with each other through a secured

communication mechanism. The Security Credential Management System (SCMS) has been used as a leading vehicular public-key infrastructure (VPKI) candidate designs for protecting vehicle-to-vehicle (V2V) and vehicle-to-infrastructure (V2I) communications. Specifically, the SCMS combines an efficient and privacy-preserving method for vehicles to obtain large batches of pseudonym certificates (also known as butterfly key expansion), and an ancillary process for revoking the user's privacy in case of misbehavior, so that multiple certificates belonging to the same user can be linked together. In SCMS, however, the security of the construction relies on the hardness of the elliptic curve discrete logarithm problem (ECDLP). As a result, its security properties may be lost in a post-quantum setting, i.e., if a large-enough quantum computer is built for running Shor's algorithm, attackers may have sufficient time to solve the ECDLP in polynomial time and thus launch a successful attack on the SCMS.

SUMMARY

[0005] This section summarizes some features of the invention. Other features may be described in the subsequent sections. The invention is defined by the appended claims, which are incorporated into this section by reference.

[0006] Some embodiments of the present invention provide a method for providing digital certificates for use by devices in authentication operations. Specifically, a cocoon public key is received at a first entity for generating a digital certificate. The cocoon public key is generated by expanding a caterpillar public key with a random function and the first entity is uninformed of which device the caterpillar public key is originated from. Butterfly reconstruction credentials are generated based on the cocoon public key and a random value. A certificate is generated based on the butterfly reconstruction credentials and metadata. A hash value is generated of both the certificate and a verification public key reserved for the first entity. A signature is generated based on the random value, the hash value and a verification private key associated with the verification public key. The certificate and the signature are encrypted using the cocoon public key. The encryption package from the encrypted certificate and signature is sent to a second entity. The second entity is unable to decrypt the encryption package, and the encryption package is forwarded from the second entity to a requesting device.

[0007] Some embodiments of the present invention provide a method for using digital certificates in authentication operations. An encryption package forwarded by a second entity that is unable to decrypt the encryption package is received, at a device and from a first entity. A private cocoon key is generated for decrypting the encryption package based on a private key associated with the device and a random function. The encryption package is decrypted using the private cocoon key into a certificate and a signature. A hash value of both the certificate and a verification public key reserved for the first entity. A verification private key reserved for the device is generated based on the private cocoon key and the signature. A verification public key reserved for the device is generated based on the verification public key reserved for the first entity, the hash value and butterfly reconstruction credentials. It is then verified that the generated verification public key reserved for the device and the generated verification private key satisfies a relationship.

[0008] Some embodiments of the present invention provide a method for using a ring- learning-with-errors (RLWE) based post-quantum protocol to provide digital certificates for use by devices in authentication operations. Specifically, a cocoon public key for generating a digital certificate is received at a first entity. The cocoon public key is generated by expanding a caterpillar public key with a first random function and a second random function, and the first entity is uninformed of which device the caterpillar public key is originated from. A verification public key reserved for the device is generated based on the received cocoon public key, a first pseudo-random value and a second pseudo-random value sampled from a 0-centered discrete Gaussian distribution on a first multi-dimensional space with a first standard deviation value according to a pseudo-random sampler having a seed value. A signature is generated over the verification public key reserved for the device along with metadata, a verification public key reserved for the first entity and a private key pair reserved for the first entity. A set of the seed value, the metadata and the signature is encrypted into an encryption package. The encryption package is sent to a second entity. The second entity is unable to decrypt the encryption package, and the encryption package is forwarded from the second entity to a requesting device.

[0009] Some embodiments of the present invention provide a method for using a ring- learning-with-errors (RLWE) based post-quantum protocol to verify digital certificates for use by devices in authentication operations. An encryption package forwarded by a second entity that is unable to decrypt the encryption package is received, at a device and from a first entity. A private cocoon key pair for decrypting the encryption package is generated based on a caterpillar private key pair associated with the device, a first random function and a second random function. The encryption package is decrypted using the private cocoon key pair into a set of a seed value, metadata and a signature. A verification public key reserved for the device is generated based on a public cocoon key, a first pseudo-random value and a second pseudo- random value sampled from a 0-centered discrete Gaussian distribution on a first multi- dimensional space with a first standard deviation value according to a pseudo-random sampler having the seed value. A verification private key pair reserved for the device is generated based on a private cocoon key pair, the first pseudo-random value and the second pseudo-random value. It is then verified that the generated verification public key reserved for the device and the generated verification private key pair satisfies a relationship. BRIEF DESCRIPTION OF THE DRAWINGS

[00010] Fig.1 illustrates an example SCMS infrastructure in which systems and methods of the present disclosure can operate.

[00011] FIG.2 provides an example diagram illustrating the butterfly key expansion in SCMS.

[00012] Fig.3 illustrates an embodiment of a computing device 150 which is used by any of the entities shown in Fig.1, according to some embodiments.

[00013] FIG.4 is an example table that compares existing explicit and implicit protocols with an implicit protocol with Schnorr-style signatures, according to embodiments described herein.

[00014] FIG.5A provides an example logic flow diagram illustrating an example RLWE- based component scheme for the use of butterfly effect protocols, known as the qTESLA digital signature scheme, according to some embodiments.

[00015] FIG.5B provides an example logic flow diagram illustrating an example RLWE- based component scheme for the use of butterfly effect protocols, known as the Lyubashevsky- Peikert-Regev (LPR) digital signature scheme, according to some embodiments.

[00016] FIG.6 provides an example table that compares the ECC-based (pre-quantum) and the lattice-based (post-quantum) variants of the explicit butterfly protocol, according to some embodiments described herein.

DETAILED DESCRIPTION OF SOME EMBODIMENTS

[00017] This description and the accompanying drawings that illustrate aspects,

embodiments, implementations, or applications should not be taken as limiting—the claims define the protected invention. Various mechanical, compositional, structural, electrical, and operational changes may be made without departing from the spirit and scope of this description and the claims. In some instances, well-known circuits, structures, or techniques have not been shown or described in detail as these are known to one skilled in the art. Like numbers in two or more figures represent the same or similar elements.

[00018] In this description, specific details are set forth describing some embodiments consistent with the present disclosure. Numerous specific details are set forth in order to provide a thorough understanding of the embodiments. It will be apparent to one skilled in the art, however, that some embodiments may be practiced without some or all of these specific details. The specific embodiments disclosed herein are meant to be illustrative but not limiting. One skilled in the art may realize other elements that, although not specifically described here, are within the scope and the spirit of this disclosure. In addition, to avoid unnecessary repetition, one or more features shown and described in association with one embodiment may be incorporated into other embodiments unless specifically described otherwise or if the one or more features would make an embodiment non-functional.

[00019] The following notations are used throughout the description:

r, e - random numbers;

sig - a digital signature;

cert– a digital certificate;

meta– metadata of the digital certificate;

U, ?– public signature keys (stylized ?: reserved for the pseudonym certificate authority) u, ?– private signature keys associate with U, ?

S, s– public and private caterpillar keys;

?^? _, ?̂– public and private cocoon keys; V– public key reconstruction credential;

b– number of cocoon keys in a batch of certificates;

f, g– pseudo-random functions;

ℋ^????^? - hash of bitstring str;

Enc (K, str)– encryption of bitstring str with encryption key K. Introduction

[0020] Fig.1 illustrates an example SCMS infrastructure in which systems and methods of the present disclosure can operate. Devices 102a-c, which may be a vehicle, a mobile device, and/or the like, may communicate through the SCMS infrastructure 103.

[0021] In SCMS, each device 102a-c receives two types of certificates: an enrollment certificate, which have long expiration times and identify valid devices in the system, and multiple pseudonym certificates, each of which has a short valid period (e.g., a few days). A number C (e.g., ? ^ 1 ) pseudonym certificates may be valid simultaneously. For protecting the privacy, a particular vehicle (e.g., 102a or 102b) may then frequently change the pseudonym certificate employed in their communications, thus avoiding tracking by nearby vehicles or by roadside units. In some implementations, the number of pseudonym certificates ? is usually limited to a small number to avoid“sybil-like” attacks, in which one vehicle poses as a platoon aiming to get some advantage over the system. For example, such a fake platoon could end up receiving preferential treatment from traffic lights programmed to give higher priority to congested roads.

[0022] SCMS is configured to allow the distribution of multiple pseudonym certificates to vehicles 102a-c in an efficient manner, while providing mechanisms for easily revoking them in case of misbehavior by their owners. As shown in FIG.1, the SCMS infrastructure 103 includes a Pseudonym Certificate Authority (PCA) 105 that is responsible for issuing pseudonym certificates to devices 102a-c. Registration Authority (RA) 108 receives and validates requests for batches of pseudonym certificates from devices 102a-c via the location obscurer proxy 112, which are identified by their enrollment certificates. Those requests are individually forwarded to the PCA 105, where requests associated with different devices are shuffled together so the PCA 105 cannot link a group of requests to the same device.

[0023] In some embodiments, the PCA 105 may include one or more distributed PCA(s), which are connected to a root certificate authority 118 via one or more intermediate certificate authority 117. The root certificate authority 118 may interface with the SCMS manager cloud 120 to receive control commands, configuration data, etc. from the manager could 120. [0024] The SCMS infrastructure 103 further includes Linkage Authority (LA) modules, e.g., 115a-b. The LA modules 115a-b generate random-like bit-strings that are added to certificates so the certificates can be efficiently revoked (namely, multiple certificates belonging to the same device can be linked together by adding a small amount of information to certificate revocation lists (CRLs)). Although two LAs 115a-b are shown in the SCMS infrastructure 103, additional LAs may be supported.

[0025] The SCMS infrastructure 103 also includes a Misbehavior Authority (MA) 116 that is configured to identify misbehavior by devices and, whenever necessary, revokes the certificates issued to the misbehaved devices by placing their certificates into a CRL. For example, the MA 116 includes a CRL generator 116c that adds the certificates of misbehaved devices to a CRL store 122 and broadcasts the revoked certificate information through a CRL broadcast module 124.

[0026] FIG.2 provides an example diagram illustrating the butterfly key expansion in SCMS. The pseudonym certification provisioning process in SMCS provides an efficient mechanism for devices to obtain arbitrarily large batches of (short-lived) certificates with a small-sized request message. It comprises the following steps, as illustrated in Figure 2.

[0027] First, the device (e.g., vehicle 102a) generates two caterpillar private/public key pairs 2 The public caterpillar keys 201 ? and ? are then sent

to the Registration Authority (RA 108) together with two suitable pseudorandom functions

and ? The key ? is employed by the RA 108 in the generation of ? public cocoon signature

for an arbitrary value of ?; similarly, the RA 108 uses ? for generating ? public cocoon encryption keys ? Pairs of cocoon keys

205a-n generated through the butterfly key expansion process 203, from different devices are then shuffled together by the RA 108 and sent in batch to the PCA 105 for the generation of the corresponding pseudonym certificates.

[0028] After receiving the cocoon keys, the PCA 105 computes the device's public signature key 206a-n as for a random value ?_?, inserts ?_? into a certificate ????_? containing

any necessary metadata, and digitally signs this certificate. The signed certificate 207a-n, together with the value of ?_? is then encrypted using ?^? _?, so only the original device can decrypt the result to learn ?_? and compute the corresponding private signature key

[0029] The encrypted data is also signed by the PCA 105 using its own private signature key, aiming to prevent an "honest-but-curious" RA 108 from engaging in a Man-in-the-Middle (MitM) attack. Namely, without this signature, a MitM attack by the RA 108 could be performed as follows: (1) instead of ?

the RA 108 sends to the PCA 105 a fake cocoon encryption key for an arbitrary value of ?; (2) the RA 108 decrypts the PCA's response using

learning the value of ?_?; and (3) the RA 108 re-encrypts the certificate with the correct

sending the result to the device, which proceeds with the protocol as usual. As long as the device verifies the PCA's signature on the RA's response, however, the attack would fail because RA 108 would not be able to provide a valid signature for the re-encrypted certificate 208a-n using the private signature key by PCA 105.

[0030] The user's privacy is protected in this process as long as the RA 108 and PCA 105 do not collude. After all, the shuffling of public cocoon keys 205a-n performed by the RA 108 prevents the PCA 105 from learning whether or not a group of keys in the batch belong to a same device. Unlinkability of public keys towards the RA 108, in turn, is also obtained because the latter does not learn the value of ?_?, randomized by the PCA 105 using ?_?.

[0031] The butterfly key expansion process shown in FIG.2 is generally quite efficient, but sometimes may consume significant processing resource and bandwidth, especially when implemented with the SMCS system shown in FIG. 1.

[0032] Fig.3 illustrates an embodiment of a computing device 150 which is used by any of the entities shown in Fig. 1, according to some embodiments. For example, the computing device 150 may be housed within the vehicle 102a-b, the PCA 105, the RA 108, etc.

[0033] As shown in Fig.3, computing device 150 includes one or more computer processors 150P coupled to computer storage (memory) 150S, and wireless communication equipment 150W for radio communications. Operation of computing device 150 is controlled by processor 150P, which may be implemented as one or more central processing units, multi-core processors, microprocessors, microcontrollers, digital signal processors, field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), graphics processing units (GPUs), tensor processing units (TPUs), and/or the like in computing device 150P. [0034] Memory 150S may be used to store software executed by computing device 150 and/or one or more data structures used during operation of computing device 150. Memory 150S may include one or more types of machine-readable media. Some common forms of machine readable media may include floppy disk, flexible disk, hard disk, magnetic tape, any other magnetic medium, CD-ROM, any other optical medium, punch cards, paper tape, any other physical medium with patterns of holes, RAM, PROM, EPROM, EEPROM, FLASH-EPROM, any other memory chip or cartridge, and/or any other medium from which a processor or computer is adapted to read.

[0035] Processor 150P and/or memory 150S may be arranged in any suitable physical arrangement. In some embodiments, processor 150P and/or memory 150S may be implemented on a same board, in a same package (e.g., system-in-package), on a same chip (e.g., system-on- chip), and/or the like. In some embodiments, processor 150P and/or memory 150S may include distributed, virtualized, and/or containerized computing resources. Consistent with such embodiments, processor 150P and/or memory 150S may be located in one or more data centers and/or cloud computing facilities. In some examples, memory 150S may include non-transitory, tangible, machine readable media that includes executable code that when run by one or more processors (e.g., processor 150P) may cause the computing device 150, alone or in conjunction with other computing devices in the environment, to perform any of the methods described further herein

[0036] Computing device or equipment 150 may include user interface 150i, e.g. such as present in a smartphone, an automotive information device, or of some other type device, for use by pedestrians, vehicle drivers, passengers, traffic managers, and possibly other people.

A Schnorr-Style Variant Of The Implicit Protocol

[0037] In view of the need for a protocol with improved resource and bandwidth efficiency, a Schnorr-stype variant protocol is provided. FIG.4 is an example table that compares existing explicit and implicit protocols with an implicit protocol with Schnorr-style signatures, according to embodiments described herein. The existing explicit protocol 401, the existing implicit protocol 402 and the implicit Schnorr protocol 403 employs the same process for the vehicles 102a-b to generate a public key o the PCA 105 via the RA 108, as described in FIG.2.

[0038] In all three protocols 401-403, the vehicle 102a starts by picking a random caterpillar private key s and computing the corresponding caterpillar public key S = s·G. The vehicle 102a then sends S, together with a pseudorandom instance f, to the RA 108.

[0039] In response to the vehicle’s request, the RA 108 expands the caterpillar public key S into b cocoon public Since f is shared only among the vehicle 102a and

the RA 108, the resulting cocoon keys are unlinkable to the original S from the perspective of any entity other than the vehicle 102a and the RA 108. The RA 108 then sends each individual

to the PCA 105, while shuﬄing together requests associated to diﬀerent batches to ensure their unlinkability. [0040] The PCA 105 receives, from RA 108, the cocoon public key and randomizes by

adding r_iG to it, for a randomly picked r_i. For existing explicit certificates in protocol 401, the resulting elliptic curve point is used directly as the vehicle’s butterfly public key Ui; it is then placed into a certificate together with any required metadata (e.g., a validity period), and signed. For existing implicit certificates with protocol 402, the randomized point is used as the butterfly reconstruction credential Vi; it is also combined with some metadata, and then signed. In all cases for protocols 401-403, the resulting certificate is encrypted with the originally provided

and sent back to the RA 108. The RA 108, unable to decrypt the PCA’s response pkg, simply forwards it back to the requesting vehicle 102a, in batch.

[0041] Finally, the vehicle 102a computes the key for decrypting pkg. It then

verifies that the retrieved certificate is indeed valid. This is done either by checking its signature (for explicit certificates) or by performing the corresponding key verification process (for implicit certificates). As long as such verification is successful, the keys obtained can be used for signing messages sent to other vehicles.

[0042] Specifically, at PCA 105, the implicit Schnorr protocol 403 adopts a Schnorr variant in key generation. The implicit Schnorr protocol 403 generating a hash of both the certificate and an intended verification public key, , where ? denotes the public

keys and certi denotes certificates. The previous schemes 401 and 402 only hash certificates and metadata (presumably, vehicle signatures only include messages and possibly metadata as well). Thus, by including the intended verification public key ? in the hash, the implicit Schnorr protocol 403 is able to thwart attacks against several keys at once. This effective measure may be implemented for all signatures (not only those of certificates, but future ones generated and verified by vehicles using their certified keys) to improve robustness of the public keys. PCA 105 then generates a signature based at least in part on the hash and a private key u, encrypts the certificate and the signature with the public key, and sends the encrypted certificate and signature to the device.

[0043] In some embodiments, the implicit Schnorr protocol 403 further provides implicit private key recovering at the vehicle 102a. The old implicit private key recovering equation used in the existing implicit protocol 402, involves a modular multiplication.

Instead, in the implicit Schnorr protocol 403, at the vehicle 102a, private key recovering is implemented via which only involves a modular addition. In this way, the

implicit Schnorr protocol 403 can implement private key recovering in a fast and more efficient manner to defend against side channel leaks without loss of efficiency, and the implementation structure matches the corresponding computation that has been used the explicit protocol 401.

[0044] In some embodiments, the implicit Schnorr protocol 403 adopts implicit private key verification. In the existing implicit scheme 402, while other vehicles implicitly trust the PCA 105 by mixing its public key ? with the received key V_i and the hashed certificate h_i, the signing vehicle itself performs no verification at all of the received encrypted certificate, e.g., ℎ

This might be a point of protocol security failure. To prevent the potential protocol security failure, the implicit Schnorr protocol 403 adopts a mechanism in which the received key element s_ig_i is formally similar to a signature element. For example, in the existing implicit scheme 402, the vehicle 102a-b can verify the received certificate (and hence its private key) by checking that . In the implicit Schnorr protocol 403, the vehicle

102a-b does it by checking that Although the private key recovering

in the implicit Schnorr protocol 403 may incur either a full-length (old scheme) or half-length (new scheme) multiplication by scalar, such private key recovering scheme may be used as a security measure against potential threats that have not been previously addressed by existing protocols.

[0045] In some embodiments, the implicit Schnorr protocol 403 implicit public key recovering. The existing implicit protocol 402 adopts a public key recovering equation, ?_? which involves a multiplication by scalar where the curve point is different for each

vehicle. No optimization opportunities are clear in this approach for a generic choice of the underlying elliptic curve. The implicit Schnorr protocol 403 adopts a public key recovering equation as

, which involves a multiplication by scalar where the curve point (namely, the PCA public key is one and the same for all vehicles, so that dedicated code and

precomputation could be adopted to speed up the recovering operation. For instance, if the scalars are 256 bits long and written in hex, namely

for all 0 by precomputing and storing a single, fixed

one could implement the computation of

at a fixed cost of only 63 point additions (rather than 255 point doublings plus an average of 85 further point additions, even if a non-adjacent form (NAF) is adopted). In this way, the implicit public key recovering mechanism provided by the implicit Schnorr protocol 403 can be about 3 to 4 times faster than a plain arithmetic mechanism.

[0046] It is worth noting that an isochronous implementation may not be necessary for the public key recovering operation described above, as all quantities involvingℎ_?and ? are public. The fixed, shared precomputed table occupies exactly 32 KB at the classical 128-bit security level with 256-bit keys.

[0047] In some embodiments, the implicit Schnorr protocol 403 adopts implicit PCA signing. The implicit PCA signing equation adopted by the existing implicit protocol 402, e.g., involves a modular multiplication where both factors are different for each

vehicle. No optimization opportunities are clear in this approach. Instead, the implicit Schnorr protocol 403 adopts a PCA signing equation ? which involves a modular

multiplication where one of the factors (namely, the PCA private key ?) is one and the same for all vehicles, so that a similar precomputed table lookup technique as above can be adopted to speed up certificate generation. [0048] In this case, however, because the fixed factor is private, one needs to adopt an isochronous approach as shown in Table 1

defined for the p-th step, which would involve an isochronous sequential search for the proper hex digitℎ_?,? among the 16 possibilities and subsequently a modular addition is integrated into the

accumulator (the modular reduction can even be postponed until the end, since the sum of 64 values will be no more than 256 + 6 bits long).

Schnorr variants

[0049] In some embodiments, if a Schnorr-style scheme at the ?-bit security level is used for all signatures, so that modular integers are 2? bits long (full-length), but hash values can be only ? bits long (half-length), because the Schnorr-style signatures only require preimage resistance. Here, it is assumed that the signature scheme hashes the intended verification key together with the nonce and the metadata or message.

[0050] Let L denote the cost of one full-length multiplication by scalar. Here the costs of hashing or performing a simple point addition may be ignored, as they tend to be much smaller than the other involved costs (for instance, the cost of one point addition is roughly only a fraction 1/?2?? of L, which is small at practical security levels). The most common form of a Schnorr-style signature for a message m under a key pair

corresponding to a signing process where the signer samples a pseudo-random integer ? and computes

Other forms of the Schnorr-style signature are also possible, e.g., a security equivalent and interchangeable form is ??, ??, whereby verification consists of computingℎ ^ℋ??, ?, ?? and checking whether ?

Implicit vs. explicit protocols

[0051] In some embodiments, if the PCA 105 issues a key pair

an example scenario of use of vehicular keys may include: vehicle

signs some message using its private key ?_?and sends it to vehicle (e.g., 102b) together with the certificate rom which the public key

can be extracted (explicit variant) or

inferred (implicit variant), and then used to verify the signed message. The certificate

prepared by the PCA 105, contains either

itself and a signature

such that

in the explicit variant, or else a point ?_? such that

in the implicit variant. To sign ?_? under

vehicle A samples a pseudo-random integer computes assembles the

signature

Afterwards, vehicle B verifies the signed message by checking that

Relative efficiency

[0052] As described above, the implicit form may have an efficiency advantage over the explicit form. Indeed, recovering the implicitly verified key ?_? requires only a half-length multiplication by scalar, while an explicitly verified key incurs one full-length and one half- length multiplications. This may be true if the explicit form adopts the more common

signature form. However, if the alternative form is adopted instead, the implicit form may

not appear to have a significant advantage.

[0053] Specifically, upon receiving an implicit certificate together with a message ?

signed as

, vehicle ? must recover at the cost / of a half-

length multiplication by scalar, then verify the signature on by checking that

at the cost of a full-length multiplication by scalar and a half-length

multiplication by scalar, or roughly 3 Therefore, the combined cost is 2?. This cost does

not change whichever alternative signature form, is adopted.

[0054] By comparison, with signatures in the alternative form upon receiving an

explicit certificate signed as together with a message ?_? signed as

by vehicle ? can verify the certificate and the signed message in batch, by computing

and checking whether

at a cost of a full-length multiplication by scalar and two half-length

multiplications by scalar, or roughly 2?. This is essentially the same cost as the implicit variant.

[0055] Therefore, the implicit variant and the explicit form may achieve comparable processing efficiency (with the implicit variant may possess a marginal advantage when

is used). It is worth noting that this assessment is not affected by the availability of table-based implementations as suggested previously: both the implicit and the explicit forms would benefit equally from it, and the overall cost would decrease to ?3/2 + ??? if the actual cost of computingℎ_?∙ ? were only ?? (0<?≪ 1? rather than ?

Attacking and defending batch verification

[0056] In general, batch verification is usually deployed with care to prevent attacks. The implicit Schnorr protocol 403, however, contains a butterfly protocol that automatically protects against such attacks. For example, the attacks on multisignatures as proposed by M. Bellare and G. Neven (discussed in“Multisignatures in the Plain Public-Key Model and a General Forking Lemma.” Proceedings of the 13th ACM Conference on Computer and Communications Security (CCS 2006), pp.390–399, 2006, DOI: 10.1145/1180405.1180453) do not necessarily affect the implicit Schnorr protocol 403. The reason is that the very countermeasure adopted in the aforementioned Bellare-Neven work, namely multiplying each involved public key by a different hash, is already embedded in the scheme definition of the implicit Schnorr protocol 403 (more precisely, the signatures here never cease to be individual rather than collective). In addition, naive multisignatures require the same hash value to be signed by all participants, and the Bellare-Neven scheme thwarts it by forcing independent hash values to be signed. In the implicit Schnorr protocol 403, the hash values are naturally different to begin with, only the verification process is expedited by the batch mechanism.

The key faking attack

[0057] If ? is a genuine public key and an attacker is allowed to pick their public key ?¢ at will, the attacker can mount the following attack. The attacker's goal is to come up with fake signatures ^??, ?^? for a message ? and for a message ?¢ that will likely not verify

separately (nor are they required to), e.g., most likely

, but that do verify in batch, i.e.

, , To attain that attack goal, the attacker chooses points ? and ?¢ and integers ? and ?¢ uniformly at random, and messages ? and ?¢ at will. Then the attacker defines

Attack failure against butterflies

[0058] Such key faking attack, however, does not work against the butterfly protocol. One aspect of the butterfly protocols is that the PCA 105 only ever signs the vehicle's public keys. Therefore, the above attack is only meaningful for ? = ? when ? = ?¢ and the attacker, who is not a genuine participant vehicle in the system, intends to convince other vehicles otherwise by sending them fake certificates and messages that would verify in batch. But in that case the attack equation becomes

whereby ?¢ must be provided beforehand as part of its own definition. Thus, the choice of a public key is no longer free as required by the attacker, which therefore thwarts the attack.

[0059] Similar attack variants may fail in a similar way, as there is generally no way other quantities in the attack equation could be chosen as a function of the others: of all curve points involved, ? and ? are given and cannot be changed; the other two points, ? and ?¢, both appear as inputs and outputs of hash functions in the same fashion as ?¢; and finally, the two integers ? and ?¢ are only extractible from the equation by directly solving an instance of the discrete logarithm problem.

[0060] In general, the key faking attack may fail for batch verification of a hierarchy of keys, but potentially may apply when all involved keys are at the same level.

Hierarchical batch verification security

[0061] However, if the butterfly protocol with variant Schnorr-style signatures are insecure with regard to hierarchical batch verification, then the attacker would be able to solve the discrete logarithm problem to extract the two integers ? and ?¢. Specifically, the attacker would be able to retrieve the PCA's private key from ? and the corresponding public key ? alone.

[0062] Indeed, if the attacker, when given ? and ?, could come up with a public key ?¢ and two pairs

satisfying the batch verification equation ¢

hey could apply the Pointcheval-Stern technique of

running the same Turing machine that describes this process with the same randomness input but different hash oracles and end up with three such equations for the same fake signatures ( under three different hash oracles). Thus, even if the attacker did not know the discrete logarithms of ? + ?¢ and ?¢ (let alone that of ?) to the base ?, in the end the attacker may get a determinate linear system in those three unknowns, and thus recover the private key corresponding to ?.

Post-Quantum Butterfly Key Expansion for Vehicular Communications

[0063] In some embodiments, the Elliptic-curve cryptography (ECC) based protocols may be extended to quantum-resistant schemes as long as those schemes support both encryption and signatures under the same key pair. For example, in all schemes, the PCA 105 encrypts the certificate under

which apart from an offset ? is functionally the same key

that will be later used to verify signatures. This requires the encryption and signing key pairs to have the same algebraic/combinatorial nature. However, while this is possible in the ECC setting, such scheme precludes most post-quantum candidate cryptosystems. Specifically, it precludes hash-based schemes (which only support signatures), multivariate schemes (which mostly support signatures, while encryption/key encapsulation mechanism (KEM) are much less scrutinized for security and require entirely different algorithms and parameters), code-based and isogeny-based schemes (which mostly support encryption/KEM, while signatures are very hard to obtain, inefficient when available, and require entirely different parameters). However, in general it does not preclude lattice-based cryptosystems, in particular those schemes that rely on the Ring-learn-with-errors (RLWE) assumption (specifically where keys have the form

? + ?_? for short private vectors ?_? and ? sampled from a suitable distribution and ? is a uniformly random public vector), as both encryption and signature schemes are known to differ in much less disparate ways than in other families of post-quantum proposals. Therefore, with a proper choice of algorithms and, above all, distributions and parameters, it is possible to attain the same functionality with post-quantum protocols with the ECC protocols.

[0064] In some embodiments, blind transference of LWE samples can be used for RLWE version of post-quantum protocols, which provides the possibility of blind transferences of elliptic curve points. In the post-quantum setting, it depends on the existence of an RLWE-based encryption (more precisely, key encapsulation) scheme and a digital signature scheme that can sport additively homomorphic keys, share the same key pair for their individual operations, and are similarly secure for the same set of distributions and parameters. Specifically, the sum of two private keys

and

s still an algebraically admissible private key

,

The sum the corresponding public keys ? and ?¢ is still an

algebraically admissible public key and is so the same key that naturally corresponds to the sum of public keys. This can be achieved, for instance, when the keys have the form ?

a

[0065] In some embodiments, a lattice-based analogue of the ECC-based explicit protocol can be achieved, e.g., with (a minor variant of) the qTESLA digital signature scheme and the Lyubashevsky-Peikert-Regev (LPR) key encapsulation scheme further described below in relation to FIGS.5A-5B. It is worth noting that any digital signature scheme and key encapsulation scheme that is purely based on RLWE or LWE would work with the post-quantum butterfly key expansion discussed throughout this disclosure.

[0066] FIG.5A provides an example logic flow diagram illustrating an example RLWE- based component scheme 500a for the use of butterfly effect protocols, known as the qTESLA digital signature scheme, according to some embodiments. Let ? be a permutation that sorts the components of a ring element u in decreasing order of their absolute magnitudes, i.e. |

⋯

In what follows, ???_?(?) denotes the i-th largest component of ? in absolute value, that is,

Furthermore, for any integer ? and for a given parameter ?, [

denotes the unique integer in such that _? mod the centered ?

least significant bits of ?) and [?]_? denotes the value (i.e. the corresponding

centered most significant bits of ?, with [?]_? and ?_? denoting the application of these operations to all coefficients of ?.

[0067] The qTESLA digital signature scheme 500a starts at process 502, where a vehicle (e.g., 102a) computes key generation with the parameters ℎ where n denotes the

dimension of the key; ? denotes a permutation that sorts the components of a ring element u in decreasing order of their absolute magnitudes q denotes a prime number; and are the

chosen the qTESLA parameters that bound the random sampling; and G denotes a uniformly sampled ring element. Specifically, at sub-process 506, ? is sampled from ?_? ^? until

?^?? max_? ( At sub-process 508, ? is sampled from ?_? ^? until

sub-process 510, the scheme computes

At sub-process 512, the vehicle sets the public key as ?, and the secret key as

[0068] At process 503, PCA 105 signs with parameters

Specifically, at sub-process 514, parameter ? is sampled uniformly from

process

, computes

Next, if max_?(? scheme 500a restarts. Otherwise, scheme 500a proceeds to sub-

process 518 to compute

at sub-process 518. If ? or

the scheme 500a restarts. Otherwise, scheme 500a generates signature s usually represented as a short raw hash value) at subprocess 520.

[0069] At process 504, the vehicle verifies the signatures with parameters

Specifically, if the vehicle rejects the

signature at 522. Otherwise, the scheme 500a proceeds to sub-process 524 to compute

the vehicle rejects the signature at

522, otherwise the vehicle accepts the signature at 526.

[0070] FIG.5B provides an example logic flow diagram illustrating an example RLWE- based component scheme 500b for the use of butterfly effect protocols, known as the

Lyubashevsky-Peikert-Regev (LPR) digital signature scheme, according to some embodiments. The LPR scheme is a variant of the Gentry-Peikert-Vaikuntanathan (GPV) dual scheme

(discussed in C. Gentry, C. Peikert, and V. Vaikuntanathan. "Trapdoors for hard lattices and new cryptographic constructions". STOC 2008, pp.197-206, 2008, which is hereby expressly incorporated by reference herein in its entirety), which in turn is a dual variant of the original Regev cryptosystem (discussed in O. Regev. "On lattices, learning with errors, random linear codes, and cryptography." STOC 2005, pp.84-93, 2005, which is hereby expressly incorporated by reference herein in its entirety). One of the differences is that, in LPR, both the public key and the encryption nonce are (R)LWE samples, while in GPV and Regev either the nonce or the public key are syndromes of an (R)LWE sample.

[0071] In what follows, ? Îℕ is the lattice dimension, ? Îℕ is a prime, ? and ? are suitable distribution parameters, and ? Î ?_? ^× is a uniformly sampled ring element (which is shared among the users in the present scenario, but elsewhere could be individually chosen as part of the public key). The encryption base ? naturally corresponds to the signing base ? and hence both are represented with the same notation. Here, uppercase letters are used to denote long, uniformly random ring elements, and lowercase letters are used to denote short ring elements.

[0072] At process 532, the vehicle (e.g., 102a) performs key generation using parameters (?, ?, ?). Specifically, at subprocess 536, the vehicle samples

from un At

subprocess 538, the vehicle computes At sub-process 540, the vehicle sets

the public key as ?, and the secret key as ?. Here, the e component remains secret but is not further used.

[0073] At process 533, the PCA (e.g., 105) performs encryption based on parameters

where l denotes the encryption length. Specifically, at sub-process

542, the PCA samples At sub-process 544, the PCA encodes ? as ?

truncat

ed to, ? out of ? coefficients. At sub-process 546, the PCA computes the

ciphertext

[0074] At process 534, the vehicle decrypts the cipher text based on

, , , ,

Specifically, at sub-process 548 the vehicle computes At sub-process 550, for all

[0075] Here,

Thus the decryption will be correct as long as

is within the error threshold of decoding, If ? is less than ? bits long (as

it typically indeed is, since it stands for an ephemeral symmetric key at the desired security level, long as compared to ? = 1024, or ? = 256 bits long as compared to

? = 2048 the ? component of the cryptogram ( or a capsule in a KEM) can be restricted to its

first ? bits, thereby considerably reducing bandwidth occupation and slightly speeding up both encryption and decryption.

[0076] The RLWE-based component schemes described in Figures 5A-5B provide a post- quantum secure approach for issuing multiple pseudonym certificates from a small piece of information, while traditionally most encryption schemes are vulnerable to post-quantum attacks (e.g., in a traditional SCMS). Thus, the RLWE-based component schemes described in Figures 5A-5B improves long-term security of SCMS.

[0077] FIG.6 provides an example table that compares the ECC-based (pre-quantum) and the lattice-based (post-quantum) variants of the explicit butterfly protocol, according to some embodiments described herein. Here, ? denotes the random sampling of a value u from

the 0-centered discrete Gaussian distribution onℤ with standard deviation ?. Additionally, ?

denotes the pseudo-random sampling of a value ? from the 0-centered discrete

Gaussian distribution onℤ

with standard deviation ?, taking seed as the seed of the pseudo- random sampler.

[0078] Specifically, in the lattice-based post-quantum variants of the explicit butterfly protocol 602, the vehicle 102a starts by generating a caterpillar private/public key pair. In this case, however, the private caterpillar key has two components, the short ring elements (s and e), which are obtained by random sampling the zero-centered discrete Gaussian distribution ?_? ^? with standard deviation s. The corresponding public caterpillar key is then computed as S =s·G+e, which corresponds to a ring element following the LWE distribution and, thus, is

indistinguishable from random. This public caterpillar key S is then sent to the RA 108 along with two suitable pseudo-random functions f(i) and g(i) that deterministically emulate sampling from ?_? ^? with i as seed.

[0079] The RA 108 then uses the public caterpillar key S as well as the pseudo-random

outputs from pseudo-random functions f(i) and g(i), for generating b public cocoon public keys

Then, the RA 108 shuffles keys from different vehicles (as

described in FIG.2) and sends the batch of cocoon keys to the PCA 105.

[0080] After receiving a cocoon key ? the PCA 105 computes the vehicle’s public butterfly

?

In this process, the randomization factors are

generated to prevent the RA 108 from learning the vehicle’s actual butterfly key. Instead of using a single random factor ?_? sampled fromℤ as use in the existing explicit protocol 601, the

factors are obtained by pseudo-random sampling the zero-centered discrete Gaussian

distribution with standard deviation s, meaning that ?_?, ?_? can be recovered by the requesting vehicle as long as the requesting vehicle is provided with the pseudo-randomness source seed i.

[0081] The corresponding pseudonym certificate is then created by the PCA 105. Namely, the PCA 105 signs the vehicle’s public butterfly key U_i, along with any required metadata (meta), using the qTESLA signature scheme described in FIG.5A and the PCA’s own private key u. The set (seed i, meta, sigi ) is then encrypted using so only the vehicle who sent the

request is able to decrypt the resulting package pkg. Subsequently, the encrypted package pkg is then sent to the RA 108, which forwards the package to the vehicle 102a.

[0082] Finally, the vehicle 102a decrypts the RA’s response using the private key

thus recovering the set (seed i, meta, sig_i ). Here, this set does not contain

the public key U_i itself, but just the (more compact) seed i that enables its computation.

Therefore, the vehicle 102a first computes the public key

. The vehicle 102a then checks the PCA’s signature sigi and, if the

verification is successful, sets its i-th pseudonym certificate to ce The

qTesla private signature key corresponding to U is thus, To ensure

that this private key (u_i, w_i) is correct, the vehicle 102a also verifies that ?

Blind Transference of LWE Samples

[0083] In some embodiments, the scheme requires the private key samples to

satisfy and meaning these conditions must hold for ?_? and ?_? as well.

Yet, the PCA 105 cannot check this for the since the PCA does not know ?

or ?_?. This will force the vehicle 102b to reject the received key if it fails to pass the checks, as it might otherwise cause genuine signatures not to verify. Fortunately, it is possible to choose parameters such that the probability of key rejection is fairly low, so that instead of receiving a fixed number of keys from the PCA 105, the vehicle 102b obtains a variable amount (albeit very close to the expected value). This also compensates for the possibility of decryption failure for the LPR scheme (although this should be negligible, even though one must use qTESLA parameters and keys). In principle, this increases the chance of rejection during signing, since the probability of decryption failure grows in the opposite direction as the chance of key rejection. [0084] To mitigate this issue, especially-tailored parameters can be constructed that keep both key and signing rejection under control. Even the actual rate of plain signature restarts ( an unavoidable but predicted and controlled phenomenon that is in the nature of most if not all LWE-based signatures) was actually observed to be very close to the typical q rate

(specifically, approximately 38.8% as compared to a design value of 40%).

[0085] In some embodiments, the blind transference of samples may be defined

through the following definitions:

Definition 1. sample is a ring element sampled from the (zero-centered) Gaussian distribution onℛ with parameter

Let and be uniformly sampled from The (R)LWE assumption for a sample of form

(where ? and ? are "short" ?-samples) is that distinguishing between ? and ? is hard.

Definition 2. A ring element of form , where ? and ? are ?-samples, will be called

?-indistinguishable (from a uniform random sample) under the (R)LWE assumption.

Here it is assumed that the (R)LWE assumption holds at the desired security level for all ? Î where If so, then the vehicle's ring elements, of form ? for

-samples and are -indistinguishable from the point of view of the RA 108, the PCA 105, and other vehicles. The RA’s ring elements, of form ?

simulating ?_?-sampling, are -indistinguishable from the point of view of the PCA 105 and other vehicles (unless they too know which are supposed to be known only by the vehicle and the RA 108). This is because the RA 108 is essentially masking the ?_?- indistinguishable element ? with another ?_?-indistinguishable element, yielding a ring element identical to that obtained from ring elements ? , which are themselves

identical to ?2?_?-samples by virtue of being the sum of two ?_?-samples each. The ring elements signed by the PCA 105, of form

for ?_?-samples ?_? and ?_?, are

indistinguishable from the point of view of the RA 108 and other vehicles. This is because the PCA 105 is essentially masking the indistinguishable element with a

indistinguishable element, yielding a ring element identical to that obtained from (the vehicle's new secret) ring elements

which are themselves identical to _?

samples by virtue of being the sum of a sample and a ?_?-sample each.

Signature Scheme

[0086] In some embodiments, signing only requires functions

and to

deterministically emulate sampling from

with ? as the seed. Accordingly, the PCA 105 must sample and Î from ?

_? and encryption will impose additional constraints on these functions.

[0087] From the R assumption, is indistinguishable from uniformly

random for ? and ? sampled with distribution parameter ?, while the

are indistinguishable from uniformly random for ?

and

sampled with distribution parameter

Ö by virtue of these secret components being each the sum of 2 identically parametrized Gaussian variables, namely

and the

are indistinguishable from uniformly random for ?_? and ?_? sampled with distribution parameter

virtue of these secret components being each the sum of 3 such variables, namely and

The actual scheme parameters are to be chosen to remain secure at the

desired level or above for all of these distribution parameters. Furthermore, the parameters ensure that all signature operations are efficient with distribution parameter (and related

quantities, e.g., the qTESLA parameters and since the final certificate is equivalent to

keys prepared according to this setting.

[0088] Encryption requires functions

to deterministically emulate sampling from with as the seed, until that is, they are both invertible.

Accordingly, the PCA 105 samples until Like the secret ?

component, the ̂ and components need not actually be computed, nor Î_? kept after the

certificate generation. Here, set

to bridge the qTESLA and LPR notations. From the RLWE assumption, indistinguishable from uniformly random for ? (and ?)

sampled with distribution parameter ? while the

̅Gare indistinguishable from

uniformly random for (and ? sampled with distribution parameter

Ö

by virtue of these

secret components being each the sum of 2 identically parametrized Gaussian variables, namely

[0089] In some embodiments, encryption occurs in the scheme only under the key pair

(and implicitly ?̂_?), so in principle the actual scheme parameters could be chosen under this premise, but the final signature key pair already forces a more stringent condition. If the final key pair is used not only for signatures but for encryption as well, then the parameters are usually double-checked (although the requirements for encryption tend to be less stringent than those for signatures, e.g. the distributions need not be as precise).

Bandwidth Requirements

[0090] In some embodiments, a public certificate ????_? contains: a q public key of

size A general q signature would include a K-bit seed for the pseudo-

random choice of the base ?, but this is omitted here since the same ? must be used systemwide

to preserve the vehicle's anonymity. Metadata of unspecified size includes ^|

A signature ???_? has a size bits (more precisely, a hash

value of size K bits and a ring element inℛ with 0-centered coefficients not exceeding

in absolute value). Hence the bandwidth requirement of the public certificate cert_i has a size of

[0091] In some embodiments, an encrypted clipped certificate ??? contains a LPR capsule bits (where ? is the encryption nonce and ?

is the encapsulation of a ?-bit symmetric key), a seed of size

bits for the blind LWE transfer, metadata of unspecified size signature ???_? of

size ^| bits, a MAC tag ?_? of size ^K bits as part of the

authenticated symmetric encryption of the clipped certificate. Hence the encrypted clipped certificate has a size of ^|

[0092] The embodiments described above illustrate but do not limit the invention. For example, the techniques described for vehicles can be used by other mobile systems, e.g.

pedestrians’ smart phones or other mobile systems equipped with computer and communication systems 150. The term“vehicle” is not limited to terrestrial vehicles, but includes aircraft, boats, space ships, and maybe other types of mobile objects. The vehicle techniques can be also be used by non-mobile systems, e.g. they can be used on a computer system. [0093] The invention is not limited to the embodiments described above. Other embodiments and variations are within the scope of the invention, as defined by the appended claims.

Claims

CLAIMS What is Claimed is:

1. A method for providing digital certificates for use by devices in authentication operations, the method comprising:

receiving, by a first entity, a cocoon public key for generating a digital certificate, wherein the cocoon public key is generated by expanding a caterpillar public key with a random function and the first entity is uninformed of which device the caterpillar public key is originated from; generating butterfly reconstruction credentials based on the cocoon public key and a random value;

generating a certificate based on the butterfly reconstruction credentials and metadata; generating a hash value of both the certificate and a verification public key reserved for the first entity;

generating a signature based on the random value, the hash value and a verification private key associated with the verification public key;

encrypting the certificate and the signature using the cocoon public key; and

sending an encryption package from the encrypted certificate and signature to a second entity, wherein:

the second entity is unable to decrypt the encryption package, and the encryption package is forwarded from the second entity to a requesting device.

2. The method of claim 1, further comprising;

sampling the random value from a multi-dimensional space; and

generating the signature by adding the random value and a product of the hash value and the verification private key.

3. The method of claim 2, wherein the generating the signature further comprises using an isochronous table lookup to speed up signature generation based on a fixed factor of the verification private key.

4. The method of claim 3, further comprising:

performing an isochronous sequential search for a hex digit among 16 possibilities, and a modular addition into an accumulator.

5. A method for using digital certificates in authentication operations, the method comprising:

receiving, at a device and from a first entity, an encryption package forwarded by a second entity that is unable to decrypt the encryption package;

generating a private cocoon key for decrypting the encryption package based on a private key associated with the device and a random function;

decrypting the encryption package using the private cocoon key into a certificate and a signature;

generating a hash value of both the certificate and a verification public key reserved for the first entity;

generating a verification private key reserved for the device based on the private cocoon key and the signature;

generating a verification public key reserved for the device based on the verification public key reserved for the first entity, the hash value and butterfly reconstruction credentials; and

verifying that the generated verification public key reserved for the device and the generated verification private key satisfies a relationship.

6. The method of claim 5, further comprising:

in response to verifying that the generated verification public key reserved for the device and the generated verification private key reserved for the device satisfies a relationship, using the generated verification public key reserved for the device and the generated verification private key reserved for the device for signing a message to be sent to another device.

7. The method of claim 5, further comprising:

originating a request to generate the certificate at the first entity by:

randomly picking a private caterpillar key and generating a public caterpillar key according to the relationship, and sending the public caterpillar key to the second entity.

8. The method of claim 7, wherein the first entity not being informed with which device the certificate is associated, and wherein the certificate is to be transmitted to the device in the encryption package from which the certificate is recoverable.

9. The method of claim 5, wherein the verification public key reserved for the device involves a multiplication of the hash value and the verification public key reserved for the first entity.

10. The method of claim 9, wherein the multiplication is performed via precomputing possibilities of a product of the hash value and the verification public key reserved for the first entity into a fixed lookup table.

11. A computing device for providing digital certificates for use by devices in authentication operations, the computing device comprising:

a memory containing machine readable medium storing machine executable code;

one or more processors coupled to the memory and configured to execute the machine executable code to cause the one or more processors to:

receive, by a first entity, a cocoon public key for generating a digital certificate, wherein the cocoon public key is generated by expanding a caterpillar public key with a random function and the first entity is uninformed of which device the caterpillar public key is originated from;

generate butterfly reconstruction credentials based on the cocoon public key and a random value;

generate a certificate based on the butterfly reconstruction credentials and metadata;

generate a hash value of both the certificate and a verification public key reserved for the first entity;

generate a signature based on the random value, the hash value and a verification private key associated with the verification public key; encrypt the certificate and the signature using the cocoon public key; and

send an encryption package from the encrypted certificate and signature to a second entity, wherein:

12. The computing device of claim 11, wherein the one or more processors are further configured to execute the machine executable code to cause the one or more processors to:

sample the random value from a multi-dimensional space; and

generate the signature by adding the random value and a product of the hash value and the verification private key.

13. The computing device of claim 12, wherein the one or more processors are further configured to execute the machine executable code to cause the one or more processors to generate the signature by using an isochronous table lookup to speed up signature generation based on a fixed factor of the verification private key.

14. The computing device of claim 13, wherein the one or more processors are further configured to execute the machine executable code to cause the one or more processors to perform an isochronous sequential search for a hex digit among 16 possibilities, and a modular addition into an accumulator.

15. A computing device for using digital certificates in authentication operations, the computing device comprising:

a memory containing machine readable medium storing machine executable code;

receive, at a device and from a first entity, an encryption package forwarded by a second entity that is unable to decrypt the encryption package;

generate a private cocoon key for decrypting the encryption package based on a private key associated with the device and a random function;

decrypt the encryption package using the private cocoon key into a certificate and a signature;

generate a verification private key reserved for the device based on the private cocoon key and the signature;

generate a verification public key reserved for the device based on the verification public key reserved for the first entity, the hash value and butterfly reconstruction credentials; and

verify that the generated verification public key reserved for the device and the generated verification private key satisfies a relationship.

16. The computing device of claim 15, wherein the one or more processors are further configured to execute the machine executable code to cause the one or more processors to:

in response to verifying that the generated verification public key reserved for the device and the generated verification private key reserved for the device satisfies a relationship, use the generated verification public key reserved for the device and the generated verification private key reserved for the device for signing a message to be sent to another device.

17. The computing device of claim 15, wherein the one or more processors are further configured to execute the machine executable code to cause the one or more processors to:

originate a request to generate the certificate at the first entity by:

randomly picking a private caterpillar key and generating a public caterpillar key according to the relationship, and

sending the public caterpillar key to the second entity.

18. The computing device of claim 17, wherein the first entity not being informed with which device the certificate is associated, and wherein the certificate is to be transmitted to the device in the encryption package from which the certificate is recoverable.

19. The computing device of claim 15, wherein the verification public key reserved for the device involves a multiplication of the hash value and the verification public key reserved for the first entity.

20. The computing device of claim 19, wherein the multiplication is performed via precomputing possibilities of a product of the hash value and the verification public key reserved for the first entity into a fixed lookup table.

21. A method for using a ring-learning-with-errors (RLWE) based post-quantum protocol to provide digital certificates for use by devices in authentication operations, the method comprising:

receiving, by a first entity, a cocoon public key for generating a digital certificate, wherein the cocoon public key is generated by expanding a caterpillar public key with a first random function and a second random function, and the first entity is uninformed of which device the caterpillar public key is originated from;

generating a verification public key reserved for the device based on the received cocoon public key, a first pseudo-random value and a second pseudo-random value sampled from a 0- centered discrete Gaussian distribution on a first multi-dimensional space with a first standard deviation value according to a pseudo-random sampler having a seed value;

generating a signature over the verification public key reserved for the device along with metadata, a verification public key reserved for the first entity and a private key pair reserved for the first entity;

encrypting a set of the seed value, the metadata and the signature into an encryption package; and

sending the encryption package to a second entity, wherein:

22. The method of claim 21, wherein the cocoon public key is generated by the second entity using ring elements based on the first random function and the second function simulating sampling from the 0-centered discrete Gaussian distribution on the first multi-dimensional space with the first standard deviation value,

wherein the ring elements are indistinguishable by the first standard deviation value times a square root of two from a point of view of the first entity and other devices.

23. The method of claim 21, wherein the signature is generated by:

signing ring elements composed of the verification public key reserved for the device generated based on the first pseudo-random value and the second pseudo-random value,

wherein the ring elements are indistinguishable by the first standard deviation value times a square root of three from a point of view of the registration authority entity and other devices.

24. The method of claim 27, wherein the signature is recoverable from the encryption package along with the seed value at the device.

25. The method of claim 21, further comprising:

sampling a first random value and a second random value from the 0-centered discrete Gaussian distribution on the first multi-dimensional space with the first standard deviation value; sampling a third random value from the 0-centered discrete Gaussian distribution on a second multi-dimensional space with the first standard deviation value, wherein the second multi-dimensional space has a dimension corresponding to an encryption length;

encoding a message by truncating a size of the message to the encryption length; and computing a cyphertext based at least in part on the first random value, the second random value, the third random value and the encoded message.

26. The method of claim 25, further comprising:

returning the cyphertext to the device, wherein the cyphertext is decrypted at the device based at least in part on a secret key.

27. A method for using a ring-learning-with-errors (RLWE) based post-quantum protocol to verify digital certificates for use by devices in authentication operations, the method comprising: receiving, at a device and from a first entity, an encryption package forwarded by a second entity that is unable to decrypt the encryption package;

generating a private cocoon key pair for decrypting the encryption package based on a caterpillar private key pair associated with the device, a first random function and a second random function;

decrypting the encryption package using the private cocoon key pair into a set of a seed value, metadata and a signature;

generating a verification public key reserved for the device based on a public cocoon key, a first pseudo-random value and a second pseudo-random value sampled from a 0-centered discrete Gaussian distribution on a first multi-dimensional space with a first standard deviation value according to a pseudo-random sampler having the seed value;

generating a verification private key pair reserved for the device based on a private cocoon key pair, the first pseudo-random value and the second pseudo-random value; and

verifying that the generated verification public key reserved for the device and the generated verification private key pair satisfies a relationship.

28. The method of claim 27, further comprising:

in response to decrypting the encryption package using the private cocoon key pair into the set of the seed value, metadata and the signature, verifying the signature with public key data and the metadata; and

in response to successful verification of the signature, setting a certificate based on the verification public key reserved for the device, the metadata and the signature.

29. The method of claim 27, further comprising:

originating a request to generate the encryption package at the first entity by:

randomly picking a private caterpillar key pair from the 0-centered discrete Gaussian distribution on the first multi-dimensional space with the first standard deviation value; and

generating a public caterpillar key according to the relationship.

30. The method of claim 29, wherein the public caterpillar key is originated at the device based on ring elements that are indistinguishable by the first standard deviation value from the point of view of the first entity or the second entity.

31. A computing device for using a ring-learning-with-errors (RLWE) based post-quantum protocol to provide digital certificates for use by devices in authentication operations, the computing device comprising:

a memory containing machine readable medium storing machine executable code;

receive, by a first entity, a cocoon public key for generating a digital certificate, wherein the cocoon public key is generated by expanding a caterpillar public key with a first random function and a second random function, and the first entity is uninformed of which device the caterpillar public key is originated from;

generate a verification public key reserved for the device based on the received cocoon public key, a first pseudo-random value and a second pseudo-random value sampled from a 0-centered discrete Gaussian distribution on a first multi-dimensional space with a first standard deviation value according to a pseudo-random sampler having a seed value;

generate a signature over the verification public key reserved for the device along with metadata, a verification public key reserved for the first entity and a private key pair reserved for the first entity;

encrypt a set of the seed value, the metadata and the signature into an encryption package; and

send the encryption package to a second entity, wherein:

32. The computing device of claim 31, wherein the cocoon public key is generated by the second entity using ring elements based on the first random function and the second function simulating sampling from the 0-centered discrete Gaussian distribution on the first multi- dimensional space with the first standard deviation value, wherein the ring elements are indistinguishable by the first standard deviation value times a square root of two from a point of view of the first entity and other devices.

33. The computing device of claim 31, wherein the signature is generated by:

34. The computing device of claim 33, wherein the signature is recoverable from the encryption package along with the seed value at the device.

35. The computing device of claim 21, wherein the one or more processors coupled to the memory are further configured to execute the machine executable code to cause the one or more processors to:

sample a first random value and a second random value from the 0-centered discrete Gaussian distribution on the first multi-dimensional space with the first standard deviation value; sample a third random value from the 0-centered discrete Gaussian distribution on a second multi-dimensional space with the first standard deviation value, wherein the second multi-dimensional space has a dimension corresponding to an encryption length;

encode a message by truncating a size of the message to the encryption length; and compute a cyphertext based at least in part on the first random value, the second random value, the third random value and the encoded message.

36. The computing device of claim 35, wherein the one or more processors coupled to the memory are further configured to execute the machine executable code to cause the one or more processors to:

return the cyphertext to the device, wherein the cyphertext is decrypted at the device based at least in part on a secret key.

37. A computing device for using a ring-learning-with-errors (RLWE) based post-quantum protocol to verify digital certificates for use by devices in authentication operations, the computing device comprising:

a memory containing machine readable medium storing machine executable code;

generate a private cocoon key pair for decrypting the encryption package based on a caterpillar private key pair associated with the device, a first random function and a second random function;

decrypt the encryption package using the private cocoon key pair into a set of a seed value, metadata and a signature;

generate a verification public key reserved for the device based on a public cocoon key, a first pseudo-random value and a second pseudo-random value sampled from a 0- centered discrete Gaussian distribution on a first multi-dimensional space with a first standard deviation value according to a pseudo-random sampler having the seed value;

generate a verification private key pair reserved for the device based on a private cocoon key pair, the first pseudo-random value and the second pseudo-random value; and

verify that the generated verification public key reserved for the device and the generated verification private key pair satisfies a relationship.

38. The computing device of claim 37, wherein the one or more processors coupled to the memory are further configured to execute the machine executable code to cause the one or more processors to:

in response to decrypting the encryption package using the private cocoon key pair into the set of the seed value, metadata and the signature, verify the signature with public key data and the metadata; and

in response to successful verification of the signature, set a certificate based on the verification public key reserved for the device, the metadata and the signature.

39. The computing device of claim 37, wherein the one or more processors coupled to the memory are further configured to execute the machine executable code to cause the one or more processors to:

originate a request to generate the encryption package at the first entity by:

generating a public caterpillar key according to the relationship.

40. The computing device of claim 39, wherein the public caterpillar key is originated at the device based on ring elements that are indistinguishable by the first standard deviation value from the point of view of the first entity or the second entity.