Biometric security for cryptographic system

Abstract

A method of storing data allowing a seed value for generating an encryption key to be retrieved is provided. The method comprises obtaining, for each of a plurality of biological data sources, a respective set of biometric data from an authorised user. A respective biometric identifier is generated from each set of biometric data. The biometric identifiers are stored in a database. A plurality of seed portions are generated that are combinable using a function to generate the seed value. Each seed portion is stored in the database in association with a biometric identifier.

Claims

1. A method of storing data allowing a seed value for generating an encryption key to be retrieved, the method comprising: obtaining, for each of a plurality of biological data sources, a respective set of biometric data from an authorized user; generating, from each set of biometric data, a respective biometric identifier; storing the biometric identifiers in a database; generating a plurality of seed portions that are combinable using a non-commutative function to generate the seed value, wherein generating a plurality of seed portions comprises generating an intermediate seed value for generating an encryption key using a seed generating function and splitting the intermediate seed value into seed portions, wherein a sequence of alphanumeric characters is representative of the intermediate seed value and splitting the intermediate seed value into seed portions comprises separating the sequence of alphanumeric characters into sub-sequences of alphanumeric characters, each sub-sequence being representative of a respective seed portion; and storing each seed portion in the database in association with a biometric identifier, receiving a code from the user defining a sequence of the biometric identifiers, wherein a respective one of the plurality of seed portions is generated for each symbol and stored in the database in association with the corresponding biometric identifier.

2. The method of claim 1, wherein a respective seed portion is generated for each biometric identifier.

3. The method of claim 1, wherein each sub-sequence of alphanumeric characters has a length equal to a length of the other sub-sequences of alphanumeric characters.

4. The method of claim 1, wherein generating an intermediate seed value using a seed generating function comprises obtaining data indicative of a physical property and formatting the data so that it can be used as a seed value for a public-key algorithm.

5. The method of claim 4, wherein the physical property is keystroke timings of user inputs.

6. The method of claim 4, wherein the physical property is a portion of the sets of biometric data.

7. The method of claim 4, further comprising generating one or more dummy seed portions and storing each dummy seed portion in the database in association with a respective one of the biometric identifiers.

8. The method of claim 7, further comprising generating one or more dummy biometric identifiers and storing the dummy biometric identifiers in the database, wherein at least one dummy seed portion is stored in association with a dummy biometric identifier.

9. A method of obtaining a seed value for generating an encryption key from a database, wherein the database contains a plurality of biometric identifiers and a plurality of seed portions that can be combined using a function to provide the seed value, each seed portion being stored in association with a respective one of the plurality of biometric identifiers, the method comprising: obtaining, for each of a sequence of two or more biological data sources, a respective biometric data set from a user, thereby providing a sequence of biometric data sets; matching each of the sequence of biometric data sets to a respective biometric identifier from the database to provide a sequence of biometric identifiers; retrieving from the database, for each of the sequence of biometric identifiers, a respective seed portion stored in association with the biometric identifier to provide a sequence of seed portions; and combining the sequence of seed portions using a function to provide the seed value, wherein the function is non-commutative, wherein combining the seed portions using a function comprises concatenating the seed portions.

10. The method of claim 9, wherein the sequence of two or more biological data sources contains at least two distinct biological data sources.

11. The method of claim 9, wherein each position in the sequence of seed portions is assigned a predetermined multiplier and combining the seed portions using a function comprises multiplying each seed portion by the predetermined multiplier.

12. The method of claim 9, wherein at least two seed portions are stored in association with a particular biometric identifier and wherein retrieving a seed portion from the database stored in association the particular biometric identifier further comprises determining which seed portion to retrieve based on a position of the biometric identifier in the sequence of biometric identifiers.

13. The method of claim 12, wherein determining which seed portion to retrieve based on a position of the biometric identifier in the sequence of biometric identifiers comprises retrieving a seed portion that contains an indication of the position.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

(1) FIG. 1 shows a pair of public and private keys being generated from a seed value using a public-key algorithm.

(2) FIG. 2 shows the private key being deleted.

(3) FIG. 3 shows fingerprint templates in a secure database.

