Methods and systems for user security authentication and / or identification
By generating user-specific keys and encryption vectors through inner product encryption technology, the data leakage and decryption requirements in cloud-based biometric authentication are solved, achieving secure and efficient cloud-based biometric authentication and identification.
Patent Information
- Application Number
- CN202580024866.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2024-10-30
- Filing Date
- 2025-03-06
- Publication Date
- 2026-11-17
AI Technical Summary
Existing technologies for cloud-hosted biometric authentication pose risks of biometric data leakage and unauthorized use, and calculating the distance between user biometric features requires decryption, leading to security and privacy issues.
It employs inner product encryption technology, which generates user-specific keys and encryption vectors to calculate the inner product of biometric datasets, avoiding the decryption process, ensuring data privacy, and performing secure authentication and identification in the cloud.
It enables secure calculation of distances between biometric features in the cloud, protecting user privacy, reducing server requirements and management costs, and improving the security and efficiency of authentication and identification.
Smart Images

Figure CN123125834A_ABST
Abstract
Description
Technical Field
[0001] The implementation schemes described herein relate to methods and systems for secure authentication and / or identification of users. Background Technology
[0002] The ability to successfully identify and / or authenticate users is a critical requirement for enabling secure online transactions. One way to achieve this is by using a trusted server to securely store registered biometric readings (templates) from users and calculating the distance between registered biometric readings and newly generated / submitted biometric readings during the authentication / identification process. If the calculated distance is less than or equal to an acceptance threshold T, the user is considered successfully authenticated and / or identified. However, using a trusted server incurs significant costs, both in terms of the space required to house the server and in ensuring its physical security and proper maintenance.
[0003] Hosting biometric-based services in the cloud offers a more attractive alternative because it reduces the need to purchase servers, facilities, etc., instead enabling the adoption of lighter-weight subscription-based services. However, biometric matching methods used in conventional models require the server to decrypt user biometrics before calculating the distance between them. From a cloud-based server security perspective, this is unacceptable because cloud-based servers are considered to be at greater risk of compromise. Damage to the data during computation (i.e., when the data is not encrypted) can lead to the leakage of user biometrics (i.e., highly sensitive information). Furthermore, cloud-based servers can attempt to read and use data in unauthorized ways.
[0004] Therefore, it is desirable to provide an apparatus for supporting the calculation of distances between user biometrics in a privacy-preserving manner, so as to support cloud-hosted biometric authentication and / or identification services. Summary of the Invention
[0005] According to a first aspect of the present invention, a computer-implemented method is provided, comprising:
[0006] Receive the first dataset from the user at the first point in time;
[0007] Upon receiving the first dataset:
[0008] Perform feature extraction on the first dataset to obtain the first feature vector;
[0009] Generate the first integer vector representation of the first feature vector;
[0010] Generate a user-specific key using the first integer vector representation and the master key; and
[0011] Send the user ID and user-specific key to the remote server.
[0012] The first dataset may include biometric data.
[0013] The integer vector representation for generating the first feature vector may include:
[0014] Calculate the norm of the first eigenvector;
[0015] Divide each value in the first eigenvector by the norm; and
[0016] Round or scale the value of the first feature vector to an integer value.
[0017] The method may also include:
[0018] Receive the second dataset at a later point in time;
[0019] Upon receiving the second dataset:
[0020] Perform feature extraction on the second dataset to obtain a second feature vector;
[0021] Generate a second integer vector representation of the second feature vector;
[0022] A second integer vector representation of the encrypted version is generated using the master key; and
[0023] Send the encrypted version, represented by the second integer vector, to the remote server.
[0024] The method may also include:
[0025] Send the user ID and an encrypted version of the second integer vector to the remote server.
[0026] The second dataset may include biometric data.
[0027] The second integer vector representation for generating the second feature vector may include:
[0028] Calculate the norm of the second eigenvector;
[0029] Divide each value in the second eigenvector by the norm; and
[0030] Round or scale the value of the second feature vector to an integer value.
[0031] According to a second aspect of the present invention, a computer-implemented method is provided, comprising:
[0032] The server receives a user-specific key and user ID from the user. The user-specific key is generated using: (i) an integer vector representation of a first feature vector and (ii) a master key.
[0033] The server receives an encrypted vector and the claimed user ID from the user, where the vector is encrypted using a master key;
[0034] The server processes the encrypted vector using a user-specific key to obtain the output value;
[0035] The server determines whether the output value is equal to or less than a predetermined threshold; and
[0036] If the output value is less than or equal to the threshold, the declared user ID will be authenticated as the same as the user ID.
[0037] According to a third aspect of the present invention, a computer-implemented method is provided, comprising:
[0038] (i) Receive multiple ciphertexts from the client device at the server, each ciphertext being generated by encrypting the same vector using a different corresponding master secret key, and each ciphertext being accompanied by a tag indicating the corresponding user;
[0039] (ii) The server retrieves from the storage device a user-specific key corresponding to the user indicated by the tag attached to the first ciphertext in the ciphertext;
[0040] (iii) The server processes the first ciphertext in the ciphertext using a user-specific key to obtain the output value;
[0041] (iv) If the output value is less than or equal to a predetermined threshold, determine that the user indicated by the tag attached to the first ciphertext is the user operating the client device;
[0042] (v) If the output value is greater than a threshold, retrieve a second user-specific key corresponding to the user indicated by the tag attached to the second ciphertext in the ciphertext, and have the server process the second ciphertext in the ciphertext using the second user-specific key to obtain a second output value; and
[0043] (vi) If the second output value is less than the threshold, determine that the user indicated by the tag attached to the second ciphertext is the user operating the client device.
[0044] If the second output value is greater than the threshold, the method may include repeating steps (ii) and (iii) for another ciphertext and its corresponding user-specific key until the obtained output value is less than the threshold or a predetermined number of user-specific keys have been retrieved.
[0045] Each dataset can include an image of the user's face.
[0046] According to a fourth aspect of the present invention, a computer-implemented method is provided, comprising:
[0047] Receive the first dataset from the user at the first point in time;
[0048] Perform feature extraction on the first dataset to obtain the first feature vector;
[0049] Generate the binary vector representation A of the first eigenvector;
[0050] Receive the mask used for the first dataset;
[0051] Generate a binary vector representation of the mask for the first dataset. A ;
[0052] Mask is represented using the first binary vector. A Generate a user-specific key using the first master secret key msk;
[0053] Represent the mask as a binary vector. A The binary vector representation A of the first feature vector is applied to obtain the mask template vector A. MASKED ;
[0054] Using mask template vector A MASKED A second user-specific key is generated from the second master secret key;
[0055] Generate a binary vector representation of the mask. A The inverse vector A NOT ;
[0056] Use the inverse vector A NOT A third user-specific key is generated from the third master secret key;
[0057] By using the mask template vector A MASKED Replace all zero entries in the vector with -1 to generate the Hamming vector A. HAMMING ;
[0058] Using Hamming vector A HAMMING And generate a fourth user-specific key from the fourth master secret key; and
[0059] Send the user ID and a first user-specific key, a second user-specific key, a third user-specific key, and a fourth user-specific key to the remote server.
[0060] The method may also include:
[0061] At a later point in time, a second dataset will be received from the user.
[0062] Perform feature extraction on the second dataset to obtain a second feature vector;
[0063] Generate the binary vector representation B of the second eigenvector;
[0064] Receive the mask used for the second dataset;
[0065] Generate a binary vector representation of the mask for the second dataset. B ;
[0066] The Mask is represented by a binary vector using the first master secret key. B Encrypt;
[0067] Representing a Mask as a Binary Vector B The binary vector representation B applied to the second feature vector is used to obtain the second mask template vector B. MASKED ;
[0068] Use the second master secret key to pair the second mask template vector B MASKED Encrypt;
[0069] Obtain the second binary vector representation Mask B The inverse vector B NOT ;
[0070] Use the third master secret key to inverse vector B NOT Encrypt;
[0071] By using the mask template vector B MASKED Replace all zero entries in the vector with -1 to obtain the Hamming vector B. HAMMING ;
[0072] Use the fourth master secret key to manipulate the Hamming vector B. HAMMING Encryption; and
[0073] Send an encrypted binary vector representation of the mask used for the second dataset to a remote server. B Encrypted mask template vector B MASKED Encrypted inverse vector B NOT and the encrypted Hamming vector B HAMMING .
[0074] The method may also include:
[0075] Send the user ID and an encrypted second binary vector representation of the mask used for the second dataset to the remote server. B Encrypted mask template vector B MASKED Encrypted inverse vector BNOT and the encrypted Hamming vector B HAMMING .
[0076] The method may also include:
[0077] Apply one or more shifts to the binary vector representation Mask. B And / or the binary vector representation B of the second feature vector, where each shift represents a shift in the relative alignment of the second dataset with the mask used for the second dataset;
[0078] For each shift, generate an encrypted binary vector representation of the mask for the second dataset. B Encrypted mask template vector B MASKED Encrypted inverse vector B NOT and the encrypted Hamming vector B HAMMING A new version of each of them; and
[0079] Send an encrypted binary vector representation of the mask used for the second dataset to a remote server. B Encrypted mask template vector B MASKED Encrypted inverse vector B NOT and the encrypted Hamming vector B HAMMING A new version of each of them.
[0080] According to a fifth aspect of the present invention, a computer-implemented method is provided, comprising:
[0081] (i) Receive at the server a user ID, a first user-specific key, a second user-specific key, a third user-specific key and a fourth user-specific key from a client registration device used to register users with the server;
[0082] The first user-specific key is a binary vector representation of the mask used at the client registration device. A Generated with the first master secret key,
[0083] The second user-specific key is a second master secret key used at the client registration device and represented by a binary vector mask. A The mask template vector A obtained by applying the binary vector representation A of the first dataset MASKED Generated;
[0084] The third user-specific key is a third master secret key and a binary vector representation of the Mask used at the client registration device. A The inverse vector A NOT Generated;
[0085] The fourth user-specific key is the fourth master secret key used at the client registration device and through the mask template vector A. MASKED The Hamming vector A is obtained by replacing all zero entries in the vector with -1. HAMMING Generated;
[0086] (ii) At the server, receive a first encryption vector, a second encryption vector, a third encryption vector, and a fourth encryption vector from the client authentication device used to authenticate users to the server.
[0087] The first encryption vector is a binary vector representation of the mask using the first master secret key at the client authentication device. B Generated through encryption;
[0088] The second encryption vector is obtained at the client authentication device by using the second master secret key to mask template vector B. MASKED The mask template vector B is generated through encryption. MASKED It is represented by the binary vector of the second mask. B The binary vector representation B applied to the second dataset was obtained;
[0089] The third encryption vector is represented as a binary vector using a third master secret key at the client authentication device. B The inverse vector B NOT Generated through encryption;
[0090] The fourth encryption vector is obtained at the client authentication device by using the fourth master secret key to pair with the Hamming vector B. HAMMING The Hamming vector B is generated through encryption. HAMMING It is achieved by using the mask template vector B MASKED The result was obtained by replacing all zero entries with -1;
[0091] Each encryption vector is processed using one of the user-specific keys to return the corresponding inner product;
[0092] The distance metric between the first dataset when masked by the first mask and the second dataset when masked by the second mask is calculated based on the inner product; and
[0093] Determine whether the output value is equal to or less than a predetermined threshold; and
[0094] The user is authenticated by the server if the output value is less than or equal to the threshold.
[0095] The method may also include:
[0096] The server receives multiple encryption vector sets from the client authentication device. Each encryption vector set includes a first encryption vector, a second encryption vector, a third encryption vector, and a fourth encryption vector, wherein for each encryption vector set:
[0097] The first encryption vector in this set is generated at the client authentication device by applying a corresponding shift to the binary vector representation of the second mask. B To obtain the shifted binary vector representation of Mask B And using the first master secret key to represent the Mask as a shifted binary vector. B Encrypt;
[0098] The second encryption vector is generated at the client authentication device through the following operations: applying a corresponding shift to the binary vector representation B of the second dataset to obtain a shifted binary vector representation of the second dataset, and then applying the shifted binary vector representation Mask... B The shifted binary vector representation applied to the second dataset is used to obtain the mask template vector B for the corresponding shift. MASKED And using the second master secret key to mask the template vector B MASKED Encrypt;
[0099] The third encryption vector is represented at the client authentication device as a shifted binary vector using a third master secret key. B The inverse vector B NOT Generated through encryption; and
[0100] The fourth encryption vector is generated at the client authentication device through the following operations: the mask template vector B is shifted accordingly. MASKED Replace all zero entries in the vector with -1 to obtain the Hamming vector B. HAMMING And using the fourth master secret key to pair the Hamming vector B HAMMING Encrypt;
[0101] The method also includes, for one or more encryption vectors in the encryption vector set:
[0102] Use one of the user-specific keys to process each encrypted vector in the set to return the corresponding inner product;
[0103] The distance metric between the first dataset when masked by the first mask and the second dataset when masked by the second mask is calculated based on the inner product; and
[0104] Determine whether the output value is equal to or less than a predetermined threshold; and
[0105] For a given encryption vector in the encryption vector set, the server authenticates the user if the output value is less than or equal to a threshold.
[0106] According to a sixth aspect of the present invention, a computer-implemented method is provided, comprising:
[0107] (i) At the server, for each of the multiple users, a first user-specific key, a second user-specific key, a third user-specific key and a fourth user-specific key are received and stored;
[0108] For each user:
[0109] The first user-specific key is a binary vector representation of the Mask using the first mask. A Generated with the user's first master secret key;
[0110] The second user-specific key is obtained by using the user's second master secret key and representing the Mask as a binary vector. A The mask template vector A obtained by applying the binary vector representation A of the first dataset MASKED Generated;
[0111] The third user-specific key is the user's third master secret key and a binary vector representation of the Mask. A The inverse vector A NOT Generated; and
[0112] The fourth user-specific key is obtained by using the user's fourth master secret key and by using the mask template vector A. MASKED The Hamming vector A is obtained by replacing all zero entries in the vector with -1. HAMMING Generated;
[0113] (ii) The server receives from the client device a ciphertext group for each user, each group accompanied by a tag indicating the corresponding user, and each ciphertext group includes:
[0114] The first ciphertext is a binary vector representation of the mask using the corresponding user's first master secret key. B Generated through encryption;
[0115] The second ciphertext is created by using the corresponding user's second master secret key to mask the template vector B. MASKED The mask template vector B is generated through encryption. MASKED It is represented by the binary vector of the first mask. B The binary vector representation B applied to the dataset is obtained;
[0116] The third ciphertext, which is the binary vector representation of the Mask using the corresponding user's third master secret key, is used to create the Mask. B The inverse vector B NOT Generated through encryption; and
[0117] The fourth ciphertext, which is obtained by using the corresponding user's fourth master secret key to pair the Hamming vector B HAMMING The Hamming vector B is generated through encryption. HAMMING It is achieved by using the mask template vector B MASKED The result was obtained by replacing all zero entries with -1;
[0118] (iii) Select the first ciphertext group in the ciphertext group;
[0119] (iv) Retrieve the user-specific key indicated by the tag attached to the first ciphertext;
[0120] (v) Use one of the retrieved user-specific keys to process each ciphertext in the first ciphertext group to return the corresponding inner product;
[0121] (vi) Calculate the value of the distance metric based on the inner product; and
[0122] (vii) Determine whether the output value is equal to or less than a predetermined threshold;
[0123] (viii) If the output value is less than or equal to the threshold, determine that the user indicated by the tag attached to the first ciphertext group is the user operating the client device.
[0124] If the output value is greater than a predetermined threshold, the method may include repeating steps (iii) to (viii) for one or more ciphertext groups until the obtained output value is less than the threshold or a predetermined number of ciphertext groups have been selected.
[0125] The method may also include:
[0126] (ii) The server receives from the client device multiple ciphertext groups for each user, each of the multiple groups being accompanied by a tag indicating the corresponding user, and each of the multiple groups including a first ciphertext, a second ciphertext, a third ciphertext, and a fourth ciphertext.
[0127] For each ciphertext group among the multiple groups received from the user:
[0128] The first ciphertext in the corresponding group is generated by applying the corresponding shift to the binary vector representation of the second mask. B To obtain the shifted binary vector representation of Mask BAnd the shifted binary vector representation of Mask using the corresponding user's first master secret key. B Encrypt;
[0129] The second ciphertext is generated through the following operations: applying the corresponding shift to the binary vector representation B of the second dataset to obtain the shifted binary vector representation of the second dataset, and then applying the shifted binary vector representation Mask. B The shifted binary vector representation applied to the second dataset is used to obtain the mask template vector B for the corresponding shift. MASKED And using the corresponding user's second master secret key to mask the template vector B MASKED Encrypt;
[0130] The third ciphertext is a shifted binary vector representation of the Mask using the corresponding user's third master secret key. B The inverse vector B NOT Generated through encryption; and
[0131] The fourth encryption vector is generated by the following operation: taking the mask template vector B for the corresponding shift... MASKED Replace all zero entries in the vector with -1 to obtain the Hamming vector B. HAMMING And using the fourth master secret key to pair the Hamming vector B HAMMING Encrypt;
[0132] The method includes:
[0133] (iii) Select the first ciphertext group from the first ciphertext group among multiple ciphertext groups;
[0134] (iv) Retrieve the user-specific key indicated by the tag attached to the first ciphertext of a plurality of ciphertexts;
[0135] (v) Use one of the retrieved user-specific keys to process each ciphertext in the first ciphertext group to return the corresponding inner product;
[0136] (vi) Calculate the value of the distance metric based on the inner product; and
[0137] (vii) Determine whether the output value is equal to or less than a predetermined threshold;
[0138] (viii) If the output value is less than or equal to the threshold, determine that the user indicated by the tag attached to the first ciphertext group among a plurality of ciphertext groups is the user operating the client device.
[0139] If the output value is greater than a predetermined threshold, the method may include repeating steps (iii) to (viii) for one or more other ciphertext groups in the first ciphertext group of a plurality of ciphertext groups.
[0140] For each of one or more other ciphertext groups in a first ciphertext group among a plurality of ciphertext groups, if the output value is greater than a predetermined threshold, the method may include:
[0141] Select the first ciphertext from the second ciphertext from a set of ciphertexts; and
[0142] Repeat steps (iii) to (viii) for one or more ciphertexts in the second ciphertext group among multiple ciphertext groups.
[0143] Each user-specific key can be generated based on its corresponding master secret key.
[0144] A user-specific key sk can be generated by calculating sk = u + Tx', where:
[0145] x' is the first integer vector representation of the first eigenvector;
[0146] u is a vector of length n + k, where from Z q The elements are randomly and uniformly sampled, where n and q are predefined values, and k is the length of the first feature vector; and
[0147] T is a matrix , where I k S is an identity matrix of size k x k, and S is an n x k matrix of random integer values.
[0148] The first master secret key may include the tuple (u1, S);
[0149] The second master secret key may include the tuple (u2, S);
[0150] The third master secret key can include the tuple (u3, S); and
[0151] The fourth master secret key may include the tuple (u4, S);
[0152] in:
[0153] u1 is the first vector of length n + k, where from Z q The elements are randomly and uniformly sampled.
[0154] u2 is the second vector of length n + k, where from Z q The elements are randomly and uniformly sampled.
[0155] u3 is a third vector of length n + k, where from Z q The elements are randomly and uniformly sampled.
[0156] u4 is the fourth vector of length n + k, where from Z q The elements are randomly and uniformly sampled.
[0157] S is derived from Z. q The n x k matrix of random integer values, where n and q are predefined values, and k is the length of the first eigenvector.
[0158] The first user-specific key sk1 can be generated by calculating sk1 = u1 + Tx1';
[0159] The second user-specific key sk2 can be generated by calculating sk2 = u2 + Tx2';
[0160] The third user-specific key sk3 can be generated by calculating sk3 = u3 + Tx3';
[0161] The fourth user-specific key sk4 can be generated by calculating sk4 = u4 + Tx4';
[0162] in:
[0163] x1' is the binary vector representation of the first mask. A ;
[0164] x2' is the mask template vector A MASKED ;
[0165] x3' is the inverse vector A NOT ;
[0166] x4' is the Hamming vector A HAMMING ;
[0167] T is a matrix , where I k It is an identity matrix of size k × k.
[0168] Each master secret key can be partially derived from a combination of the same root key and the corresponding unique tag using a key derivation function.
[0169] Each dataset can include images captured by the camera of the client device.
[0170] Each image can be an image of the user's eye. A mask applied to the corresponding image can be, for example, used to isolate the user's iris from the image.
[0171] According to a seventh aspect of the invention, a computer-readable storage medium is provided that includes computer-executable instructions, which, when executed by a computer, cause the computer to perform a method according to any one of the first, second, third, fourth, fifth, and sixth aspects of the invention.
[0172] According to an eighth aspect of the invention, a computer system is provided, which is configured to perform a method according to any one of the first, second, third, fourth, fifth, and sixth aspects of the invention. Attached Figure Description
[0173] Embodiments of the invention will now be described by way of example with reference to the accompanying drawings, wherein:
[0174] Figure 1 An example system according to an implementation scheme is shown, which includes a client device and a cloud-based server;
[0175] Figure 2 A flowchart is shown illustrating the steps performed by the client device as part of the registration process;
[0176] Figure 3 It illustrates the steps performed by a registered user when the registered user seeks to authenticate themselves to a cloud-based server;
[0177] Figure 4 The sequence of steps performed by a cloud-based server to authenticate the user of a client device is shown.
[0178] Figure 5 The sequence of steps performed by a client device to enable a cloud-based server to identify a user who has previously registered with the server from among multiple users is shown.
[0179] Figure 6 The sequence of steps performed by a cloud-based server to identify the user of a client device is shown.
[0180] Figure 7 An image of the user's eyes and a mask for the biometric image used to capture the user's iris are shown;
[0181] Figure 8 A flowchart is shown illustrating the steps performed by the client device as part of the registration process;
[0182] Figure 9 A flowchart illustrates the steps performed by a cloud-based server as part of the registration process;
[0183] Figure 10It illustrates the steps performed by a registered user when the registered user seeks to authenticate themselves to a cloud-based server;
[0184] Figure 11 As shown Figure 7 The illustration shows how the relative alignment between the user's eye and the image mask can be shifted for different image captures.
[0185] Figure 12 The sequence of steps performed by a server device to enable a cloud-based server to authenticate users who have previously registered with the server from among multiple users is shown.
[0186] Figure 13 It illustrates the steps performed by a registered user when the registered user seeks to identify themselves to a cloud-based server; and
[0187] Figure 14 The sequence of steps performed by a cloud-based server to identify the user of a client device is shown. Detailed Implementation
[0188] The implementation described in this paper enables the capture of matching distances between two biometric datasets in a privacy-preserving manner and is well-suited for supporting cloud-based authentication and identification solutions.
[0189] The implementation described in this paper is based on so-called "function inner product encryption," an example of which is the lattice-based function inner product encryption (IPE) scheme described in "Lattice-Based Secure Biometric Authentication for Hamming Distance" by Cheon J. et al., ACISP Proceedings 2021, J. Baek and S. Ruj (eds.), LNCS13083, pp. 653-672, 2021 (hereinafter referred to as "Cheon, J. et al."). Such schemes allow the inner product of two vectors to be computed in a privacy-preserving manner. More specifically, one of the vectors is transformed into a "user-specific key." The user-specific key has the property that even if an adversary can read it, they cannot obtain any information about the vector that generated the key. The second vector is simply encrypted to provide its confidentiality protection. Function inner product encryption schemes are able to take the user-specific key and the encrypted vector and obtain the inner product of the two underlying vectors from it. It is important to note that this computation does not require decryption of the underlying vectors; a computer can perform this computation without any ability to decrypt the underlying vectors, or actually obtain any information about them other than the inner product.
[0190] Now refer to Figures 1 to 6 A first implementation is described, wherein the method proposed by Cheon, J. et al. is applicable to authentication protocols. This implementation is applicable to authentication protocols that rely on biometrics such as facial biometrics, where biometrics can be represented as floating-point vectors, and the differences between biometrics are computed as the cosine distance between these vectors.
[0191] Figure 1 An example system for implementing the protocol according to the first embodiment is shown. The system includes client devices 101 communicating with each other over a network and a cloud-based server 103. The server 103 can be used to authenticate or identify users of the client devices 101. After the user has been authenticated and / or identified, the server can facilitate access to one or more services for the user by either directly providing those services or by providing authentication / identity verification to other devices or servers.
[0192] In order to perform user authentication or identification, the user on the client device must first register with the server. Figure 2 A flowchart illustrating the steps performed by the client device to complete registration is shown. Starting in step S201, the client device receives a template dataset from the user. This template dataset will be used as a reference dataset for authenticating / identifying the user at a later point in time. The template dataset may include a user-specific biometric dataset. For example, the template dataset may include an image of a part of the user's body, such as their face or fingerprints, or a recording of the user's voice.
[0193] In step S203, the client device performs feature extraction on the template dataset. Feature extraction can be performed using one of a variety of known techniques in the art. For example, one or more trained machine learning algorithms can be used to obtain an embedding for the template dataset that is unique to the template dataset and provides a low-dimensional representation of the data. This embedding can define a reduced feature set that can summarize information of interest in the template data while removing other irrelevant data.
[0194] After performing feature extraction, the client device now outputs a vector x representing the floating-point values of the extracted features. The client device then performs the following steps:
[0195] (i) Calculate the norm (value) of the eigenvector x, ||x||;
[0196] (ii) Divide each value in vector x by the norm ||x||; and
[0197] (iii) Scale or round each value in the vector to an integer value.
[0198] The vector of floating-point values is then presented as an integer vector x' (step S205).
[0199] In step S207, the client device generates a master secret key msk and securely stores it on the device. The master secret key msk may be stored in association with the user ID of the user in question. The master secret key must be unique and distinguishable from any key previously used for a specific scheme parameter set. The master secret key consists of two variables:
[0200] (i) A vector u of length n + k, where from Z q Random uniform sampling of elements
[0201] (ii) (n + k) × k matrix , where I k Z is an identity matrix of dimension k x k, and S is an n x k matrix, where Z is derived from a discrete Gaussian distribution with a width parameter σ. q Random sampling is performed on the values.
[0202] Here, the values n and q are the underlying parameters of the encryption scheme and can be chosen based on the required security level of the scheme; k is the length of vectors x and y (more specifically, the number of elements in each vector x and y) and is a predefined parameter from the biometric scheme (the number of features captured from each user's face). Z q This is understood as the integer value modulo q; for this scheme, it means the integer x within the range –q / 2 < x <= q / 2. It should be understood that arithmetic is performed by adding / multiplying the integers and then taking the remainder after dividing by q.
[0203] Next, in step S209, the client device generates a user-specific key using the master secret key msk and the vector x'. The user-specific key sk is obtained by calculating sk = u + Tx', where T is a matrix derived from the master secret key. The user-specific key sk will be a vector of length m, which has integer values modulo q, where m = n + k.
[0204] In step S211, the client device forwards a user-specific key and user ID to the cloud-based server. The user ID is used to associate the key with a specific user and may include, for example, the user's name, email address, or phone number. It should be understood that standard security measures are employed to maintain the integrity, authenticity, and confidentiality of data transmitted from the client device to the cloud-based server. For example, encryption and signing are employed as part of the network protocol. It will also be understood that the received user key and ID are securely stored on the cloud-based server, i.e., protected for integrity. With the client device having forwarded the user-specific key and user ID to the cloud-based server, registration is now complete.
[0205] Figure 3 The steps performed by a registered user when the user later seeks to authenticate themselves with a cloud-based server are illustrated. The user begins by inputting a new dataset corresponding to the dataset used as a template dataset during registration (step S301). For example, in the case of registration based on an image of the user's face, the user can provide a new facial image by taking a photo of themselves with the camera of the client device. As part of the process, the client device can prompt the user to provide the necessary input dataset.
[0206] In step S303, the client device communicates with... Figure 2 In step S203, feature extraction is performed on the input dataset in the same way as feature extraction on the template dataset.
[0207] In step S305, the client device continues to generate a vector y of floating-point values, which represent features extracted from the newly input dataset. Similar to the registration process, the client device calculates the norm (magnitude) ||y|| of the feature vector y, divides each value in the vector y by the norm ||y||, performs scaling and rounding to integers, and outputs the vector of floating-point values as the integer vector y'.
[0208] Having already computed vector y', the client device now generates ciphertext by encrypting vector y' using the master secret key msk (step S307), and sets the vector Y' = Enc msk (y') is forwarded to the cloud-based server along with the user ID (step S309). It should be understood here that the master secret key msk used for encrypting vector y' must be the same master secret key used during the registration phase; further details on how to ensure that the client device can ensure that it selects the correct master secret key will be provided later below.
[0209] Figure 4This illustrates a sequence of steps performed by a cloud-based server to authenticate users on client devices. (Example:) Figure 4 As shown, in order to perform authentication, a cloud-based server must first possess a user-specific key and user ID from the user. It should be understood that receiving the user-specific key and user ID forms the basis of the above reference. Figure 2 This is part of the registration phase described. After receiving the user key and ID, these are securely stored on a cloud-based server (step S401).
[0210] Authentication begins in step S403, where the cloud-based server receives vector Y' from the client device, as shown in... Figure 3 This is generated in step S307. Upon receiving the data, the cloud-based server retrieves a user-specific key sk associated with the user's declared ID from the secure storage device. In step S405, the cloud-based server processes the received vector Y' using the user-specific key sk. Since the user-specific key sk is derived from the master secret key msk and x', processing the vector y' using the user-specific key sk results in the inner product of x' and y'. The output value is then converted back to a floating-point representation by rescaling (step S407). The rescaled value is equal to the inner product of x and y divided by ||x|| ||y||, which is the cosine similarity between x and y. The cloud-based server can then simply calculate the cosine distance as 1 minus the cosine similarity value.
[0211] In step S409, the cloud-based server determines whether the cosine distance calculated in step S407 is less than or equal to a predefined threshold. If the cosine distance is less than or equal to the threshold distance, the user is authenticated (step S411). The server can then proceed to perform another operation, such as providing the user with an authentication token or physical access to the room. If the cosine distance is found to be greater than the threshold, the user is not authenticated.
[0212] As mentioned above, when processing received ciphertext (encryption vector) with a user-specific key sk, the same master secret key msk must have already been used to generate both the user secret key and the ciphertext. If a different master secret key has been used, the inner product of the output will be incorrect. For the security of the scheme, it is also important that the master secret key is used only for a single user secret key generation (i.e., user registration). Therefore, not only must the master secret key msk be unique for each user, but a new master secret key will also need to be generated for that user if they register again (requiring a new user-specific key generation). However, the same master secret key can be used for multiple encryption operations (i.e., user authentication).
[0213] Therefore, a unique master secret key must be used each time a user secret key is generated, but when performing authentication, the same master secret key used for registration must be selected. Where the client device used for registration and authentication is unique to a particular user (e.g., the client device is the user's personal mobile phone), these requirements can be met by storing the master secret key on the client device and using it whenever the client device is used to authenticate a user. In other implementations, the client device may need to serve multiple users. For example, the client device may include an authentication terminal at the entrance of a building or site. In this case, the client device can store all master secret keys and retrieve the master secret key associated with the claimed user during authentication. However, if the number of users is very large, storing all master secret keys for multiple users may become impractical. There is also a potential key management problem because each new registration will require the generated master secret key to be securely distributed to all trusted clients. The solution to this problem is to derive all master secret keys from a public root key. Here, each specific master secret key can be derived from a combination of the root key and a unique (public) label using a suitable Key Derivation Function (KDF). This means that trusted clients only need to store a root key, but can generate a master secret key when authentication is required.
[0214] As mentioned above, the master secret key consists of two variables:
[0215] (i) A vector u of length n + k, where from Z q Random uniform sampling of elements
[0216] (ii) (n + k) × k matrix , where I k Z is an identity matrix of dimension k x k, and S is an n x k matrix, where Z is derived from a discrete Gaussian distribution with a width parameter σ. q Random sampling is performed on the values.
[0217] One way to ensure the uniqueness of the master key each time it is generated is to use a new matrix T (or equivalently S) for each user's secret key generation. However, a more preferred method is to use a different vector u each time, where matrix T is generated once during the setup phase and then reused in all registrations. Using a different vector u each time is sufficient to ensure uniqueness and is more efficient because vector u is significantly smaller than T and only requires uniform random sampling, which can be easily accomplished using common KDFs. Matrix T can be stored along with the root key on all devices that need to perform registration or authentication.
[0218] For this purpose, it is recommended to choose a NIST-approved KDF (e.g., a counter-mode KDF based on HMAC as the pseudo-random function (PRF)) from Reference 1 (“Recommendation for Key Derivation Using Pseudorandom Functions”, NIST Special Publication 800, NIST SP 800-108r1-upd1, Lily Chen, Computer Security Department, Information Technology Lab, August 2022). 198-1 U.S. Federal Information Processing Standards Publication, Information Technology Laboratory, National Institute of Standards and Technology, Gaithersburg, MD, 20899-8900, July 2008. To ensure no collisions occur (i.e., to ensure each vector u is indeed unique), for the chosen 128-bit security parameters, the root key size should be 256 bits, and a hash function with an input length of at least 256 bits (e.g., SHA-256) should be chosen. The remaining question is how to manage the tags used to identify each user, and consequently, which master secret key to retrieve for that particular user. The user ID itself provides a natural choice for the tag and is meaningful in the context of authentication, as the authentication process attempts to verify the user ID; therefore, in any case, the user ID must be known or presented during authentication. However, other options might be meaningful, such as a simple serial number, or a combination of user ID and serial number, to allow the same user to register multiple times. Such options would require the tag to be stored by the user in some way after registration and presented at authentication.
[0219] Therefore, by using a root key combined with the user's unique ID / tag and KDF, a master secret key can be derived for each user without permanently storing each user's master secret key on the client device. When seeking to authenticate a user, the client device can use the tag associated with that user (e.g., user ID) to ensure that the correct master secret key is selected when encrypting the vector y', i.e., the same master secret key initially used when generating the user-specific key during the registration phase.
[0220] In addition to authenticating users, the techniques described in this paper can also be used to identify a user from among several distinct users. Regardless of whether the cloud-based server performs the steps of authenticating the client device or identifying the user, the user will perform actions similar to... Figure 2The same registration process is shown. It is possible that multiple different users will register with the cloud-based server, and the server will identify a specific user who has previously registered from among these multiple users.
[0221] Now refer to Figure 5 and Figure 6 Describe an implementation scheme in which cloud-based servers are used to identify users of client devices. Figure 5 The sequence of steps performed by a client device to enable a cloud-based server to identify a user previously registered with the server from among multiple users is shown. Here, steps S501 to S505 are exact replicas of steps S301 to S305. In step S507, the client device performs an operation similar to step S303, but instead of encrypting the vector y' with a single master secret key, the client device now generates ciphertext for each of the master secret keys stored on the device; that is, the client device generates a corresponding vector Y' using each master secret key stored on the device. The client device also associates each of the generated vectors Y' with a tag identifying the corresponding master secret key. In step S509, the client device sends the vector Y' along with the associated tags to the cloud-based server.
[0222] Figure 6 The sequence of steps performed by a cloud-based server to identify a user on a client device is illustrated. In step S601, the server receives an encrypted vector Y' and an associated tag from the client device. In step S603, the server selects an encrypted vector from the encrypted vector Y' and retrieves a user-specific key sk associated with that user (i.e., the user who encrypted vector Y' using their master secret key) from memory using the tag. The user-specific key itself is stored by the server in conjunction with the user ID provided during registration. In step S605, the server processes Y' using the user-specific key to return the inner product of x' and y'. The output value is then converted back to a floating-point representation by rescaling (step S607) to return the cosine similarity between x and y. The cosine distance between x and y can then be calculated as subtracting the cosine similarity from 1, as previously described.
[0223] The cosine distance is compared to a predefined threshold (step S609). In step S611, if the cosine distance is less than or equal to the threshold, the server is able to identify the user as the user whose user-specific key was retrieved in step S603. Conversely, if the cosine distance is greater than the threshold, the server is able to infer that the user-specific key sk used to process vector Y' is not the same key generated during registration as the key initially used with vector x' (see [link to relevant documentation]). Figure 2(Step S207). After this, the server is able to determine that the user is a different user from the user-specific key sk retrieved in step S603. The server can then select a new encryption vector Y' and the corresponding user-specific key (step S613), and continue with steps S605 to S609 to process vector Y' using the newly selected user-specific key. This process can be repeated until the server returns a positive result in step S609. Then, it is discovered that the user has an identity associated with the successfully retrieved user-specific key.
[0224] The requirement to encrypt vector y' with each of the master secret keys means that the above identification method may not be suitable for situations with a particularly large user pool, i.e., a large number of users registered with the server, and where the server must generate a corresponding encryption vector each time it needs to identify a single user from that pool. However, the above method can still be applicable to certain scenarios, such as "watchlist" applications. If the watchlist is small (e.g., a few hundred users) and the tags are simple sequence numbers, the client device can generate the required ciphertext / encryption vector Y' for all possible tags / users without excessive overhead.
[0225] Therefore, by using the inner product encryption described above, the cosine distance between biometric vectors represented as floating-point numbers can be computed in a privacy-preserving manner by a single cloud-based server. In this way, the server (or other adversaries) cannot learn the original user template by observation or by attempting to reverse engineer any data stored by the cloud-based server. The cloud server can be used to perform distance calculations to support authentication and / or identification use cases without the risks of the server learning the original data and using it in an unauthorized manner, or leaking the original data in the event of intrusion during the computation.
[0226] The methods discussed above are suitable for authentication schemes where biometrics (e.g., facial biometrics) can be represented as floating-point vectors, and the differences between biometrics are calculated as the cosine distance between those vectors. However, some authentication protocols may involve additional processing steps requiring different methods. As an example, iris matching technology can be considered. [Reference] Figure 7The registration phase of the iris matching technology includes capturing a template image 701 of the user's eye and a mask 703, and converting both the template image and the mask into binary vectors. The mask vector is used to remove bits from the template vector during matching computation to ensure that only the useful (discriminative) bits of the template are used. Authentication can be performed by determining the Hamming distance between the mask template 705 and a newly captured image of the user's iris, where the mask is again applied to the newly captured image. Here, the authentication scheme must be adapted to the following: the input dataset used in registration consists of a combination of two vectors, namely, a vector corresponding to the underlying template image and a vector corresponding to the applied mask; similarly, the input image used for authenticating / identifying the user will consist of a combination of these two vectors.
[0227] The following describes an implementation where matching is performed in a privacy-preserving manner by computing the Hamming distance between these distinct input vectors. The described implementation extends the method described by Cheon J. et al. to support commonly used iris matching processes. More broadly, the described implementation facilitates the use of inner product encryption (IPE) in authentication / identification protocols, where the datasets being compared include both the underlying template vector and the mask vector.
[0228] The following notation will be used:
[0229] During registration, template vector A and mask vector Mask A Captured.
[0230] During authentication, template vector B and mask vector Mask B Captured.
[0231] The inner product between two vectors A and B is represented as .
[0232] The Hamming distance between two vectors A and B is denoted as HD(A, B).
[0233] ⊕ indicates XOR (exclusive OR).
[0234] It means AND.
[0235] It means NOT.
[0236] This represents the L1 norm, which is the sum of the entries in a vector. For a binary vector, this is equivalent to the number of non-zero entries.
[0237] (A) represents the number of elements in vector A. Note that in the described implementation, each vector will have the same length, which is known to both the client and the server.
[0238] It should be understood that for binary vectors:
[0239] •‖A ⊕ B‖ = HD(A, B)
[0240] •‖A B‖ =
[0241] • The Hamming distance can be computed as an inner product, which involves some preprocessing of the vectors, as shown by Cheon, J, et al. If all "0" elements are replaced with -1, then HD(A, B) = ( (A) – ) / 2.
[0242] Based on the above, the matching algorithm uses the following distance metric:
[0243]
[0244] In order to utilize the IPE method described by Cheon, J. et al., vector A, Mask A B and Mask B The vectors need to be preprocessed so that applying only the inner product is sufficient to compute the distance d. Furthermore, any inner product can only involve vectors from A and / or Mask. A Preprocessed vectors and from B and / or Mask B Preprocessed vectors. For example, it's impossible to use an input vector where one of the vectors is the inner product of a combination of A and B; this is because such combinations of vectors would be unavailable during registration or authentication (registration only allows access with A or Mask). A The relevant vectors, and authentication only allows access to B and Mask. B (Related vectors). This presents a challenge: it is impossible to compute the numerator in the above expression from the vector dot product in a simple or obvious way while satisfying these other constraints.
[0245] The solution to the above problem lies in determining that the distance d can be rewritten as:
[0246]
[0247] The proof of the above proposition can be verified by writing out the truth tables of the two expressions and proving their equivalence. Note that this form of distance d satisfies all the constraints discussed above. Each individual term in the expression involves only A and / or Mask. A , or B and / or Mask B These terms are combined using XOR or AND, which are related to the Hamming distance (which can be computed as an inner product) and the inner product, respectively.
[0248] It should be understood that the above d((A, Mask) A ), (B, Mask B The specific expression of )) is a Boolean formula, which can be written in several equivalent forms; for example, it can be expressed using formulas such as A ⊕ B ≡ (A ∧ B ≡ A ≡ ... B) ∨( A ∧ B), or P ∨ (Q ∨ R) ∧ (R ∨ P)) ≡ R ∨ ( The equivalent of P ∧ Q modifies this formula. Therefore, using the implementation described herein, and specifically by computing the different vectors described below, it becomes possible to formulate many different Boolean formulas that satisfy the conditions required by the IPE method described using Cheon.
[0249] As in Figures 1 to 6 In the example shown, the process begins at the registration stage, where the user provides a reference biometric template and an associated ID (e.g., the user's name) to the cloud server, which can then use the reference biometric template and associated ID to authenticate and / or identify the user later. Figure 8 The steps performed during the registration phase in this embodiment are illustrated. As previously described, the user can capture their biometric readings on the client device (step S801), and then perform feature extraction on the biometric readings to retain the features of interest and remove irrelevant data (step S803). After feature extraction has been performed, the client device now outputs a binary vector A representing the extracted features (step S805).
[0250] In step S807, the client device captures the mask to be applied to the template dataset and similarly generates a binary vector representation of the mask, Mask. A (Step S809). At this stage, the biometrics are represented by a binary vector A and a Mask. A composition.
[0251] In steps S811 to S815, the client device determines the following vector:
[0252] AMASKED = A Mask A (Template vector with mask applied)
[0253] A NOT = Mask A , (the "inverse" of the mask vector), and
[0254] A HAMMING A HAMMING It is by passing vector A Mask A The vector is obtained by replacing all zero entries with -1.
[0255] In step S817, after obtaining the vector Mask A A MASKED and A HAMMING In this scenario, the client device generates four master secret keys, msk1, msk2, msk3, and msk4, and securely stores these master secret keys on the device. Each of the generated master secret keys must be unique and distinguishable from any other keys previously used for a specific scheme parameter set. Each master secret key msk uses the methods described above. Figure 2 The master secret key is obtained using the same method as in step S207. It is a tuple (u, S), where u is a vector of length m with random integer values modulo q, and S is an n x k matrix with random integer values modulo q. As mentioned earlier, the values m, n, and q are the underlying parameters of the encryption scheme and can be chosen based on the required security level; k is the vector A, Mask... A A MASKED A NOT and A HAMMING The length.
[0256] Next, in steps S819 to S825, the four master secret keys are used for vector A, Mask A A MASKED A NOT and A HAMMING Each of the components generates a corresponding user-specific key. Then, the client device forwards the user-specific key along with the user ID to the server (step S827).
[0257] Figure 9The steps performed by the server as part of the registration process are shown. Here, the server receives a user-specific key and user ID (step S901) and stores them in memory (step S903). It is assumed here that appropriate security measures are employed to maintain the integrity and confidentiality of data transmitted from the client device to the server (e.g., using encryption and signing as part of the network protocol), and that the received user key and user ID are securely stored on the server for integrity protection.
[0258] Figure 10 The steps performed by the user during the authentication phase are illustrated. The user captures a new biometric dataset on the client device (step S1001), and then the client device performs feature extraction on the dataset (step S1003). The client device outputs a binary vector B0 representing the extracted features (step S1105). In step S1007, the client device captures a mask to be applied to the input dataset and generates the mask. B0 The binary vector representation of biometrics (step S1009). At this stage, biometrics are represented by binary vector B0 and Mask. B0 composition.
[0259] In step S1011, the client device determines the number n of shifts to be applied to the mask. This shift accommodates the situation where the mask applied to the input template during registration may not be perfectly aligned with the mask applied to the input template during authentication. This can be referenced... Figure 11 To understand further. Figure 11 A shows the same Figure 7 The same image sequence is shown, namely, the template image 701 of the user's eye captured during the registration phase, the mask 703, and the mask template 705 generated by applying the mask 703 to the template image 701. Figure 11 B illustrates another template image 1101 captured during the authentication phase, along with a new mask template 1103 and the result 1105 of applying mask 1103 to template image 1101. In this case, the alignment between mask 1103 and image template 1101 is offset relative to the alignment between mask 703 and image template 701; that is, mask 1103 is offset by a distance δy in the vertical direction relative to image template 1101. Applying a different shift to the mask during registration or authentication increases the likelihood of reproducing the same alignment between mask 1103 and image template 1101 during the authentication phase as it is during the registration phase; this, in turn, can help mitigate false rejection errors, i.e., the person seeking authentication is genuine, but fails verification due to the alignment difference between the mask and the template. (Although the shift δy is in Figure 11In B, the displacement is indicated in the vertical direction. However, in addition to the vertical direction, or in place of the vertical direction, displacement can also be obtained in the horizontal direction.
[0260] As discussed further below, during the authentication process, it is possible to target both A and Mask. A (That is, image template 701 and mask 703) relative to B and Mask B The distance metric d is calculated by shifting each bit in the shifts of image template 1101 and mask 1103. The obtained distance d can then be compared with a threshold T, and if any distance is within that threshold distance, the matching algorithm will output a match. Typically, the shift can be implemented as a simple bit displacement of a vector, as used in common computational languages.
[0261] Refer again Figure 10 In step S1013, the first shift i = 0 is selected. In steps S1015 to S1023, the client device determines the following vector:
[0262] B i (Original template vector)
[0263] (Mask Vector)
[0264] (Template vector with mask applied)
[0265] (The "inverse" of the mask vector) and
[0266] in, It is by using vectors The vector is obtained by replacing all zero entries with -1.
[0267] (It should be understood that for i = 0, vector B) i and It is the same B0 and obtained in steps S1005 and S1009 respectively. ).
[0268] Four vectors and It is encrypted using keys msk1, msk2, msk3, and msk4, which are used to generate the first user-specific key, the second user-specific key, the third user-specific key, and the fourth user-specific key, respectively.
[0269] In step S1025, the client device continues the next shift by incrementing the value of i. Then, steps S1015 to S1023 are repeated to apply the new shift to the vector. This process is repeated for each shift 0 ≤ i ≤ n – 1, resulting in the generation of a total of 4n encrypted vectors, four encrypted vectors n for each shift. This encrypted vector is then forwarded to the server (step S1119). Similar to the registration phase, it is assumed that the data is securely sent to the server and protected for integrity.
[0270] Figure 12 This illustrates the steps performed by the server during the authentication phase. This is after 4n encryption vectors have been received from the user. and In the case of (where 0 ≤ i ≤ n – 1) and user ID (step S1201), the server retrieves four user-specific keys corresponding to the user ID from the storage device (step S1203). In step S1205, the server sets i=0, and in step S1207, it calculates the distance metric d. i as follows:
[0271]
[0272] The formula for d above directly follows the Boolean formulas described earlier. If formulated in this way, the distance metric d... i The inner product can be used for computation, where each inner product involves processing the encrypted vector using an inner product encryption scheme (e.g., ...). ) and user secret key (e.g., A HAMMING This inner product encryption scheme can take a user-specific key and encryption vector, and obtain the inner product of two underlying vectors. (As shown in...) Figures 1 to 6 In the implementation shown, the computation does not require decryption of the underlying vectors; the computer can perform the computation without any ability to decrypt the underlying vectors, or actually obtain any information about them other than the inner product.
[0273] If distance d is found i If the value is less than or equal to a predetermined threshold (step S1209), the user is authenticated (step S1211). Otherwise, the server increments the value i and applies the next shift, repeating steps S1207 and S1209 until the calculated distance metric d for one shift is found. i Less than or equal to a predetermined threshold, or in the distance metric d i If the threshold criterion has not yet been met, a total of n shifts have been completed; in this case, authentication fails and the user is blocked from accessing the server (step S1215).
[0274] like Figure 6 As shown in the example, this implementation can also be used to support user identification instead of authentication. Here, the steps performed when registering a user remain unchanged (see...). Figure 8 and Figure 9 ).
[0275] Figure 13 This illustrates the steps performed by the client device when executing user identification. Here, the client device performs the following steps: Figure 10 The sequence of steps shown is similar to the sequence of steps, except that for each user m = 1, ... w, a set of the four master secret keys msk1, msk2, msk3, msk4 is retrieved, where w is the total number of registered users, and steps S1015 to S1023 are repeated for each of those sets of master secret keys. Figure 13 (Steps S1319 to S1327 in the original text). More specifically, each user m registered with the server will have a vector Mask used to generate a vector Mask for that user. B B MASKED B NOT and B HAMMING The client device generates these four vectors for each shift of each user's data. Therefore, with n shifts per user and w registered users, the client device will perform 4n encryptions per user and send a total of 4nw encrypted vectors / ciphertexts to the server. (As in...) Figure 5 In the implementation scheme, when sending each set of 4n encryption vectors to the server, the client device includes a tag identifying the user associated with the corresponding set of encryption vectors (step S1331).
[0276] Figure 14 This illustrates the steps performed by the server as part of the authentication process. The server receives an encryption vector for each user. , and Each set of encrypted vectors is matched with a set of four user-specific keys msk1, msk2, msk3, and msk4 for the corresponding user using associated labels (step S1401). In step S1403, the server selects a first user m = 1 from those users who have registered with the server, and in step S1405, the server retrieves the set of four user-specific keys and associated encrypted vector sets it has received for user m = 1. In step S1407, the server selects a first shift i = 0 and calculates the distance metric d using the selected user-specific key and the encrypted vectors used for i = 0. i (Step S1409). In step S1413, if d is found...i If the value is less than or equal to a predetermined threshold (step S1411), the server can identify the selected user m as the user whose binary vector representation B0 of the generated features has been generated (see [link to relevant documentation]). Figure 10 (Step S1005). Otherwise, the server increments the value i and applies the next shift (step S1415), where steps S1409 to S1411 are repeated until the calculated distance metric d for one shift is found. i Less than or equal to a predetermined threshold, or in the distance metric d i If the threshold criterion has not yet been met, a total of n shifts have been completed. In the latter case, it is determined that user m is not the correct user. In step S1417, it is determined whether other registered users should be considered (i.e., if m = w); if not, the next user m = m + 1 is selected. Then, steps S1405 to S1415 are repeated using the user-specific key associated with this other user. This process continues to repeat until the calculated distance metric d for a shift is found. i The user is identified if the threshold is equal to or less than a predetermined threshold, or if all registered users have been considered but no successful identification has occurred.
[0277] As in Figure 5 In the implementation scheme, it should be understood that requiring encryption of the vector with each master secret key set each time the identification process is performed means that this method may not be suitable for situations with a particularly large user pool. However, this method can still be applied to watchlist applications where the number of users registered on the server is relatively small.
[0278] Therefore, the implementation described herein enables a single cloud server to compute an iris matching metric between a biometric representation as a binary vector and its associated binary mask in a privacy-preserving manner. This is done in such a way that the server (or adversary) cannot learn the original user template by observation or by attempting to reverse engineer any data stored by the server. Specifically, the implementation described herein provides data privacy not only during rest and transmission but also now during computation (when compared to conventional methods). The implementation also provides better runtime performance than alternative privacy-preserving schemes based on techniques such as homomorphic encryption and multi-party computation. The implementation described herein is based on lattice-based “function inner product encryption” and is therefore considered quantum secure.
[0279] The implementation of the subject matter and operations described in this specification can be implemented in digital electronic circuits, or in computer software, firmware, or hardware (including the structures disclosed in this specification and their equivalents), or in a combination of one or more of these. The implementation of the subject matter described in this specification can be implemented using one or more computer programs, i.e., one or more modules of computer program instructions encoded on a computer storage medium for execution by a data processing apparatus or for controlling the operation of a data processing apparatus. Alternatively or otherwise, program instructions can be encoded on artificially generated propagating signals, such as machine-generated electrical, optical, or electromagnetic signals, which are generated to encode information for transmission to a suitable receiver device for execution by the data processing apparatus. The computer storage medium can be a computer-readable storage device, a computer-readable storage substrate, a random or serial access memory array or device, or a combination of one or more of these, or be included therein. Furthermore, although the computer storage medium is not a propagating signal, it can be a source or destination of computer program instructions encoded in artificially generated propagating signals. Computer storage media can also be one or more separate physical components or media (e.g., multiple CDs, disks or other storage devices), or included therein.
[0280] While certain embodiments have been described, these embodiments are presented by way of example only and are not intended to limit the scope of the invention. In fact, the novel methods, apparatuses, and systems described herein can be embodied in various ways; furthermore, various omissions, substitutions, and modifications may be made to the forms of the methods and systems described herein without departing from the spirit of the invention. The appended claims and their equivalents are intended to cover such forms or modifications that fall within the scope and spirit of the invention.
Claims
1. A computer-implemented method, the computer-implemented method comprising: Receive the first dataset from the user at the first point in time; Upon receiving the first dataset: Perform feature extraction on the first dataset to obtain a first feature vector; Generate a first integer vector representation of the first feature vector; Use the first integer vector representation and the master key to generate a user-specific key; as well as Send the user ID and the user-specific key to the remote server.
2. The computer-implemented method according to claim 1, wherein the first dataset includes biometric data.
3. The computer-implemented method according to claim 1 or 2, wherein generating the integer vector representation of the first feature vector comprises: Calculate the norm of the first eigenvector; Divide each value in the first feature vector by the norm; as well as The value of the first feature vector is rounded or scaled to an integer value.
4. The computer-implemented method according to any one of the preceding claims, wherein the computer-implemented method further comprises: Receive the second dataset at a later point in time; Upon receiving the second dataset: Perform feature extraction on the second dataset to obtain a second feature vector; Generate a second integer vector representation of the second feature vector; The encrypted version represented by the second integer vector is generated using the master key; as well as Send the encrypted version represented by the second integer vector to the remote server.
5. The computer-implemented method according to claim 4, wherein the computer-implemented method comprises: Send the user ID and the encrypted version represented by the second integer vector to the remote server.
6. The computer-implemented method according to claim 4 or 5, wherein the second dataset includes biometric data.
7. The computer-implemented method according to any one of claims 4 to 6, wherein generating the second integer vector representation of the second feature vector comprises: Calculate the norm of the second eigenvector; Divide each value in the second feature vector by the norm; as well as The value of the second feature vector is rounded or scaled to an integer value.
8. A computer-implemented method, the computer-implemented method comprising: The server receives a user-specific key and user ID from the user, the user-specific key being generated using: (i) an integer vector representation of a first feature vector and (ii) a master key; The server receives an encryption vector and a declared user ID from the user, wherein the vector is encrypted using the master key; The server processes the encryption vector using the user-specific key to obtain the output value; The server determines whether the output value is equal to or less than a predetermined threshold. as well as If the output value is less than or equal to the threshold, the declared user ID will be authenticated as being the same as the user ID.
9. A computer-implemented method, the computer-implemented method comprising: (i) Receive multiple ciphertexts from the client device at the server, each ciphertext being generated by encrypting the same vector using a different corresponding master secret key, and each ciphertext being accompanied by a tag indicating the corresponding user; (ii) The server retrieves from the storage device a user-specific key corresponding to the user indicated by the tag attached to the first ciphertext in the ciphertext; (iii) The server processes the first ciphertext in the ciphertext using the user-specific key to obtain an output value; (iv) If the output value is less than or equal to a predetermined threshold, determine that the user indicated by the tag attached to the first ciphertext is the user operating the client device; (v) If the output value is greater than the threshold, retrieve a second user-specific key corresponding to the user indicated by the tag attached to the second ciphertext in the ciphertext, and have the server process the second ciphertext in the ciphertext using the second user-specific key to obtain a second output value; as well as (vi) If the second output value is less than the threshold, determine that the user indicated by the tag attached to the second ciphertext is the user operating the client device.
10. The computer-implemented method according to claim 9, wherein: If the second output value is greater than the threshold, the method includes repeating steps (ii) and (iii) for another ciphertext and its corresponding user-specific key until the obtained output value is less than the threshold or a predetermined number of user-specific keys have been retrieved.
11. The computer-implemented method according to any one of the preceding claims, wherein each dataset includes an image of a user's face.
12. A computer-implemented method, the computer-implemented method comprising: Receive the first dataset from the user at the first point in time; Perform feature extraction on the first dataset to obtain a first feature vector; Generate the binary vector representation A of the first feature vector; Receive the mask used for the first dataset; Generate a binary vector representation of the mask for the first dataset. A ; Mask is represented using the first binary vector. A Generate a user-specific key using the first master secret key msk; The binary vector representation of the mask. A The binary vector representation A applied to the first feature vector is used to obtain the mask template vector A. MASKED ; Using the mask template vector A MASKED A second user-specific key is generated from the second master secret key; Generate the binary vector representation Mask A The inverse vector A NOT ; Using the inverse vector A NOT A third user-specific key is generated from the third master secret key; By using the mask template vector A MASKED Replace all zero entries in the vector with -1 to generate the Hamming vector A. HAMMING ; Using the Hamming vector A HAMMING A fourth user-specific key is generated from the fourth master secret key; as well as Send the user ID and the first user-specific key, the second user-specific key, the third user-specific key, and the fourth user-specific key to the remote server.
13. The computer-implemented method according to claim 12, further comprising: At a later point in time, a second dataset is received from the user; Perform feature extraction on the second dataset to obtain a second feature vector; Generate the binary vector representation B of the second feature vector; Receive the mask used for the second dataset; Generate a binary vector representation of the mask for the second dataset. B ; The first master secret key is used to represent the Mask in the binary vector. B Encrypt; The binary vector represents the Mask. B The binary vector representation B applied to the second feature vector is used to obtain the second mask template vector B. MASKED ; Use the second master secret key to modify the second mask template vector B. MASKED Encrypt; Obtain the second binary vector representation Mask B The inverse vector B NOT ; Use the third master secret key to apply the inverse vector B NOT Encrypt; By using the mask template vector B MASKED Replace all zero entries in the vector with -1 to obtain the Hamming vector B. HAMMING ; The fourth master secret key is used to modify the Hamming vector B. HAMMING Encryption; and The encrypted binary vector representation of the mask for the second dataset is sent to the remote server. B The encrypted mask template vector B MASKED The encrypted inverse vector B NOT and the encrypted Hamming vector B HAMMING .
14. The computer-implemented method according to claim 13, wherein the computer-implemented method comprises: Send the user ID and the encrypted second binary vector representation of the mask used for the second dataset to the remote server. B The encrypted mask template vector B MASKED The encrypted inverse vector B NOT and the encrypted Hamming vector B HAMMING .
15. The computer-implemented method according to claim 13 or 14, further comprising: Apply one or more shifts to the binary vector representation Mask. B And / or the binary vector representation B of the second feature vector, wherein each shift represents a shift in the relative alignment of the second dataset with the mask used for the second dataset; For each shift, the encrypted binary vector representation Mask is generated for the mask used in the second dataset. B The encrypted mask template vector B MASKED The encrypted inverse vector B NOT and the encrypted Hamming vector B HAMMING A new version of each of them; as well as The encrypted binary vector representation of the mask for the second dataset is sent to the remote server. B The encrypted mask template vector B MASKED The encrypted inverse vector B NOT and the encrypted Hamming vector B HAMMING A new version of each of them.
16. A computer-implemented method, the computer-implemented method comprising: (i) Receive a user ID, a first user-specific key, a second user-specific key, a third user-specific key, and a fourth user-specific key from a client registration device used to register a user with the server at the server; The first user-specific key is a binary vector representation of the Mask using a first mask at the client registration device. A Generated with the first master secret key, The second user-specific key is obtained by using a second master secret key at the client registration device and by representing the binary vector Mask. A The mask template vector A obtained by applying the binary vector representation A of the first dataset MASKED Generated; The third user-specific key is obtained by using a third master secret key and the binary vector representation Mask at the client registration device. A The inverse vector A NOT Generated; The fourth user-specific key is obtained by using the fourth master secret key at the client registration device and by using the mask template vector A. MASKED The Hamming vector A is obtained by replacing all zero entries in the vector with -1. HAMMING Generated; (ii) At the server, the user receives a first encryption vector, a second encryption vector, a third encryption vector, and a fourth encryption vector from a client authentication device used to authenticate the user to the server. The first encryption vector is a binary vector representation of the mask at the client authentication device using the first master secret key paired with the second mask. B Generated through encryption; The second encryption vector is obtained at the client authentication device by using the second master secret key to mask template vector B. MASKED The mask template vector B is generated through encryption. MASKED It is by representing the Mask by the binary vector of the second mask. B The binary vector representation B applied to the second dataset was obtained; The third encryption vector is represented by the third master secret key at the client authentication device, which is used to encrypt the binary vector representing the Mask. B The inverse vector B NOT Generated through encryption; The fourth encryption vector is obtained at the client authentication device by using the fourth master secret key to pair the Hamming vector B. HAMMING The Hamming vector B is generated through encryption. HAMMING It is by using the mask template vector B MASKED The result was obtained by replacing all zero entries with -1; Each encryption vector is processed using one of the user-specific keys to return the corresponding inner product; The distance metric between the first dataset when it is masked by the first mask and the second dataset when it is masked by the second mask is calculated based on the inner product. as well as Determine whether the output value is equal to or less than a predetermined threshold; as well as If the output value is less than or equal to the threshold, the server authenticates the user.
17. The computer-implemented method according to claim 16, wherein the computer-implemented method comprises: The server receives multiple encryption vector sets from the client authentication device, each encryption vector set including a first encryption vector, a second encryption vector, a third encryption vector, and a fourth encryption vector. For each set of encryption vectors: The first encryption vector in the set is generated at the client authentication device by applying a corresponding shift to the binary vector representation of the second mask. B To obtain the shifted binary vector representation of Mask B and using the first master secret key to the shifted binary vector representation Mask B Encrypt; The second encryption vector is generated at the client authentication device by: applying the corresponding shift to the binary vector representation B of the second dataset to obtain a shifted binary vector representation of the second dataset, and then applying the shifted binary vector representation Mask. B The shifted binary vector representation applied to the second dataset is used to obtain a mask template vector B for the corresponding shift. MASKED and using the second master secret key to the mask template vector B MASKED Encrypt; The third encryption vector is the shifted binary vector representing the Mask, obtained by using the third master secret key at the client authentication device. B The inverse vector B NOT Generated through encryption; and The fourth encryption vector is generated at the client authentication device through the following operation: the mask template vector B is shifted accordingly. MASKED Replace all zero entries in the vector with -1 to obtain the Hamming vector B. HAMMING And using the fourth master secret key to the Hamming vector B HAMMING Encrypt; The method further includes, for one or more encryption vectors in the encryption vector set: Each encrypted vector in the set is processed using one of the user-specific keys to return the corresponding inner product; The distance metric between the first dataset when it is masked by the first mask and the second dataset when it is masked by the second mask is calculated based on the inner product. as well as Determine whether the output value is equal to or less than a predetermined threshold; as well as For a given encryption vector in the encryption vector set, the server authenticates the user if the output value is less than or equal to the threshold.
18. A computer-implemented method, the computer-implemented method comprising: (i) At the server, for each of the multiple users, a first user-specific key, a second user-specific key, a third user-specific key and a fourth user-specific key are received and stored; For each user: The first user-specific key is a binary vector representation of the Mask using a first mask. A Generated with the user's first master secret key; The second user-specific key is obtained by using the user's second master secret key and representing the mask using the binary vector. A The mask template vector A obtained by applying the binary vector representation A of the first dataset MASKED Generated; The third user-specific key is obtained by using the user's third master secret key and the binary vector representation Mask. A The inverse vector A NOT Generated; and The fourth user-specific key is obtained by using the user's fourth master secret key and by using the mask template vector A. MASKED The Hamming vector A is obtained by replacing all zero entries in the vector with -1. HAMMING Generated; (ii) The server receives from the client device a ciphertext group for each of the users, each group being accompanied by a tag indicating the corresponding user, each ciphertext group comprising: The first ciphertext is a binary vector representation of the mask created by using the first master secret key of the corresponding user. B Generated through encryption; The second ciphertext, which is obtained by using the second master secret key of the corresponding user to mask the template vector B. MASKED The mask template vector B is generated through encryption. MASKED It is by representing the mask by the binary vector of the first mask. B The binary vector representation B applied to the dataset is obtained; The third ciphertext is obtained by using the third master secret key of the corresponding user to represent the binary vector Mask. B The inverse vector B NOT Generated through encryption; and The fourth ciphertext, which is obtained by using the fourth master secret key of the corresponding user to pair the Hamming vector B HAMMING The Hamming vector B is generated through encryption. HAMMING It is by using the mask template vector B MASKED The result was obtained by replacing all zero entries with -1; (iii) Select the first ciphertext group from the ciphertext groups; (iv) Retrieve the user-specific key of the user indicated by the tag attached to the first ciphertext group; (v) Use one of the retrieved user-specific keys to process each ciphertext in the first ciphertext group to return the corresponding inner product; (vi) Calculate the value of the distance metric based on the inner product; and (vii) Determine whether the output value is equal to or less than a predetermined threshold; (viii) If the output value is less than or equal to the threshold, determine that the user indicated by the tag attached to the first ciphertext group is the user operating the client device.
19. The computer-implemented method according to claim 18, wherein: If the output value is greater than the predetermined threshold, the method includes repeating steps (iii) to (viii) for one or more ciphertext groups until the obtained output value is less than the threshold or a predetermined number of ciphertext groups have been selected.
20. The computer-implemented method according to claim 18 or 19, wherein the computer-implemented method comprises: (ii) The server receives from the client device a plurality of ciphertext groups for each of the users, each of the plurality of groups being accompanied by a tag indicating the corresponding user, each of the plurality of groups comprising a first ciphertext, a second ciphertext, a third ciphertext, and a fourth ciphertext; For each of the plurality of ciphertext groups received from the user: The first ciphertext in the corresponding group is generated by applying a corresponding shift to the binary vector representation of the second mask. B To obtain the shifted binary vector representation of Mask B and using the first master secret key of the corresponding user to the shifted binary vector representation Mask B Encrypt; The second ciphertext is generated by applying the corresponding shift to the binary vector representation B of the second dataset to obtain a shifted binary vector representation of the second dataset, and then applying the shifted binary vector representation Mask. B The shifted binary vector representation applied to the second dataset is used to obtain a mask template vector B for the corresponding shift. MASKED And using the second master secret key of the corresponding user to the mask template vector B MASKED Encrypt; The third ciphertext is obtained by using the third master secret key of the corresponding user to represent the shifted binary vector Mask. B The inverse vector B NOT Generated through encryption; and The fourth encryption vector is generated by the following operation: taking the mask template vector B with the corresponding shift... MASKED Replace all zero entries in the vector with -1 to obtain the Hamming vector B. HAMMING And using the fourth master secret key to the Hamming vector B HAMMING Encrypt; The method includes: (iii) Selecting a first ciphertext group from the plurality of ciphertext groups; (iv) Retrieve the user-specific key of the user indicated by the tag attached to the first ciphertext group among the plurality of ciphertext groups; (v) Use one of the retrieved user-specific keys to process each ciphertext in the first ciphertext group to return the corresponding inner product; (vi) Calculate the value of the distance metric based on the inner product; and (vii) Determine whether the output value is equal to or less than a predetermined threshold; (viii) If the output value is less than or equal to the threshold, determine that the user indicated by the tag attached to the first ciphertext group of the plurality of ciphertext groups is the user operating the client device.
21. The computer-implemented method according to claim 20, wherein: If the output value is greater than the predetermined threshold, the method includes repeating steps (iii) to (viii) for one or more other ciphertext groups in the first ciphertext group of the plurality of ciphertext groups.
22. The computer-implemented method according to claim 21, wherein, For each of the one or more other ciphertext groups in the first ciphertext group of the plurality of ciphertext groups, if the output value is greater than the predetermined threshold, the method includes: Select the first ciphertext group from the second ciphertext group among the plurality of ciphertext groups; and Steps (iii) to (viii) are repeated for one or more of the second ciphertext groups among the plurality of ciphertext groups.
23. The computer-implemented method according to any one of the preceding claims, wherein each user-specific key is generated based on its corresponding master secret key.
24. The computer-implemented method according to claim 23, which is dependent on any one of claims 1 to 10, wherein the user-specific key sk is generated by calculating sk = u + Tx', wherein: x' is the first integer vector representation of the first feature vector; u is a vector of length n + k, where from Z q The elements are randomly and uniformly sampled, where n and q are predefined values, and k is the length of the first feature vector; and T is a matrix , where I k S is an identity matrix of size k × k, and S is an n×k matrix of random integer values.
25. The computer-implemented method according to claim 23, which is dependent on any one of claims 12 to 22, wherein: The first master secret key comprises the tuple (u1, S); The second master secret key consists of the tuple (u2, S); The third master secret key comprises the tuple (u3, S); and The fourth master secret key includes the tuple (u4, S); in: u1 is the first vector of length n + k, where from Z q The elements are randomly and uniformly sampled. u2 is the second vector of length n + k, where from Z q The elements are randomly and uniformly sampled. u3 is a third vector of length n + k, where from Z q The elements are randomly and uniformly sampled. u4 is the fourth vector of length n + k, where from Z q The elements are randomly and uniformly sampled. S is derived from Z. q The n x k matrix of random integer values, where n and q are predefined values, and k is the length of the first eigenvector.
26. The computer-implemented method according to claim 25, wherein: The first user-specific key sk1 is generated by calculating sk1 = u1 + Tx1'; The second user-specific key sk2 is generated by calculating sk2 = u2 + Tx2'; The third user-specific key sk3 is generated by calculating sk3 = u3 + Tx3'; The fourth user-specific key sk4 is generated by calculating sk4 = u4 + Tx4'; in: x1' is the binary vector representation of the first mask. A ; x2' is the mask template vector A MASKED ; x3' is the inverse vector A NOT ; x4' is the Hamming vector A HAMMING ; T is a matrix , where I k It is an identity matrix of size k × k.
27. The computer-implemented method according to any one of the preceding claims, wherein each master secret key is derived in part from a combination of the same root key and a corresponding unique tag using a key derivation function.
28. The computer-implemented method according to any one of the preceding claims, wherein each dataset includes images captured by a camera of a client device.
29. The computer-implemented method of claim 28, wherein each image is an image of a user's eye, and the mask applied to the respective image is, for example, used to isolate the user's iris in the image.
30. A computer-readable storage medium comprising computer-executable instructions that, when executed by a computer, cause the computer to perform the method according to any one of the preceding claims.
31. A computer system configured to perform the method according to any one of the preceding claims.
32. A computer system, the computer system comprising: A client device configured to perform the method according to any one of claims 1 to 7, 12 to 15, and 21 to 29; and A server device configured to perform the method according to any one of claims 8 to 11 and 16 to 20.