(4) FIG. 4, FIG. 5, FIG. 6, and FIG. 7 show examples of additional data stored in a secure database along with the fingerprint templates.

DETAILED DESCRIPTION

The Solution

(5) The solution is the use of a biometrics in a secret order of sequence to negate the need to store, memorise or put into cold-storage the private-key, since this is the Achilles-heel in the cryptographic system. This is achieved by generating the private-key on the fly at the point of use. The result is that the private-key is invisible and tied to the biometric features of the individual user and their knowledge of a secret sequence.

(6) Cryptography relies upon two basic components: an algorithm (or cryptographic methodology) and a cryptographic key. The algorithm is a mathematical function, and the key is a parameter used by that function. The generation of the private/public key is determined by an input seed (or a combination of input seeds). The input seed/s needs to be a random number and be of a sufficient length. Once the input seed is created and put into the public-key algorithm, two keys are generated. One is a private-key and the other public key.

(7) The important point to note is that for a significant number of widely used asymmetric cryptographic algorithms, the private and public keys will always be the same if the input seed (or a combination of input seeds) is the same one used to generate the key in the first instant. The input seed/s would be too long to memorise and un-safe to store. In our method the input seed would be split into several parts with each part being tied to a different biometric feature (e.g. fingerprints). The input seed/s would then be created on the fly and at the point of use by inputting the biometric feature (e.g. fingerprint) in a specific order known only to the user. Each biometric feature would provide only part of the intermediate input seed ingredient until the full input seed is created. The full input seed/s would only be correct if the different parts are in the correct order, which is entirely dependent on the order of input of the biometric feature.

Example 1

(8) Generating Private and Public Key

(9) Step 1: Register Fingerprints

(10) Scan each of the user's fingerprints, which will result in:

(11) Finger 1=Template 1; Finger 2=Template 2; Finger 3=Template 3; Finger 4=Template 4; Finger 5=Template 5; Finger 6=Template 6;

(12) Finger 7=Template 7; Finger 8=Template 8; Finger 9=Template 9; Finger 10=Template 10

(13) Step 2: Store all the fingerprint templates in a secure database.

(14) This step is shown in FIG. 3.

(15) Step 3: Create and register an order of sequence for input of fingerprints

(16) Secret sequence known only to the user:

(17) First position (P1)=Finger 2 (Template 2)

(18) Second Position (P2)=Finger 3 (Template 3)

(19) Third Position (P3)=Finger 8 (Template 8)

(20) Fourth Position (P4)=Finger 1 (Template 1)

(21) Step 4: Give each sequence position a fixed number, which are stored in memory with an association to the sequence position.

(22) First position=n1=5023

(23) Second Position=n2=68

(24) Third Position=n3=7899

(25) Fourth Position=n4=555

(26) The fixed numbers can be alphanumeric and of varying length

(27) Step 5: Generate an intermediate seed

(28) The random intermediate seed=5963274521963254763312344853697020002147 (This could also be alpha-numeric)

(29) Step 6: Split the intermediate seed into four segments:

(30) Segment 1 (S1)=5963274521

(31) Segment 2 (S2)=9632547633

(32) Segment 3 (S3)=1234485369

(33) Segment 4 (S4)=7020002147

(34) Step 7: Associate each segment with fingerprint

(35) Each segment of the intermediate seed will be associated with a fingerprint. The order of association will be determined by the order of position in the sequence.

(36) First position (P1)=Finger 2 (Template 2)=5963274521

(37) Second Position (P2)=Finger 3 (Template 3)=9632547633

(38) Third Position (P3)=Finger 8 (Template 8)=1234485369

(39) Fourth Position (P4)=Finger 1 (Template 1)=7020002147

(40) Step 8: Store the results of steps 1; 2; 3; 5; 6; 7 in a secure database

(41) This step is shown in FIG. 4.

(42) Step 9: Generate input seeds for Public-Key Algorithm

(43) Perform Function 1:

(44) Take the fixed number associated with the finger position and multiply with number associated with the relevant segment. In our example this would be:

(45) n1×S1

(46) n2×S2

(47) n3×S3

(48) n4×S4

(49) Which equals:
5023×5963274521=29953527918983
68×9632547633=655013239044
7899×1234485369=9751199929731
555×7020002147=3896101191585

(50) Perform Function 2:

(51) Concatenate each of the results to form the input seed

(52) 29953527918983 & 655013239044 & 9751199929731 & 3896101191585=2995352791898365501323904497511999297313896101191585

(53) Perform Function 3:

(54) Split the input seed into two to create final input into the Public-key algorithm

(55) 299535279189836550132390449751199929 & 7313896101191585

(56) Step 10: Generate the Private & Public Key

(57) Public-key algorithm=Elliptic curve cryptography (ECC) (although it will be appreciated that any type of public-key algorithm may be used)

(58) This step is shown in FIG. 1.

(59) Step 11: Delete Private Key & Distribute Public Key

(60) This step is shown in FIG. 2.

(61) There is no need to save or store the private key anywhere since it can be generated at the point of use.

(62) Executing a Digital Signature in an Asymmetric Cryptographic System

(63) Step 1: Place finger on scanner in secret order of original sequence

(64) Finger 2 placed on scanner in first position (P1)=this generates finger print template

(65) Result: P1=Template 2

(66) Finger 3 placed on scanner in second position (P2)=this generates finger print template

(67) Result: P2=Template 3

(68) Finger 8 placed on scanner in third position (P3)=this generates finger print template

(69) Result: P3=Template 8

(70) Finger 1 placed on scanner in fourth position (P4)=this generates finger print template

(71) Result: P4=Template 1

(72) Step 2: Search and match fingerprint templates in database to receive corresponding raw segment data needed to generate input seed.

(73) Search Template 2=5963274521

(74) Search Template 3=9632547633

(75) Search Template 8=1234485369

(76) Search Template 1=7020002147

(77) Step 3: Perform function/s on segment data to generate Input Seeds

(78) Perform Function 1:

(79) Take the fixed number associated with the finger position and multiply with number associated with the relevant segment. In our example this would be:

(80) n1×S1

(81) n2×S2

(82) n3×S3

(83) n4×S4

(84) Which equals:
5023×5963274521=29953527918983
68×9632547633=655013239044
7899×1234485369=9751199929731
555×7020002147=3896101191585

(85) Perform Function 2:

(86) Concatenate each of the results to form the input seed

(87) 29953527918983 & 655013239044 & 9751199929731 & 3896101191585=2995352791898365501323904497511999297313896101191585

(88) Perform Function 3:

(89) Split the input seed into two to create final input into the Public-key algorithm

(90) 299535279189836550132390449751199929 & 7313896101191585

(91) With each scan of a fingerprint a part of the intermediate seed is revealed. Only if the correct fingerprints are scanned in a specific order, known only to the user, will the correct input seed be generated.

(92) Step 4: Submit input seeds to generate Private Key

(93) Public-key algorithm=Elliptic curve cryptography (ECC)

(94) This step is shown in FIG. 1.

(95) If fingerprints were scanned in the wrong order of sequence this would result in the creation of an incorrect input seed. This would in turn result in unsuccessful generation of the correct Private-key.

(96) Step 5: Use Private Key to perform digital signature

(97) S:=σ(Private Key, M)

(98) Where S=digital signature M=message

(99) If S & M are made public with the public key, a verification function can be performed to authenticate the digital signature.

(100) V (Public Key, M, S)

(101) Step 6: Delete Private key

(102) This step is shown in FIG. 2.

Example 2

(103) In this example one finger is used twice in a sequence length of four. Any finger can be used more than once in a given sequence length.

(104) Generating Private and Public Key

(105) Step 1: Register Fingerprints

(106) Scan each of the user's fingerprints, which will result in:

(107) Finger 1=Template 1; Finger 2=Template 2; Finger 3=Template 3;

(108) Finger 4=Template 4; Finger 5=Template 5; Finger 6=Template 6;

(109) Finger 7=Template 7; Finger 8=Template 8; Finger 9=Template 9;

(110) Finger 10=Template 10

(111) Step 2: Store all the fingerprint templates in a secure database.

(112) This step is shown in FIG. 3.

(113) Step 3: Create and register an order of sequence for input of fingerprints

(114) Secret sequence known only to the user:

(115) First position (P1)=Finger 2 (Template 2)

(116) Second Position (P2)=Finger 3 (Template 3)

(117) Third Position (P3)=Finger 2 (Template 2)

(118) Fourth Position (P4)=Finger 1 (Template 1)

(119) Step 4: Give each sequence position a fixed number

(120) First position=n1=5023

(121) Second Position=n2=68

(122) Third Position=n3=7899

(123) Fourth Position=n4=555

(124) The fixed numbers can be alphanumeric and of varying length

(125) Step 5: Generate an intermediate seed

(126) The random intermediate seed=5963274521963254763312344853697020002147 (this could also be alpha-numeric).

(127) Step 6: Split the intermediate seed into four segments:

(128) Segment 1 (S1)=5963274521

(129) Segment 2 (S2)=9632547633

(130) Segment 3 (S3)=1234485369

(131) Segment 4 (S4)=7020002147

(132) Step 7: Associate each segment with fingerprint

(133) Each segment of the intermediate seed will be associated with a fingerprint. The order of association will be determined by the order of position in the sequence. When a finger is used for a second or more time in a sequence then the position reference will be in front of the segment. For example Third position (P3) and Segment 3 (1234485369) will result in P31234485369.

(134) First position (P1)=Finger 2 (Template 2)=5963274521

(135) Second Position (P2)=Finger 3 (Template 3)=9632547633

(136) Third Position (P3)=Finger 2 (Template 2)=P31234485369

(137) Fourth Position (P4)=Finger 1 (Template 1)=7020002147

(138) Step 8: Store the results of steps 1; 2; 3; 5; 6; 7 in a secure database

(139) This step is shown as FIG. 5.

(140) Step 9: Generate input seeds for Public-Key Algorithm

(141) Perform function 1:

(142) Take the fixed number associated with the finger position and multiply with number associated with the relevant segment. In our example this would be:

(143) n1×S1

(144) n2×S2

(145) n3×S3

(146) n4×S4

(147) Which equals:
5023×5963274521=29953527918983
68×9632547633=655013239044
7899×1234485369=9751199929731
555×7020002147=3896101191585

(148) Perform Function 2:

(149) Concatenate each of the results to form the final input seed

(150) 29953527918983 & 655013239044 & 9751199929731 & 3896101191585=2995352791898365501323904497511999297313896101191585

(151) Perform Function 3:

(152) Split the input seed into two to create final input into the Public-key algorithm

(153) 299535279189836550132390449751199929 & 7313896101191585

(154) Step 10: Generate the Private & Public Key

(155) Public-key algorithm=Elliptic curve cryptography (ECC) (although it will be appreciated that any type of public-key algorithm may be used)

(156) This step is shown in FIG. 1.

(157) Step 11: Delete Private Key & Distribute Public Key

(158) This step is shown in FIG. 2.

(159) There is no need to save or store the private key anywhere since it can be generated at the point of use.

(160) Executing a digital signature in an asymmetric cryptographic system

(161) Step 1: Place finger on scanner in secret order of original sequence

(162) Finger 2 placed on scanner in first position (P1)=this generates finger print template

(163) Result: P1=Template 2

(164) Finger 3 placed on scanner in second position (P2)=this generates finger print template

(165) Result: P2=Template 3

(166) Finger 2 placed on scanner in third position (P3)=this generates finger print template

(167) Result: P3=Template 2

(168) Finger 1 placed on scanner in fourth position (P4)=this generates finger print template

(169) Result: P4=Template 1

(170) Step 2: Search and match fingerprint templates in database to receive corresponding raw segment data needed to generate input seed.

(171) Search Template 2=5963274521 & P31234485369

(172) Search Template 3=9632547633

(173) Search Template 2=5963274521 & P31234485369

(174) Search Template 1=7020002147

(175) A Sorting Logic will be applied: If more than one segment is returned for a position then priority is given to segments with “P”. If “P” is in the segment then the correct position (e.g. P1) must be in initial part of any segment for it to be accepted and the first two characters of the segment will be deleted from the segment. If the position does not match the initial characters in the segment then it will be rejected and priority will be given to the next segment with a “P”. If there are no position matches then the remaining segment without a “P” will be accepted. If there are no “P” in the segment it will be accepted without any alteration to the segment.

(176) Applying the Sorting Logic to first position P1:

(177) P31234485369 is given priority because it has “P”. But “P1” is not in the first two characters of the segment and therefore it is rejected.

(178) Because there is no “P”, P1=5963274521

(179) Appling the logic to second position P2:

(180) There is no “P” so P2=9632547633

(181) Appling the logic to third position P3:

(182) Where P3=5963274521 & P31234485369

(183) P31234485369 is given priority because it has “P”. And P3 is in the first two characters of the segment and therefore P3=1234485369

(184) Appling the logic to fourth position P4:

(185) There is no “P” so P4=7020002147

(186) Step 3: Perform function/s on segment data to generate Input Seeds

(187) Perform function 1:

(188) Take the fixed number associated with the finger position and multiply with number associated with the relevant segment. In our example this would be:

(189) n1×S1

(190) n2×S2

(191) n3×S3

(192) n4×S4

(193) Which equals:
5023×5963274521=29953527918983
68×9632547633=655013239044
7899×1234485369=9751199929731
555×7020002147=3896101191585

(194) Perform Function 2:

(195) Concatenate each of the results to form the final input seed

(196) 29953527918983 & 655013239044 & 9751199929731 & 3896101191585=2995352791898365501323904497511999297313896101191585

(197) Perform Function 3:

(198) Split the input seed into two to create final input into the Public-key algorithm

(199) 299535279189836550132390449751199929 & 7313896101191585

(200) With each scan of a fingerprint a part of the intermediate seed is revealed. Only if the correct fingerprints are scanned in a specific order, known only to the user, will the correct input seed be generated.

(201) Step 4: Submit input seeds to generate Private Key

(202) Public-key algorithm=Elliptic curve cryptography (ECC)

(203) This step is shown in FIG. 1.

(204) If fingerprints were scanned in the wrong order of sequence this would result in the creation of an incorrect input seed. This would in turn will result in unsuccessful generation of the correct Private-key.

(205) Step 5: Use Private Key to perform digital signature

(206) S:=σ(Private Key, M)

(207) Where S=digital signature M=message

(208) If S & M are made public with the public key, a verification function can be perform to authenticate the digital signature.

(209) V (Public Key, M, S)

(210) Step 6: Delete Private key

(211) This step is shown in FIG. 2.

(212) The above methods can have further variations:

(213) Biometric Features

(214) Biometric features are not limited to fingerprints. It is entirely possible to use this method/solution with other biometric features or a combination of biometric features. These biometric features could be, but not limited to facial-scan, finger vein, palm vein, iris-scan and voice. So you could have a scenario where the first input is a palm-scan, second input is a finger vein, third input is facial scan and finally the fourth input is an iris-scan. Again it is the order of sequence which is important.

(215) Dummy Seed Segments

(216) It may also be advantageous to generate and store additional seed segments in the parts of the database that have not already been populated with seed segments. An example database shown in FIG. 6 (modified from Example 1) could then contain a seed portion for additional finger templates. This could be some additional templates or could be every template (as shown below).

(217) This can be advantageous in the event that the secure database becomes compromised or a fraudster manages to spoof the biological data (for example with false fingerprints). The correct sequence (and knowledge of how to combine the sequence) is still required to obtain the seed value and hence the encryption key. Guessing the correct sequence of seed segments is made more difficult by having more seed segments stored in the database.

(218) Moreover, since multiple fingers can be used more than once in the same sequence, further additional seed segments may be added to the database as shown in FIG. 7 (modified from Example 2).

(219) This may further enhance the difficulty in guessing the correct sequence.

(220) Dummy Biometric Templates

(221) To make guessing the correct sequence harder still, dummy templates may be added to the database. These dummy templates may have still further dummy seed segments associated with them to further decrease the chances of a sequence being correctly guessed if the database becomes compromised.

(222) No Input Sequence Required

(223) In some implementations the user does not need to register a particular input sequence beforehand. The user may provide biometric information relating to a series of sources (for example, 10 fingerprints). The system will generate templates store these in the tables populated with seed portions then. A fixed input sequence will repeatably generate an encryption key. Therefore, it may not be necessary to register the sequence beforehand but only generate the key on the fly (and rely on the fact that the same key will be generated each time). If an incorrect sequence is entered then the system will generate an incorrect encryption key and security will not be compromised.

(224) Biometric Intermediate Seed

(225) One method of creating an intermediate seed is through random number generation, as discussed above. An alternative is to use the digital templates derived from biometric features themselves. This would make the intermediate seed unique, random and non-repudiable. The intermediate seed can also be a portion of the whole digital template (derived from biometric features like fingerprints).

(226) Another variation is that instead of generating one random intermediate seed and splitting it into several parts for each finger, a random intermediate seed can be generated for each finger. In this way, each fingerprint template will have an associated randomly generated intermediate input seed.

(227) Method or Function Applied to Segment Data for Generating Input Seed

(228) This variation will be the same for step 9 in “Generating Private and Public Key” and Step 3 in “Executing a digital signature in an asymmetric cryptographic system”.

(229) Variation 1

(230) Carry out entire Step 9/Step 3 and then add a fixed alphanumeric key

(231) Alphanumeric Key=12rt888J (for example)

(232) 2995352791898365501323904497511999297313896101191585 & 12rt888J=299535279189836550132390449751199929731389610119158512rt888J

(233) Variation 2

(234) Take the fixed number associated with the finger position and multiply with number associated with the relevant segment. In our example this would be:

(235) n1×S1

(236) n2×S2

(237) n3×S3

(238) n4×S4

(239) Which equals:
5023×5963274521=29953527918983
68×9632547633=655013239044
7899×1234485369=9751199929731
555×7020002147=3896101191585

(240) Sum the outputs (rather than concatenate):

(241) 29953527918983+655013239044+9751199929731+3896101191585=44255842279343

(242) Additionally, or alternatively, one or more other mathematical functions may be performed on the segment data (and/or data based at least in part on the segment data) to generate the input seed. Is it required that the function be non-commutative to generate the input seed, but may involve commutative operations. For example one or more of addition, subtraction, division, multiplication, concatenation, etc. may be used.

(243) In the example given above, the modified seed segments are summed together. Addition is a commutative operation. However, the overall function to combine the segments to generate the input seed is non-commutative. This is because each segment is multiplied by a different factor, depending on the position of the segment in the sequence. Indeed the factors could be chosen so that the function is equivalent to concatenation by setting the factors in the following way.

(244) n1=10.sup.30

(245) n2=10.sup.20

(246) n3=10.sup.10

(247) n4=1

Other Variations

(248) Apply numerous mathematical functions to segment data.

Example 1

(249) The seed value could be formed by taking the Log of each output and apply addition or concatenation:
Log(n1×S1)+Log(n2×S2)+Log(n3×S3)+Log(n4×S4)

Example 2

(250) Another alternative could be to concatenate (or perform any other non-commutative operation on) the segment data to arrive directly at the input seed (i.e., not having to multiply each item of segment data with the associated fixed number n1-n4):

(251) Concatenate (S1) & (S2) & (S3) & (S4)

(252) 5963274521 & 9632547633 & 1234485369 & 7020002147=5963274521963254763312344853697020002147

(253) Or the Log values of the segments could be concatenated:

(254) Log(S1) & Log(S2) & Log(S3) & Log(S4)

(255) Segmenting the Intermediate Seed

(256) This applies to Step 6 in “Generating Private and Public Key”

(257) Split the intermediate seed into four segments:

(258) Segment 1 (51)=5963274521

(259) Segment 2 (S2)=9632547633

(260) Segment 3 (S3)=1234485369

(261) Segment 4 (S4)=7020002147

(262) The segment lengths do not have to be the same number of digits. They can vary in length.

Example

(263) Segment 1 (S1)=59632745

(264) Segment 2 (S2)=219632547633

(265) Segment 3 (S3)=12344

(266) Segment 4 (S4)=853697020002147

OTHER SCENARIOS

(267) Biometric Input Devices:

(268) Fingerprint readers; Iris scanners; Palm vein readers; Finger vein readers, Facial recognition cameras.

(269) Random number generation can be through any algorithm.

(270) In the above examples, the sequence length is four. However, the above described processes may be applied to biometric sequences of any length of two or more.